aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/cpufreq/Kconfig24
-rw-r--r--drivers/cpufreq/Makefile1
-rw-r--r--drivers/cpufreq/cpufreq.c8
-rw-r--r--drivers/cpufreq/cpufreq_conservative.c586
-rw-r--r--drivers/cpufreq/cpufreq_ondemand.c180
-rw-r--r--drivers/cpufreq/cpufreq_stats.c47
-rw-r--r--drivers/firmware/pcdp.c1
-rw-r--r--drivers/ide/pci/amd74xx.c3
-rw-r--r--drivers/pci/hotplug/cpci_hotplug_core.c302
-rw-r--r--drivers/pci/hotplug/cpci_hotplug_pci.c144
-rw-r--r--drivers/pci/hotplug/shpchprm_acpi.c4
11 files changed, 934 insertions, 366 deletions
diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig
index 95882bb1950e..60c9be99c6d9 100644
--- a/drivers/cpufreq/Kconfig
+++ b/drivers/cpufreq/Kconfig
@@ -46,6 +46,10 @@ config CPU_FREQ_STAT_DETAILS
46 This will show detail CPU frequency translation table in sysfs file 46 This will show detail CPU frequency translation table in sysfs file
47 system 47 system
48 48
49# Note that it is not currently possible to set the other governors (such as ondemand)
50# as the default, since if they fail to initialise, cpufreq will be
51# left in an undefined state.
52
49choice 53choice
50 prompt "Default CPUFreq governor" 54 prompt "Default CPUFreq governor"
51 default CPU_FREQ_DEFAULT_GOV_USERSPACE if CPU_FREQ_SA1100 || CPU_FREQ_SA1110 55 default CPU_FREQ_DEFAULT_GOV_USERSPACE if CPU_FREQ_SA1100 || CPU_FREQ_SA1110
@@ -115,4 +119,24 @@ config CPU_FREQ_GOV_ONDEMAND
115 119
116 If in doubt, say N. 120 If in doubt, say N.
117 121
122config CPU_FREQ_GOV_CONSERVATIVE
123 tristate "'conservative' cpufreq governor"
124 depends on CPU_FREQ
125 help
126 'conservative' - this driver is rather similar to the 'ondemand'
127 governor both in its source code and its purpose, the difference is
128 its optimisation for better suitability in a battery powered
129 environment. The frequency is gracefully increased and decreased
130 rather than jumping to 100% when speed is required.
131
132 If you have a desktop machine then you should really be considering
133 the 'ondemand' governor instead, however if you are using a laptop,
134 PDA or even an AMD64 based computer (due to the unacceptable
135 step-by-step latency issues between the minimum and maximum frequency
136 transitions in the CPU) you will probably want to use this governor.
137
138 For details, take a look at linux/Documentation/cpu-freq.
139
140 If in doubt, say N.
141
118endif # CPU_FREQ 142endif # CPU_FREQ
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index 67b16e5a41a7..71fc3b4173f1 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_CPU_FREQ_GOV_PERFORMANCE) += cpufreq_performance.o
8obj-$(CONFIG_CPU_FREQ_GOV_POWERSAVE) += cpufreq_powersave.o 8obj-$(CONFIG_CPU_FREQ_GOV_POWERSAVE) += cpufreq_powersave.o
9obj-$(CONFIG_CPU_FREQ_GOV_USERSPACE) += cpufreq_userspace.o 9obj-$(CONFIG_CPU_FREQ_GOV_USERSPACE) += cpufreq_userspace.o
10obj-$(CONFIG_CPU_FREQ_GOV_ONDEMAND) += cpufreq_ondemand.o 10obj-$(CONFIG_CPU_FREQ_GOV_ONDEMAND) += cpufreq_ondemand.o
11obj-$(CONFIG_CPU_FREQ_GOV_CONSERVATIVE) += cpufreq_conservative.o
11 12
12# CPUfreq cross-arch helpers 13# CPUfreq cross-arch helpers
13obj-$(CONFIG_CPU_FREQ_TABLE) += freq_table.o 14obj-$(CONFIG_CPU_FREQ_TABLE) += freq_table.o
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 8e561313d094..03b5fb2ddcf4 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -258,7 +258,7 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
258 (likely(cpufreq_cpu_data[freqs->cpu]->cur)) && 258 (likely(cpufreq_cpu_data[freqs->cpu]->cur)) &&
259 (unlikely(freqs->old != cpufreq_cpu_data[freqs->cpu]->cur))) 259 (unlikely(freqs->old != cpufreq_cpu_data[freqs->cpu]->cur)))
260 { 260 {
261 printk(KERN_WARNING "Warning: CPU frequency is %u, " 261 dprintk(KERN_WARNING "Warning: CPU frequency is %u, "
262 "cpufreq assumed %u kHz.\n", freqs->old, cpufreq_cpu_data[freqs->cpu]->cur); 262 "cpufreq assumed %u kHz.\n", freqs->old, cpufreq_cpu_data[freqs->cpu]->cur);
263 freqs->old = cpufreq_cpu_data[freqs->cpu]->cur; 263 freqs->old = cpufreq_cpu_data[freqs->cpu]->cur;
264 } 264 }
@@ -814,7 +814,7 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigne
814{ 814{
815 struct cpufreq_freqs freqs; 815 struct cpufreq_freqs freqs;
816 816
817 printk(KERN_WARNING "Warning: CPU frequency out of sync: cpufreq and timing " 817 dprintk(KERN_WARNING "Warning: CPU frequency out of sync: cpufreq and timing "
818 "core thinks of %u, is %u kHz.\n", old_freq, new_freq); 818 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
819 819
820 freqs.cpu = cpu; 820 freqs.cpu = cpu;
@@ -923,7 +923,7 @@ static int cpufreq_suspend(struct sys_device * sysdev, u32 state)
923 struct cpufreq_freqs freqs; 923 struct cpufreq_freqs freqs;
924 924
925 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) 925 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
926 printk(KERN_DEBUG "Warning: CPU frequency is %u, " 926 dprintk(KERN_DEBUG "Warning: CPU frequency is %u, "
927 "cpufreq assumed %u kHz.\n", 927 "cpufreq assumed %u kHz.\n",
928 cur_freq, cpu_policy->cur); 928 cur_freq, cpu_policy->cur);
929 929
@@ -1004,7 +1004,7 @@ static int cpufreq_resume(struct sys_device * sysdev)
1004 struct cpufreq_freqs freqs; 1004 struct cpufreq_freqs freqs;
1005 1005
1006 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) 1006 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
1007 printk(KERN_WARNING "Warning: CPU frequency" 1007 dprintk(KERN_WARNING "Warning: CPU frequency"
1008 "is %u, cpufreq assumed %u kHz.\n", 1008 "is %u, cpufreq assumed %u kHz.\n",
1009 cur_freq, cpu_policy->cur); 1009 cur_freq, cpu_policy->cur);
1010 1010
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
new file mode 100644
index 000000000000..e1df376e709e
--- /dev/null
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -0,0 +1,586 @@
1/*
2 * drivers/cpufreq/cpufreq_conservative.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
6 * Jun Nakajima <jun.nakajima@intel.com>
7 * (C) 2004 Alexander Clouter <alex-kernel@digriz.org.uk>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/smp.h>
17#include <linux/init.h>
18#include <linux/interrupt.h>
19#include <linux/ctype.h>
20#include <linux/cpufreq.h>
21#include <linux/sysctl.h>
22#include <linux/types.h>
23#include <linux/fs.h>
24#include <linux/sysfs.h>
25#include <linux/sched.h>
26#include <linux/kmod.h>
27#include <linux/workqueue.h>
28#include <linux/jiffies.h>
29#include <linux/kernel_stat.h>
30#include <linux/percpu.h>
31
32/*
33 * dbs is used in this file as a shortform for demandbased switching
34 * It helps to keep variable names smaller, simpler
35 */
36
37#define DEF_FREQUENCY_UP_THRESHOLD (80)
38#define MIN_FREQUENCY_UP_THRESHOLD (0)
39#define MAX_FREQUENCY_UP_THRESHOLD (100)
40
41#define DEF_FREQUENCY_DOWN_THRESHOLD (20)
42#define MIN_FREQUENCY_DOWN_THRESHOLD (0)
43#define MAX_FREQUENCY_DOWN_THRESHOLD (100)
44
45/*
46 * The polling frequency of this governor depends on the capability of
47 * the processor. Default polling frequency is 1000 times the transition
48 * latency of the processor. The governor will work on any processor with
49 * transition latency <= 10mS, using appropriate sampling
50 * rate.
51 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
52 * this governor will not work.
53 * All times here are in uS.
54 */
55static unsigned int def_sampling_rate;
56#define MIN_SAMPLING_RATE (def_sampling_rate / 2)
57#define MAX_SAMPLING_RATE (500 * def_sampling_rate)
58#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER (100000)
59#define DEF_SAMPLING_DOWN_FACTOR (5)
60#define TRANSITION_LATENCY_LIMIT (10 * 1000)
61
62static void do_dbs_timer(void *data);
63
64struct cpu_dbs_info_s {
65 struct cpufreq_policy *cur_policy;
66 unsigned int prev_cpu_idle_up;
67 unsigned int prev_cpu_idle_down;
68 unsigned int enable;
69};
70static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
71
72static unsigned int dbs_enable; /* number of CPUs using this policy */
73
74static DECLARE_MUTEX (dbs_sem);
75static DECLARE_WORK (dbs_work, do_dbs_timer, NULL);
76
77struct dbs_tuners {
78 unsigned int sampling_rate;
79 unsigned int sampling_down_factor;
80 unsigned int up_threshold;
81 unsigned int down_threshold;
82 unsigned int ignore_nice;
83 unsigned int freq_step;
84};
85
86static struct dbs_tuners dbs_tuners_ins = {
87 .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
88 .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD,
89 .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,
90};
91
92static inline unsigned int get_cpu_idle_time(unsigned int cpu)
93{
94 return kstat_cpu(cpu).cpustat.idle +
95 kstat_cpu(cpu).cpustat.iowait +
96 ( !dbs_tuners_ins.ignore_nice ?
97 kstat_cpu(cpu).cpustat.nice :
98 0);
99}
100
101/************************** sysfs interface ************************/
102static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
103{
104 return sprintf (buf, "%u\n", MAX_SAMPLING_RATE);
105}
106
107static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
108{
109 return sprintf (buf, "%u\n", MIN_SAMPLING_RATE);
110}
111
112#define define_one_ro(_name) \
113static struct freq_attr _name = \
114__ATTR(_name, 0444, show_##_name, NULL)
115
116define_one_ro(sampling_rate_max);
117define_one_ro(sampling_rate_min);
118
119/* cpufreq_conservative Governor Tunables */
120#define show_one(file_name, object) \
121static ssize_t show_##file_name \
122(struct cpufreq_policy *unused, char *buf) \
123{ \
124 return sprintf(buf, "%u\n", dbs_tuners_ins.object); \
125}
126show_one(sampling_rate, sampling_rate);
127show_one(sampling_down_factor, sampling_down_factor);
128show_one(up_threshold, up_threshold);
129show_one(down_threshold, down_threshold);
130show_one(ignore_nice, ignore_nice);
131show_one(freq_step, freq_step);
132
133static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
134 const char *buf, size_t count)
135{
136 unsigned int input;
137 int ret;
138 ret = sscanf (buf, "%u", &input);
139 if (ret != 1 )
140 return -EINVAL;
141
142 down(&dbs_sem);
143 dbs_tuners_ins.sampling_down_factor = input;
144 up(&dbs_sem);
145
146 return count;
147}
148
149static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
150 const char *buf, size_t count)
151{
152 unsigned int input;
153 int ret;
154 ret = sscanf (buf, "%u", &input);
155
156 down(&dbs_sem);
157 if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
158 up(&dbs_sem);
159 return -EINVAL;
160 }
161
162 dbs_tuners_ins.sampling_rate = input;
163 up(&dbs_sem);
164
165 return count;
166}
167
168static ssize_t store_up_threshold(struct cpufreq_policy *unused,
169 const char *buf, size_t count)
170{
171 unsigned int input;
172 int ret;
173 ret = sscanf (buf, "%u", &input);
174
175 down(&dbs_sem);
176 if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
177 input < MIN_FREQUENCY_UP_THRESHOLD ||
178 input <= dbs_tuners_ins.down_threshold) {
179 up(&dbs_sem);
180 return -EINVAL;
181 }
182
183 dbs_tuners_ins.up_threshold = input;
184 up(&dbs_sem);
185
186 return count;
187}
188
189static ssize_t store_down_threshold(struct cpufreq_policy *unused,
190 const char *buf, size_t count)
191{
192 unsigned int input;
193 int ret;
194 ret = sscanf (buf, "%u", &input);
195
196 down(&dbs_sem);
197 if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD ||
198 input < MIN_FREQUENCY_DOWN_THRESHOLD ||
199 input >= dbs_tuners_ins.up_threshold) {
200 up(&dbs_sem);
201 return -EINVAL;
202 }
203
204 dbs_tuners_ins.down_threshold = input;
205 up(&dbs_sem);
206
207 return count;
208}
209
210static ssize_t store_ignore_nice(struct cpufreq_policy *policy,
211 const char *buf, size_t count)
212{
213 unsigned int input;
214 int ret;
215
216 unsigned int j;
217
218 ret = sscanf (buf, "%u", &input);
219 if ( ret != 1 )
220 return -EINVAL;
221
222 if ( input > 1 )
223 input = 1;
224
225 down(&dbs_sem);
226 if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
227 up(&dbs_sem);
228 return count;
229 }
230 dbs_tuners_ins.ignore_nice = input;
231
232 /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
233 for_each_online_cpu(j) {
234 struct cpu_dbs_info_s *j_dbs_info;
235 j_dbs_info = &per_cpu(cpu_dbs_info, j);
236 j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
237 j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
238 }
239 up(&dbs_sem);
240
241 return count;
242}
243
244static ssize_t store_freq_step(struct cpufreq_policy *policy,
245 const char *buf, size_t count)
246{
247 unsigned int input;
248 int ret;
249
250 ret = sscanf (buf, "%u", &input);
251
252 if ( ret != 1 )
253 return -EINVAL;
254
255 if ( input > 100 )
256 input = 100;
257
258 /* no need to test here if freq_step is zero as the user might actually
259 * want this, they would be crazy though :) */
260 down(&dbs_sem);
261 dbs_tuners_ins.freq_step = input;
262 up(&dbs_sem);
263
264 return count;
265}
266
267#define define_one_rw(_name) \
268static struct freq_attr _name = \
269__ATTR(_name, 0644, show_##_name, store_##_name)
270
271define_one_rw(sampling_rate);
272define_one_rw(sampling_down_factor);
273define_one_rw(up_threshold);
274define_one_rw(down_threshold);
275define_one_rw(ignore_nice);
276define_one_rw(freq_step);
277
278static struct attribute * dbs_attributes[] = {
279 &sampling_rate_max.attr,
280 &sampling_rate_min.attr,
281 &sampling_rate.attr,
282 &sampling_down_factor.attr,
283 &up_threshold.attr,
284 &down_threshold.attr,
285 &ignore_nice.attr,
286 &freq_step.attr,
287 NULL
288};
289
290static struct attribute_group dbs_attr_group = {
291 .attrs = dbs_attributes,
292 .name = "conservative",
293};
294
295/************************** sysfs end ************************/
296
297static void dbs_check_cpu(int cpu)
298{
299 unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
300 unsigned int freq_step;
301 unsigned int freq_down_sampling_rate;
302 static int down_skip[NR_CPUS];
303 static int requested_freq[NR_CPUS];
304 static unsigned short init_flag = 0;
305 struct cpu_dbs_info_s *this_dbs_info;
306 struct cpu_dbs_info_s *dbs_info;
307
308 struct cpufreq_policy *policy;
309 unsigned int j;
310
311 this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
312 if (!this_dbs_info->enable)
313 return;
314
315 policy = this_dbs_info->cur_policy;
316
317 if ( init_flag == 0 ) {
318 for ( /* NULL */; init_flag < NR_CPUS; init_flag++ ) {
319 dbs_info = &per_cpu(cpu_dbs_info, init_flag);
320 requested_freq[cpu] = dbs_info->cur_policy->cur;
321 }
322 init_flag = 1;
323 }
324
325 /*
326 * The default safe range is 20% to 80%
327 * Every sampling_rate, we check
328 * - If current idle time is less than 20%, then we try to
329 * increase frequency
330 * Every sampling_rate*sampling_down_factor, we check
331 * - If current idle time is more than 80%, then we try to
332 * decrease frequency
333 *
334 * Any frequency increase takes it to the maximum frequency.
335 * Frequency reduction happens at minimum steps of
336 * 5% (default) of max_frequency
337 */
338
339 /* Check for frequency increase */
340
341 idle_ticks = UINT_MAX;
342 for_each_cpu_mask(j, policy->cpus) {
343 unsigned int tmp_idle_ticks, total_idle_ticks;
344 struct cpu_dbs_info_s *j_dbs_info;
345
346 j_dbs_info = &per_cpu(cpu_dbs_info, j);
347 /* Check for frequency increase */
348 total_idle_ticks = get_cpu_idle_time(j);
349 tmp_idle_ticks = total_idle_ticks -
350 j_dbs_info->prev_cpu_idle_up;
351 j_dbs_info->prev_cpu_idle_up = total_idle_ticks;
352
353 if (tmp_idle_ticks < idle_ticks)
354 idle_ticks = tmp_idle_ticks;
355 }
356
357 /* Scale idle ticks by 100 and compare with up and down ticks */
358 idle_ticks *= 100;
359 up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
360 usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
361
362 if (idle_ticks < up_idle_ticks) {
363 down_skip[cpu] = 0;
364 for_each_cpu_mask(j, policy->cpus) {
365 struct cpu_dbs_info_s *j_dbs_info;
366
367 j_dbs_info = &per_cpu(cpu_dbs_info, j);
368 j_dbs_info->prev_cpu_idle_down =
369 j_dbs_info->prev_cpu_idle_up;
370 }
371 /* if we are already at full speed then break out early */
372 if (requested_freq[cpu] == policy->max)
373 return;
374
375 freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
376
377 /* max freq cannot be less than 100. But who knows.... */
378 if (unlikely(freq_step == 0))
379 freq_step = 5;
380
381 requested_freq[cpu] += freq_step;
382 if (requested_freq[cpu] > policy->max)
383 requested_freq[cpu] = policy->max;
384
385 __cpufreq_driver_target(policy, requested_freq[cpu],
386 CPUFREQ_RELATION_H);
387 return;
388 }
389
390 /* Check for frequency decrease */
391 down_skip[cpu]++;
392 if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)
393 return;
394
395 idle_ticks = UINT_MAX;
396 for_each_cpu_mask(j, policy->cpus) {
397 unsigned int tmp_idle_ticks, total_idle_ticks;
398 struct cpu_dbs_info_s *j_dbs_info;
399
400 j_dbs_info = &per_cpu(cpu_dbs_info, j);
401 total_idle_ticks = j_dbs_info->prev_cpu_idle_up;
402 tmp_idle_ticks = total_idle_ticks -
403 j_dbs_info->prev_cpu_idle_down;
404 j_dbs_info->prev_cpu_idle_down = total_idle_ticks;
405
406 if (tmp_idle_ticks < idle_ticks)
407 idle_ticks = tmp_idle_ticks;
408 }
409
410 /* Scale idle ticks by 100 and compare with up and down ticks */
411 idle_ticks *= 100;
412 down_skip[cpu] = 0;
413
414 freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
415 dbs_tuners_ins.sampling_down_factor;
416 down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
417 usecs_to_jiffies(freq_down_sampling_rate);
418
419 if (idle_ticks > down_idle_ticks) {
420 /* if we are already at the lowest speed then break out early
421 * or if we 'cannot' reduce the speed as the user might want
422 * freq_step to be zero */
423 if (requested_freq[cpu] == policy->min
424 || dbs_tuners_ins.freq_step == 0)
425 return;
426
427 freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
428
429 /* max freq cannot be less than 100. But who knows.... */
430 if (unlikely(freq_step == 0))
431 freq_step = 5;
432
433 requested_freq[cpu] -= freq_step;
434 if (requested_freq[cpu] < policy->min)
435 requested_freq[cpu] = policy->min;
436
437 __cpufreq_driver_target(policy,
438 requested_freq[cpu],
439 CPUFREQ_RELATION_H);
440 return;
441 }
442}
443
444static void do_dbs_timer(void *data)
445{
446 int i;
447 down(&dbs_sem);
448 for_each_online_cpu(i)
449 dbs_check_cpu(i);
450 schedule_delayed_work(&dbs_work,
451 usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
452 up(&dbs_sem);
453}
454
455static inline void dbs_timer_init(void)
456{
457 INIT_WORK(&dbs_work, do_dbs_timer, NULL);
458 schedule_delayed_work(&dbs_work,
459 usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
460 return;
461}
462
463static inline void dbs_timer_exit(void)
464{
465 cancel_delayed_work(&dbs_work);
466 return;
467}
468
469static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
470 unsigned int event)
471{
472 unsigned int cpu = policy->cpu;
473 struct cpu_dbs_info_s *this_dbs_info;
474 unsigned int j;
475
476 this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
477
478 switch (event) {
479 case CPUFREQ_GOV_START:
480 if ((!cpu_online(cpu)) ||
481 (!policy->cur))
482 return -EINVAL;
483
484 if (policy->cpuinfo.transition_latency >
485 (TRANSITION_LATENCY_LIMIT * 1000))
486 return -EINVAL;
487 if (this_dbs_info->enable) /* Already enabled */
488 break;
489
490 down(&dbs_sem);
491 for_each_cpu_mask(j, policy->cpus) {
492 struct cpu_dbs_info_s *j_dbs_info;
493 j_dbs_info = &per_cpu(cpu_dbs_info, j);
494 j_dbs_info->cur_policy = policy;
495
496 j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
497 j_dbs_info->prev_cpu_idle_down
498 = j_dbs_info->prev_cpu_idle_up;
499 }
500 this_dbs_info->enable = 1;
501 sysfs_create_group(&policy->kobj, &dbs_attr_group);
502 dbs_enable++;
503 /*
504 * Start the timerschedule work, when this governor
505 * is used for first time
506 */
507 if (dbs_enable == 1) {
508 unsigned int latency;
509 /* policy latency is in nS. Convert it to uS first */
510
511 latency = policy->cpuinfo.transition_latency;
512 if (latency < 1000)
513 latency = 1000;
514
515 def_sampling_rate = (latency / 1000) *
516 DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
517 dbs_tuners_ins.sampling_rate = def_sampling_rate;
518 dbs_tuners_ins.ignore_nice = 0;
519 dbs_tuners_ins.freq_step = 5;
520
521 dbs_timer_init();
522 }
523
524 up(&dbs_sem);
525 break;
526
527 case CPUFREQ_GOV_STOP:
528 down(&dbs_sem);
529 this_dbs_info->enable = 0;
530 sysfs_remove_group(&policy->kobj, &dbs_attr_group);
531 dbs_enable--;
532 /*
533 * Stop the timerschedule work, when this governor
534 * is used for first time
535 */
536 if (dbs_enable == 0)
537 dbs_timer_exit();
538
539 up(&dbs_sem);
540
541 break;
542
543 case CPUFREQ_GOV_LIMITS:
544 down(&dbs_sem);
545 if (policy->max < this_dbs_info->cur_policy->cur)
546 __cpufreq_driver_target(
547 this_dbs_info->cur_policy,
548 policy->max, CPUFREQ_RELATION_H);
549 else if (policy->min > this_dbs_info->cur_policy->cur)
550 __cpufreq_driver_target(
551 this_dbs_info->cur_policy,
552 policy->min, CPUFREQ_RELATION_L);
553 up(&dbs_sem);
554 break;
555 }
556 return 0;
557}
558
559static struct cpufreq_governor cpufreq_gov_dbs = {
560 .name = "conservative",
561 .governor = cpufreq_governor_dbs,
562 .owner = THIS_MODULE,
563};
564
565static int __init cpufreq_gov_dbs_init(void)
566{
567 return cpufreq_register_governor(&cpufreq_gov_dbs);
568}
569
570static void __exit cpufreq_gov_dbs_exit(void)
571{
572 /* Make sure that the scheduled work is indeed not running */
573 flush_scheduled_work();
574
575 cpufreq_unregister_governor(&cpufreq_gov_dbs);
576}
577
578
579MODULE_AUTHOR ("Alexander Clouter <alex-kernel@digriz.org.uk>");
580MODULE_DESCRIPTION ("'cpufreq_conservative' - A dynamic cpufreq governor for "
581 "Low Latency Frequency Transition capable processors "
582 "optimised for use in a battery environment");
583MODULE_LICENSE ("GPL");
584
585module_init(cpufreq_gov_dbs_init);
586module_exit(cpufreq_gov_dbs_exit);
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 8d83a21c6477..c1fc9c62bb51 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -34,13 +34,9 @@
34 */ 34 */
35 35
36#define DEF_FREQUENCY_UP_THRESHOLD (80) 36#define DEF_FREQUENCY_UP_THRESHOLD (80)
37#define MIN_FREQUENCY_UP_THRESHOLD (0) 37#define MIN_FREQUENCY_UP_THRESHOLD (11)
38#define MAX_FREQUENCY_UP_THRESHOLD (100) 38#define MAX_FREQUENCY_UP_THRESHOLD (100)
39 39
40#define DEF_FREQUENCY_DOWN_THRESHOLD (20)
41#define MIN_FREQUENCY_DOWN_THRESHOLD (0)
42#define MAX_FREQUENCY_DOWN_THRESHOLD (100)
43
44/* 40/*
45 * The polling frequency of this governor depends on the capability of 41 * The polling frequency of this governor depends on the capability of
46 * the processor. Default polling frequency is 1000 times the transition 42 * the processor. Default polling frequency is 1000 times the transition
@@ -55,9 +51,9 @@ static unsigned int def_sampling_rate;
55#define MIN_SAMPLING_RATE (def_sampling_rate / 2) 51#define MIN_SAMPLING_RATE (def_sampling_rate / 2)
56#define MAX_SAMPLING_RATE (500 * def_sampling_rate) 52#define MAX_SAMPLING_RATE (500 * def_sampling_rate)
57#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER (1000) 53#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER (1000)
58#define DEF_SAMPLING_DOWN_FACTOR (10) 54#define DEF_SAMPLING_DOWN_FACTOR (1)
55#define MAX_SAMPLING_DOWN_FACTOR (10)
59#define TRANSITION_LATENCY_LIMIT (10 * 1000) 56#define TRANSITION_LATENCY_LIMIT (10 * 1000)
60#define sampling_rate_in_HZ(x) (((x * HZ) < (1000 * 1000))?1:((x * HZ) / (1000 * 1000)))
61 57
62static void do_dbs_timer(void *data); 58static void do_dbs_timer(void *data);
63 59
@@ -78,15 +74,23 @@ struct dbs_tuners {
78 unsigned int sampling_rate; 74 unsigned int sampling_rate;
79 unsigned int sampling_down_factor; 75 unsigned int sampling_down_factor;
80 unsigned int up_threshold; 76 unsigned int up_threshold;
81 unsigned int down_threshold; 77 unsigned int ignore_nice;
82}; 78};
83 79
84static struct dbs_tuners dbs_tuners_ins = { 80static struct dbs_tuners dbs_tuners_ins = {
85 .up_threshold = DEF_FREQUENCY_UP_THRESHOLD, 81 .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
86 .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD,
87 .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR, 82 .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,
88}; 83};
89 84
85static inline unsigned int get_cpu_idle_time(unsigned int cpu)
86{
87 return kstat_cpu(cpu).cpustat.idle +
88 kstat_cpu(cpu).cpustat.iowait +
89 ( !dbs_tuners_ins.ignore_nice ?
90 kstat_cpu(cpu).cpustat.nice :
91 0);
92}
93
90/************************** sysfs interface ************************/ 94/************************** sysfs interface ************************/
91static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf) 95static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
92{ 96{
@@ -115,7 +119,7 @@ static ssize_t show_##file_name \
115show_one(sampling_rate, sampling_rate); 119show_one(sampling_rate, sampling_rate);
116show_one(sampling_down_factor, sampling_down_factor); 120show_one(sampling_down_factor, sampling_down_factor);
117show_one(up_threshold, up_threshold); 121show_one(up_threshold, up_threshold);
118show_one(down_threshold, down_threshold); 122show_one(ignore_nice, ignore_nice);
119 123
120static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, 124static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
121 const char *buf, size_t count) 125 const char *buf, size_t count)
@@ -126,6 +130,9 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
126 if (ret != 1 ) 130 if (ret != 1 )
127 return -EINVAL; 131 return -EINVAL;
128 132
133 if (input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
134 return -EINVAL;
135
129 down(&dbs_sem); 136 down(&dbs_sem);
130 dbs_tuners_ins.sampling_down_factor = input; 137 dbs_tuners_ins.sampling_down_factor = input;
131 up(&dbs_sem); 138 up(&dbs_sem);
@@ -161,8 +168,7 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
161 168
162 down(&dbs_sem); 169 down(&dbs_sem);
163 if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || 170 if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
164 input < MIN_FREQUENCY_UP_THRESHOLD || 171 input < MIN_FREQUENCY_UP_THRESHOLD) {
165 input <= dbs_tuners_ins.down_threshold) {
166 up(&dbs_sem); 172 up(&dbs_sem);
167 return -EINVAL; 173 return -EINVAL;
168 } 174 }
@@ -173,22 +179,35 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
173 return count; 179 return count;
174} 180}
175 181
176static ssize_t store_down_threshold(struct cpufreq_policy *unused, 182static ssize_t store_ignore_nice(struct cpufreq_policy *policy,
177 const char *buf, size_t count) 183 const char *buf, size_t count)
178{ 184{
179 unsigned int input; 185 unsigned int input;
180 int ret; 186 int ret;
187
188 unsigned int j;
189
181 ret = sscanf (buf, "%u", &input); 190 ret = sscanf (buf, "%u", &input);
191 if ( ret != 1 )
192 return -EINVAL;
182 193
194 if ( input > 1 )
195 input = 1;
196
183 down(&dbs_sem); 197 down(&dbs_sem);
184 if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD || 198 if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
185 input < MIN_FREQUENCY_DOWN_THRESHOLD ||
186 input >= dbs_tuners_ins.up_threshold) {
187 up(&dbs_sem); 199 up(&dbs_sem);
188 return -EINVAL; 200 return count;
189 } 201 }
202 dbs_tuners_ins.ignore_nice = input;
190 203
191 dbs_tuners_ins.down_threshold = input; 204 /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
205 for_each_online_cpu(j) {
206 struct cpu_dbs_info_s *j_dbs_info;
207 j_dbs_info = &per_cpu(cpu_dbs_info, j);
208 j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
209 j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
210 }
192 up(&dbs_sem); 211 up(&dbs_sem);
193 212
194 return count; 213 return count;
@@ -201,7 +220,7 @@ __ATTR(_name, 0644, show_##_name, store_##_name)
201define_one_rw(sampling_rate); 220define_one_rw(sampling_rate);
202define_one_rw(sampling_down_factor); 221define_one_rw(sampling_down_factor);
203define_one_rw(up_threshold); 222define_one_rw(up_threshold);
204define_one_rw(down_threshold); 223define_one_rw(ignore_nice);
205 224
206static struct attribute * dbs_attributes[] = { 225static struct attribute * dbs_attributes[] = {
207 &sampling_rate_max.attr, 226 &sampling_rate_max.attr,
@@ -209,7 +228,7 @@ static struct attribute * dbs_attributes[] = {
209 &sampling_rate.attr, 228 &sampling_rate.attr,
210 &sampling_down_factor.attr, 229 &sampling_down_factor.attr,
211 &up_threshold.attr, 230 &up_threshold.attr,
212 &down_threshold.attr, 231 &ignore_nice.attr,
213 NULL 232 NULL
214}; 233};
215 234
@@ -222,9 +241,8 @@ static struct attribute_group dbs_attr_group = {
222 241
223static void dbs_check_cpu(int cpu) 242static void dbs_check_cpu(int cpu)
224{ 243{
225 unsigned int idle_ticks, up_idle_ticks, down_idle_ticks; 244 unsigned int idle_ticks, up_idle_ticks, total_ticks;
226 unsigned int total_idle_ticks; 245 unsigned int freq_next;
227 unsigned int freq_down_step;
228 unsigned int freq_down_sampling_rate; 246 unsigned int freq_down_sampling_rate;
229 static int down_skip[NR_CPUS]; 247 static int down_skip[NR_CPUS];
230 struct cpu_dbs_info_s *this_dbs_info; 248 struct cpu_dbs_info_s *this_dbs_info;
@@ -238,38 +256,25 @@ static void dbs_check_cpu(int cpu)
238 256
239 policy = this_dbs_info->cur_policy; 257 policy = this_dbs_info->cur_policy;
240 /* 258 /*
241 * The default safe range is 20% to 80% 259 * Every sampling_rate, we check, if current idle time is less
242 * Every sampling_rate, we check 260 * than 20% (default), then we try to increase frequency
243 * - If current idle time is less than 20%, then we try to 261 * Every sampling_rate*sampling_down_factor, we look for a the lowest
244 * increase frequency 262 * frequency which can sustain the load while keeping idle time over
245 * Every sampling_rate*sampling_down_factor, we check 263 * 30%. If such a frequency exist, we try to decrease to this frequency.
246 * - If current idle time is more than 80%, then we try to
247 * decrease frequency
248 * 264 *
249 * Any frequency increase takes it to the maximum frequency. 265 * Any frequency increase takes it to the maximum frequency.
250 * Frequency reduction happens at minimum steps of 266 * Frequency reduction happens at minimum steps of
251 * 5% of max_frequency 267 * 5% (default) of current frequency
252 */ 268 */
253 269
254 /* Check for frequency increase */ 270 /* Check for frequency increase */
255 total_idle_ticks = kstat_cpu(cpu).cpustat.idle + 271 idle_ticks = UINT_MAX;
256 kstat_cpu(cpu).cpustat.iowait;
257 idle_ticks = total_idle_ticks -
258 this_dbs_info->prev_cpu_idle_up;
259 this_dbs_info->prev_cpu_idle_up = total_idle_ticks;
260
261
262 for_each_cpu_mask(j, policy->cpus) { 272 for_each_cpu_mask(j, policy->cpus) {
263 unsigned int tmp_idle_ticks; 273 unsigned int tmp_idle_ticks, total_idle_ticks;
264 struct cpu_dbs_info_s *j_dbs_info; 274 struct cpu_dbs_info_s *j_dbs_info;
265 275
266 if (j == cpu)
267 continue;
268
269 j_dbs_info = &per_cpu(cpu_dbs_info, j); 276 j_dbs_info = &per_cpu(cpu_dbs_info, j);
270 /* Check for frequency increase */ 277 total_idle_ticks = get_cpu_idle_time(j);
271 total_idle_ticks = kstat_cpu(j).cpustat.idle +
272 kstat_cpu(j).cpustat.iowait;
273 tmp_idle_ticks = total_idle_ticks - 278 tmp_idle_ticks = total_idle_ticks -
274 j_dbs_info->prev_cpu_idle_up; 279 j_dbs_info->prev_cpu_idle_up;
275 j_dbs_info->prev_cpu_idle_up = total_idle_ticks; 280 j_dbs_info->prev_cpu_idle_up = total_idle_ticks;
@@ -281,13 +286,23 @@ static void dbs_check_cpu(int cpu)
281 /* Scale idle ticks by 100 and compare with up and down ticks */ 286 /* Scale idle ticks by 100 and compare with up and down ticks */
282 idle_ticks *= 100; 287 idle_ticks *= 100;
283 up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) * 288 up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
284 sampling_rate_in_HZ(dbs_tuners_ins.sampling_rate); 289 usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
285 290
286 if (idle_ticks < up_idle_ticks) { 291 if (idle_ticks < up_idle_ticks) {
292 down_skip[cpu] = 0;
293 for_each_cpu_mask(j, policy->cpus) {
294 struct cpu_dbs_info_s *j_dbs_info;
295
296 j_dbs_info = &per_cpu(cpu_dbs_info, j);
297 j_dbs_info->prev_cpu_idle_down =
298 j_dbs_info->prev_cpu_idle_up;
299 }
300 /* if we are already at full speed then break out early */
301 if (policy->cur == policy->max)
302 return;
303
287 __cpufreq_driver_target(policy, policy->max, 304 __cpufreq_driver_target(policy, policy->max,
288 CPUFREQ_RELATION_H); 305 CPUFREQ_RELATION_H);
289 down_skip[cpu] = 0;
290 this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
291 return; 306 return;
292 } 307 }
293 308
@@ -296,23 +311,14 @@ static void dbs_check_cpu(int cpu)
296 if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor) 311 if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)
297 return; 312 return;
298 313
299 total_idle_ticks = kstat_cpu(cpu).cpustat.idle + 314 idle_ticks = UINT_MAX;
300 kstat_cpu(cpu).cpustat.iowait;
301 idle_ticks = total_idle_ticks -
302 this_dbs_info->prev_cpu_idle_down;
303 this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
304
305 for_each_cpu_mask(j, policy->cpus) { 315 for_each_cpu_mask(j, policy->cpus) {
306 unsigned int tmp_idle_ticks; 316 unsigned int tmp_idle_ticks, total_idle_ticks;
307 struct cpu_dbs_info_s *j_dbs_info; 317 struct cpu_dbs_info_s *j_dbs_info;
308 318
309 if (j == cpu)
310 continue;
311
312 j_dbs_info = &per_cpu(cpu_dbs_info, j); 319 j_dbs_info = &per_cpu(cpu_dbs_info, j);
313 /* Check for frequency increase */ 320 /* Check for frequency decrease */
314 total_idle_ticks = kstat_cpu(j).cpustat.idle + 321 total_idle_ticks = j_dbs_info->prev_cpu_idle_up;
315 kstat_cpu(j).cpustat.iowait;
316 tmp_idle_ticks = total_idle_ticks - 322 tmp_idle_ticks = total_idle_ticks -
317 j_dbs_info->prev_cpu_idle_down; 323 j_dbs_info->prev_cpu_idle_down;
318 j_dbs_info->prev_cpu_idle_down = total_idle_ticks; 324 j_dbs_info->prev_cpu_idle_down = total_idle_ticks;
@@ -321,38 +327,37 @@ static void dbs_check_cpu(int cpu)
321 idle_ticks = tmp_idle_ticks; 327 idle_ticks = tmp_idle_ticks;
322 } 328 }
323 329
324 /* Scale idle ticks by 100 and compare with up and down ticks */
325 idle_ticks *= 100;
326 down_skip[cpu] = 0; 330 down_skip[cpu] = 0;
331 /* if we cannot reduce the frequency anymore, break out early */
332 if (policy->cur == policy->min)
333 return;
327 334
335 /* Compute how many ticks there are between two measurements */
328 freq_down_sampling_rate = dbs_tuners_ins.sampling_rate * 336 freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
329 dbs_tuners_ins.sampling_down_factor; 337 dbs_tuners_ins.sampling_down_factor;
330 down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) * 338 total_ticks = usecs_to_jiffies(freq_down_sampling_rate);
331 sampling_rate_in_HZ(freq_down_sampling_rate);
332 339
333 if (idle_ticks > down_idle_ticks ) { 340 /*
334 freq_down_step = (5 * policy->max) / 100; 341 * The optimal frequency is the frequency that is the lowest that
335 342 * can support the current CPU usage without triggering the up
336 /* max freq cannot be less than 100. But who knows.... */ 343 * policy. To be safe, we focus 10 points under the threshold.
337 if (unlikely(freq_down_step == 0)) 344 */
338 freq_down_step = 5; 345 freq_next = ((total_ticks - idle_ticks) * 100) / total_ticks;
346 freq_next = (freq_next * policy->cur) /
347 (dbs_tuners_ins.up_threshold - 10);
339 348
340 __cpufreq_driver_target(policy, 349 if (freq_next <= ((policy->cur * 95) / 100))
341 policy->cur - freq_down_step, 350 __cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L);
342 CPUFREQ_RELATION_H);
343 return;
344 }
345} 351}
346 352
347static void do_dbs_timer(void *data) 353static void do_dbs_timer(void *data)
348{ 354{
349 int i; 355 int i;
350 down(&dbs_sem); 356 down(&dbs_sem);
351 for (i = 0; i < NR_CPUS; i++) 357 for_each_online_cpu(i)
352 if (cpu_online(i)) 358 dbs_check_cpu(i);
353 dbs_check_cpu(i);
354 schedule_delayed_work(&dbs_work, 359 schedule_delayed_work(&dbs_work,
355 sampling_rate_in_HZ(dbs_tuners_ins.sampling_rate)); 360 usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
356 up(&dbs_sem); 361 up(&dbs_sem);
357} 362}
358 363
@@ -360,7 +365,7 @@ static inline void dbs_timer_init(void)
360{ 365{
361 INIT_WORK(&dbs_work, do_dbs_timer, NULL); 366 INIT_WORK(&dbs_work, do_dbs_timer, NULL);
362 schedule_delayed_work(&dbs_work, 367 schedule_delayed_work(&dbs_work,
363 sampling_rate_in_HZ(dbs_tuners_ins.sampling_rate)); 368 usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
364 return; 369 return;
365} 370}
366 371
@@ -397,12 +402,9 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
397 j_dbs_info = &per_cpu(cpu_dbs_info, j); 402 j_dbs_info = &per_cpu(cpu_dbs_info, j);
398 j_dbs_info->cur_policy = policy; 403 j_dbs_info->cur_policy = policy;
399 404
400 j_dbs_info->prev_cpu_idle_up = 405 j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
401 kstat_cpu(j).cpustat.idle + 406 j_dbs_info->prev_cpu_idle_down
402 kstat_cpu(j).cpustat.iowait; 407 = j_dbs_info->prev_cpu_idle_up;
403 j_dbs_info->prev_cpu_idle_down =
404 kstat_cpu(j).cpustat.idle +
405 kstat_cpu(j).cpustat.iowait;
406 } 408 }
407 this_dbs_info->enable = 1; 409 this_dbs_info->enable = 1;
408 sysfs_create_group(&policy->kobj, &dbs_attr_group); 410 sysfs_create_group(&policy->kobj, &dbs_attr_group);
@@ -422,6 +424,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
422 def_sampling_rate = (latency / 1000) * 424 def_sampling_rate = (latency / 1000) *
423 DEF_SAMPLING_RATE_LATENCY_MULTIPLIER; 425 DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
424 dbs_tuners_ins.sampling_rate = def_sampling_rate; 426 dbs_tuners_ins.sampling_rate = def_sampling_rate;
427 dbs_tuners_ins.ignore_nice = 0;
425 428
426 dbs_timer_init(); 429 dbs_timer_init();
427 } 430 }
@@ -461,12 +464,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
461 return 0; 464 return 0;
462} 465}
463 466
464struct cpufreq_governor cpufreq_gov_dbs = { 467static struct cpufreq_governor cpufreq_gov_dbs = {
465 .name = "ondemand", 468 .name = "ondemand",
466 .governor = cpufreq_governor_dbs, 469 .governor = cpufreq_governor_dbs,
467 .owner = THIS_MODULE, 470 .owner = THIS_MODULE,
468}; 471};
469EXPORT_SYMBOL(cpufreq_gov_dbs);
470 472
471static int __init cpufreq_gov_dbs_init(void) 473static int __init cpufreq_gov_dbs_init(void)
472{ 474{
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index 2084593937c6..741b6b191e6a 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -19,6 +19,7 @@
19#include <linux/percpu.h> 19#include <linux/percpu.h>
20#include <linux/kobject.h> 20#include <linux/kobject.h>
21#include <linux/spinlock.h> 21#include <linux/spinlock.h>
22#include <asm/cputime.h>
22 23
23static spinlock_t cpufreq_stats_lock; 24static spinlock_t cpufreq_stats_lock;
24 25
@@ -29,20 +30,14 @@ static struct freq_attr _attr_##_name = {\
29 .show = _show,\ 30 .show = _show,\
30}; 31};
31 32
32static unsigned long
33delta_time(unsigned long old, unsigned long new)
34{
35 return (old > new) ? (old - new): (new + ~old + 1);
36}
37
38struct cpufreq_stats { 33struct cpufreq_stats {
39 unsigned int cpu; 34 unsigned int cpu;
40 unsigned int total_trans; 35 unsigned int total_trans;
41 unsigned long long last_time; 36 unsigned long long last_time;
42 unsigned int max_state; 37 unsigned int max_state;
43 unsigned int state_num; 38 unsigned int state_num;
44 unsigned int last_index; 39 unsigned int last_index;
45 unsigned long long *time_in_state; 40 cputime64_t *time_in_state;
46 unsigned int *freq_table; 41 unsigned int *freq_table;
47#ifdef CONFIG_CPU_FREQ_STAT_DETAILS 42#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
48 unsigned int *trans_table; 43 unsigned int *trans_table;
@@ -60,12 +55,16 @@ static int
60cpufreq_stats_update (unsigned int cpu) 55cpufreq_stats_update (unsigned int cpu)
61{ 56{
62 struct cpufreq_stats *stat; 57 struct cpufreq_stats *stat;
58 unsigned long long cur_time;
59
60 cur_time = get_jiffies_64();
63 spin_lock(&cpufreq_stats_lock); 61 spin_lock(&cpufreq_stats_lock);
64 stat = cpufreq_stats_table[cpu]; 62 stat = cpufreq_stats_table[cpu];
65 if (stat->time_in_state) 63 if (stat->time_in_state)
66 stat->time_in_state[stat->last_index] += 64 stat->time_in_state[stat->last_index] =
67 delta_time(stat->last_time, jiffies); 65 cputime64_add(stat->time_in_state[stat->last_index],
68 stat->last_time = jiffies; 66 cputime_sub(cur_time, stat->last_time));
67 stat->last_time = cur_time;
69 spin_unlock(&cpufreq_stats_lock); 68 spin_unlock(&cpufreq_stats_lock);
70 return 0; 69 return 0;
71} 70}
@@ -90,8 +89,8 @@ show_time_in_state(struct cpufreq_policy *policy, char *buf)
90 return 0; 89 return 0;
91 cpufreq_stats_update(stat->cpu); 90 cpufreq_stats_update(stat->cpu);
92 for (i = 0; i < stat->state_num; i++) { 91 for (i = 0; i < stat->state_num; i++) {
93 len += sprintf(buf + len, "%u %llu\n", 92 len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i],
94 stat->freq_table[i], stat->time_in_state[i]); 93 (unsigned long long)cputime64_to_clock_t(stat->time_in_state[i]));
95 } 94 }
96 return len; 95 return len;
97} 96}
@@ -107,16 +106,30 @@ show_trans_table(struct cpufreq_policy *policy, char *buf)
107 if(!stat) 106 if(!stat)
108 return 0; 107 return 0;
109 cpufreq_stats_update(stat->cpu); 108 cpufreq_stats_update(stat->cpu);
109 len += snprintf(buf + len, PAGE_SIZE - len, " From : To\n");
110 len += snprintf(buf + len, PAGE_SIZE - len, " : ");
111 for (i = 0; i < stat->state_num; i++) {
112 if (len >= PAGE_SIZE)
113 break;
114 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
115 stat->freq_table[i]);
116 }
117 if (len >= PAGE_SIZE)
118 return len;
119
120 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
121
110 for (i = 0; i < stat->state_num; i++) { 122 for (i = 0; i < stat->state_num; i++) {
111 if (len >= PAGE_SIZE) 123 if (len >= PAGE_SIZE)
112 break; 124 break;
113 len += snprintf(buf + len, PAGE_SIZE - len, "%9u:\t", 125
126 len += snprintf(buf + len, PAGE_SIZE - len, "%9u: ",
114 stat->freq_table[i]); 127 stat->freq_table[i]);
115 128
116 for (j = 0; j < stat->state_num; j++) { 129 for (j = 0; j < stat->state_num; j++) {
117 if (len >= PAGE_SIZE) 130 if (len >= PAGE_SIZE)
118 break; 131 break;
119 len += snprintf(buf + len, PAGE_SIZE - len, "%u\t", 132 len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
120 stat->trans_table[i*stat->max_state+j]); 133 stat->trans_table[i*stat->max_state+j]);
121 } 134 }
122 len += snprintf(buf + len, PAGE_SIZE - len, "\n"); 135 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
@@ -197,7 +210,7 @@ cpufreq_stats_create_table (struct cpufreq_policy *policy,
197 count++; 210 count++;
198 } 211 }
199 212
200 alloc_size = count * sizeof(int) + count * sizeof(long long); 213 alloc_size = count * sizeof(int) + count * sizeof(cputime64_t);
201 214
202#ifdef CONFIG_CPU_FREQ_STAT_DETAILS 215#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
203 alloc_size += count * count * sizeof(int); 216 alloc_size += count * count * sizeof(int);
@@ -224,7 +237,7 @@ cpufreq_stats_create_table (struct cpufreq_policy *policy,
224 } 237 }
225 stat->state_num = j; 238 stat->state_num = j;
226 spin_lock(&cpufreq_stats_lock); 239 spin_lock(&cpufreq_stats_lock);
227 stat->last_time = jiffies; 240 stat->last_time = get_jiffies_64();
228 stat->last_index = freq_table_get_index(stat, policy->cur); 241 stat->last_index = freq_table_get_index(stat, policy->cur);
229 spin_unlock(&cpufreq_stats_lock); 242 spin_unlock(&cpufreq_stats_lock);
230 cpufreq_cpu_put(data); 243 cpufreq_cpu_put(data);
diff --git a/drivers/firmware/pcdp.c b/drivers/firmware/pcdp.c
index 6d5df6c2efa2..df1b721154d2 100644
--- a/drivers/firmware/pcdp.c
+++ b/drivers/firmware/pcdp.c
@@ -11,6 +11,7 @@
11 * published by the Free Software Foundation. 11 * published by the Free Software Foundation.
12 */ 12 */
13 13
14#include <linux/config.h>
14#include <linux/acpi.h> 15#include <linux/acpi.h>
15#include <linux/console.h> 16#include <linux/console.h>
16#include <linux/efi.h> 17#include <linux/efi.h>
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index 47225e324356..4e0f13d1d060 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -72,6 +72,7 @@ static struct amd_ide_chip {
72 { PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2, 0x50, AMD_UDMA_133 }, 72 { PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2, 0x50, AMD_UDMA_133 },
73 { PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE, 0x50, AMD_UDMA_133 }, 73 { PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE, 0x50, AMD_UDMA_133 },
74 { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE, 0x50, AMD_UDMA_133 }, 74 { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE, 0x50, AMD_UDMA_133 },
75 { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, 0x50, AMD_UDMA_133 },
75 { 0 } 76 { 0 }
76}; 77};
77 78
@@ -487,6 +488,7 @@ static ide_pci_device_t amd74xx_chipsets[] __devinitdata = {
487 /* 12 */ DECLARE_NV_DEV("NFORCE3-250-SATA2"), 488 /* 12 */ DECLARE_NV_DEV("NFORCE3-250-SATA2"),
488 /* 13 */ DECLARE_NV_DEV("NFORCE-CK804"), 489 /* 13 */ DECLARE_NV_DEV("NFORCE-CK804"),
489 /* 14 */ DECLARE_NV_DEV("NFORCE-MCP04"), 490 /* 14 */ DECLARE_NV_DEV("NFORCE-MCP04"),
491 /* 15 */ DECLARE_NV_DEV("NFORCE-MCP51"),
490}; 492};
491 493
492static int __devinit amd74xx_probe(struct pci_dev *dev, const struct pci_device_id *id) 494static int __devinit amd74xx_probe(struct pci_dev *dev, const struct pci_device_id *id)
@@ -521,6 +523,7 @@ static struct pci_device_id amd74xx_pci_tbl[] = {
521#endif 523#endif
522 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 13 }, 524 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 13 },
523 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 14 }, 525 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 14 },
526 { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 15 },
524 { 0, }, 527 { 0, },
525}; 528};
526MODULE_DEVICE_TABLE(pci, amd74xx_pci_tbl); 529MODULE_DEVICE_TABLE(pci, amd74xx_pci_tbl);
diff --git a/drivers/pci/hotplug/cpci_hotplug_core.c b/drivers/pci/hotplug/cpci_hotplug_core.c
index 9e9dab7fe86a..8132d946c384 100644
--- a/drivers/pci/hotplug/cpci_hotplug_core.c
+++ b/drivers/pci/hotplug/cpci_hotplug_core.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * CompactPCI Hot Plug Driver 2 * CompactPCI Hot Plug Driver
3 * 3 *
4 * Copyright (C) 2002 SOMA Networks, Inc. 4 * Copyright (C) 2002,2005 SOMA Networks, Inc.
5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com) 5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2001 IBM Corp. 6 * Copyright (C) 2001 IBM Corp.
7 * 7 *
@@ -45,10 +45,10 @@
45 45
46#define dbg(format, arg...) \ 46#define dbg(format, arg...) \
47 do { \ 47 do { \
48 if(cpci_debug) \ 48 if (cpci_debug) \
49 printk (KERN_DEBUG "%s: " format "\n", \ 49 printk (KERN_DEBUG "%s: " format "\n", \
50 MY_NAME , ## arg); \ 50 MY_NAME , ## arg); \
51 } while(0) 51 } while (0)
52#define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg) 52#define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
53#define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg) 53#define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
54#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg) 54#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
@@ -111,10 +111,8 @@ enable_slot(struct hotplug_slot *hotplug_slot)
111 111
112 dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name); 112 dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
113 113
114 if(controller->ops->set_power) { 114 if (controller->ops->set_power)
115 retval = controller->ops->set_power(slot, 1); 115 retval = controller->ops->set_power(slot, 1);
116 }
117
118 return retval; 116 return retval;
119} 117}
120 118
@@ -126,37 +124,41 @@ disable_slot(struct hotplug_slot *hotplug_slot)
126 124
127 dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name); 125 dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
128 126
127 down_write(&list_rwsem);
128
129 /* Unconfigure device */ 129 /* Unconfigure device */
130 dbg("%s - unconfiguring slot %s", 130 dbg("%s - unconfiguring slot %s",
131 __FUNCTION__, slot->hotplug_slot->name); 131 __FUNCTION__, slot->hotplug_slot->name);
132 if((retval = cpci_unconfigure_slot(slot))) { 132 if ((retval = cpci_unconfigure_slot(slot))) {
133 err("%s - could not unconfigure slot %s", 133 err("%s - could not unconfigure slot %s",
134 __FUNCTION__, slot->hotplug_slot->name); 134 __FUNCTION__, slot->hotplug_slot->name);
135 return retval; 135 goto disable_error;
136 } 136 }
137 dbg("%s - finished unconfiguring slot %s", 137 dbg("%s - finished unconfiguring slot %s",
138 __FUNCTION__, slot->hotplug_slot->name); 138 __FUNCTION__, slot->hotplug_slot->name);
139 139
140 /* Clear EXT (by setting it) */ 140 /* Clear EXT (by setting it) */
141 if(cpci_clear_ext(slot)) { 141 if (cpci_clear_ext(slot)) {
142 err("%s - could not clear EXT for slot %s", 142 err("%s - could not clear EXT for slot %s",
143 __FUNCTION__, slot->hotplug_slot->name); 143 __FUNCTION__, slot->hotplug_slot->name);
144 retval = -ENODEV; 144 retval = -ENODEV;
145 goto disable_error;
145 } 146 }
146 cpci_led_on(slot); 147 cpci_led_on(slot);
147 148
148 if(controller->ops->set_power) { 149 if (controller->ops->set_power)
149 retval = controller->ops->set_power(slot, 0); 150 if ((retval = controller->ops->set_power(slot, 0)))
150 } 151 goto disable_error;
151 152
152 if(update_adapter_status(slot->hotplug_slot, 0)) { 153 if (update_adapter_status(slot->hotplug_slot, 0))
153 warn("failure to update adapter file"); 154 warn("failure to update adapter file");
154 }
155 155
156 if(slot->extracting) { 156 if (slot->extracting) {
157 slot->extracting = 0; 157 slot->extracting = 0;
158 atomic_dec(&extracting); 158 atomic_dec(&extracting);
159 } 159 }
160disable_error:
161 up_write(&list_rwsem);
160 return retval; 162 return retval;
161} 163}
162 164
@@ -165,9 +167,8 @@ cpci_get_power_status(struct slot *slot)
165{ 167{
166 u8 power = 1; 168 u8 power = 1;
167 169
168 if(controller->ops->get_power) { 170 if (controller->ops->get_power)
169 power = controller->ops->get_power(slot); 171 power = controller->ops->get_power(slot);
170 }
171 return power; 172 return power;
172} 173}
173 174
@@ -237,9 +238,8 @@ cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
237 int status = -ENOMEM; 238 int status = -ENOMEM;
238 int i; 239 int i;
239 240
240 if(!(controller && bus)) { 241 if (!(controller && bus))
241 return -ENODEV; 242 return -ENODEV;
242 }
243 243
244 /* 244 /*
245 * Create a structure for each slot, and register that slot 245 * Create a structure for each slot, and register that slot
@@ -316,32 +316,30 @@ int
316cpci_hp_unregister_bus(struct pci_bus *bus) 316cpci_hp_unregister_bus(struct pci_bus *bus)
317{ 317{
318 struct slot *slot; 318 struct slot *slot;
319 struct list_head *tmp; 319 struct slot *tmp;
320 struct list_head *next; 320 int status = 0;
321 int status;
322 321
323 down_write(&list_rwsem); 322 down_write(&list_rwsem);
324 if(!slots) { 323 if (!slots) {
325 up_write(&list_rwsem); 324 up_write(&list_rwsem);
326 return -1; 325 return -1;
327 } 326 }
328 list_for_each_safe(tmp, next, &slot_list) { 327 list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
329 slot = list_entry(tmp, struct slot, slot_list); 328 if (slot->bus == bus) {
330 if(slot->bus == bus) { 329 list_del(&slot->slot_list);
330 slots--;
331
331 dbg("deregistering slot %s", slot->hotplug_slot->name); 332 dbg("deregistering slot %s", slot->hotplug_slot->name);
332 status = pci_hp_deregister(slot->hotplug_slot); 333 status = pci_hp_deregister(slot->hotplug_slot);
333 if(status) { 334 if (status) {
334 err("pci_hp_deregister failed with error %d", 335 err("pci_hp_deregister failed with error %d",
335 status); 336 status);
336 return status; 337 break;
337 } 338 }
338
339 list_del(&slot->slot_list);
340 slots--;
341 } 339 }
342 } 340 }
343 up_write(&list_rwsem); 341 up_write(&list_rwsem);
344 return 0; 342 return status;
345} 343}
346 344
347/* This is the interrupt mode interrupt handler */ 345/* This is the interrupt mode interrupt handler */
@@ -351,7 +349,7 @@ cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
351 dbg("entered cpci_hp_intr"); 349 dbg("entered cpci_hp_intr");
352 350
353 /* Check to see if it was our interrupt */ 351 /* Check to see if it was our interrupt */
354 if((controller->irq_flags & SA_SHIRQ) && 352 if ((controller->irq_flags & SA_SHIRQ) &&
355 !controller->ops->check_irq(controller->dev_id)) { 353 !controller->ops->check_irq(controller->dev_id)) {
356 dbg("exited cpci_hp_intr, not our interrupt"); 354 dbg("exited cpci_hp_intr, not our interrupt");
357 return IRQ_NONE; 355 return IRQ_NONE;
@@ -373,38 +371,30 @@ cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
373 * INS bits of the cold-inserted devices. 371 * INS bits of the cold-inserted devices.
374 */ 372 */
375static int 373static int
376init_slots(void) 374init_slots(int clear_ins)
377{ 375{
378 struct slot *slot; 376 struct slot *slot;
379 struct list_head *tmp;
380 struct pci_dev* dev; 377 struct pci_dev* dev;
381 378
382 dbg("%s - enter", __FUNCTION__); 379 dbg("%s - enter", __FUNCTION__);
383 down_read(&list_rwsem); 380 down_read(&list_rwsem);
384 if(!slots) { 381 if (!slots) {
385 up_read(&list_rwsem); 382 up_read(&list_rwsem);
386 return -1; 383 return -1;
387 } 384 }
388 list_for_each(tmp, &slot_list) { 385 list_for_each_entry(slot, &slot_list, slot_list) {
389 slot = list_entry(tmp, struct slot, slot_list);
390 dbg("%s - looking at slot %s", 386 dbg("%s - looking at slot %s",
391 __FUNCTION__, slot->hotplug_slot->name); 387 __FUNCTION__, slot->hotplug_slot->name);
392 if(cpci_check_and_clear_ins(slot)) { 388 if (clear_ins && cpci_check_and_clear_ins(slot))
393 dbg("%s - cleared INS for slot %s", 389 dbg("%s - cleared INS for slot %s",
394 __FUNCTION__, slot->hotplug_slot->name); 390 __FUNCTION__, slot->hotplug_slot->name);
395 dev = pci_find_slot(slot->bus->number, PCI_DEVFN(slot->number, 0)); 391 dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
396 if(dev) { 392 if (dev) {
397 if(update_adapter_status(slot->hotplug_slot, 1)) { 393 if (update_adapter_status(slot->hotplug_slot, 1))
398 warn("failure to update adapter file"); 394 warn("failure to update adapter file");
399 } 395 if (update_latch_status(slot->hotplug_slot, 1))
400 if(update_latch_status(slot->hotplug_slot, 1)) { 396 warn("failure to update latch file");
401 warn("failure to update latch file"); 397 slot->dev = dev;
402 }
403 slot->dev = dev;
404 } else {
405 err("%s - no driver attached to device in slot %s",
406 __FUNCTION__, slot->hotplug_slot->name);
407 }
408 } 398 }
409 } 399 }
410 up_read(&list_rwsem); 400 up_read(&list_rwsem);
@@ -416,26 +406,28 @@ static int
416check_slots(void) 406check_slots(void)
417{ 407{
418 struct slot *slot; 408 struct slot *slot;
419 struct list_head *tmp;
420 int extracted; 409 int extracted;
421 int inserted; 410 int inserted;
422 u16 hs_csr; 411 u16 hs_csr;
423 412
424 down_read(&list_rwsem); 413 down_read(&list_rwsem);
425 if(!slots) { 414 if (!slots) {
426 up_read(&list_rwsem); 415 up_read(&list_rwsem);
427 err("no slots registered, shutting down"); 416 err("no slots registered, shutting down");
428 return -1; 417 return -1;
429 } 418 }
430 extracted = inserted = 0; 419 extracted = inserted = 0;
431 list_for_each(tmp, &slot_list) { 420 list_for_each_entry(slot, &slot_list, slot_list) {
432 slot = list_entry(tmp, struct slot, slot_list);
433 dbg("%s - looking at slot %s", 421 dbg("%s - looking at slot %s",
434 __FUNCTION__, slot->hotplug_slot->name); 422 __FUNCTION__, slot->hotplug_slot->name);
435 if(cpci_check_and_clear_ins(slot)) { 423 if (cpci_check_and_clear_ins(slot)) {
436 /* Some broken hardware (e.g. PLX 9054AB) asserts ENUM# twice... */ 424 /*
437 if(slot->dev) { 425 * Some broken hardware (e.g. PLX 9054AB) asserts
438 warn("slot %s already inserted", slot->hotplug_slot->name); 426 * ENUM# twice...
427 */
428 if (slot->dev) {
429 warn("slot %s already inserted",
430 slot->hotplug_slot->name);
439 inserted++; 431 inserted++;
440 continue; 432 continue;
441 } 433 }
@@ -452,7 +444,7 @@ check_slots(void)
452 /* Configure device */ 444 /* Configure device */
453 dbg("%s - configuring slot %s", 445 dbg("%s - configuring slot %s",
454 __FUNCTION__, slot->hotplug_slot->name); 446 __FUNCTION__, slot->hotplug_slot->name);
455 if(cpci_configure_slot(slot)) { 447 if (cpci_configure_slot(slot)) {
456 err("%s - could not configure slot %s", 448 err("%s - could not configure slot %s",
457 __FUNCTION__, slot->hotplug_slot->name); 449 __FUNCTION__, slot->hotplug_slot->name);
458 continue; 450 continue;
@@ -465,13 +457,11 @@ check_slots(void)
465 dbg("%s - slot %s HS_CSR (2) = %04x", 457 dbg("%s - slot %s HS_CSR (2) = %04x",
466 __FUNCTION__, slot->hotplug_slot->name, hs_csr); 458 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
467 459
468 if(update_latch_status(slot->hotplug_slot, 1)) { 460 if (update_latch_status(slot->hotplug_slot, 1))
469 warn("failure to update latch file"); 461 warn("failure to update latch file");
470 }
471 462
472 if(update_adapter_status(slot->hotplug_slot, 1)) { 463 if (update_adapter_status(slot->hotplug_slot, 1))
473 warn("failure to update adapter file"); 464 warn("failure to update adapter file");
474 }
475 465
476 cpci_led_off(slot); 466 cpci_led_off(slot);
477 467
@@ -481,7 +471,7 @@ check_slots(void)
481 __FUNCTION__, slot->hotplug_slot->name, hs_csr); 471 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
482 472
483 inserted++; 473 inserted++;
484 } else if(cpci_check_ext(slot)) { 474 } else if (cpci_check_ext(slot)) {
485 /* Process extraction request */ 475 /* Process extraction request */
486 dbg("%s - slot %s extracted", 476 dbg("%s - slot %s extracted",
487 __FUNCTION__, slot->hotplug_slot->name); 477 __FUNCTION__, slot->hotplug_slot->name);
@@ -491,27 +481,25 @@ check_slots(void)
491 dbg("%s - slot %s HS_CSR = %04x", 481 dbg("%s - slot %s HS_CSR = %04x",
492 __FUNCTION__, slot->hotplug_slot->name, hs_csr); 482 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
493 483
494 if(!slot->extracting) { 484 if (!slot->extracting) {
495 if(update_latch_status(slot->hotplug_slot, 0)) { 485 if (update_latch_status(slot->hotplug_slot, 0)) {
496 warn("failure to update latch file"); 486 warn("failure to update latch file");
497
498 } 487 }
499 atomic_inc(&extracting);
500 slot->extracting = 1; 488 slot->extracting = 1;
489 atomic_inc(&extracting);
501 } 490 }
502 extracted++; 491 extracted++;
503 } else if(slot->extracting) { 492 } else if (slot->extracting) {
504 hs_csr = cpci_get_hs_csr(slot); 493 hs_csr = cpci_get_hs_csr(slot);
505 if(hs_csr == 0xffff) { 494 if (hs_csr == 0xffff) {
506 /* 495 /*
507 * Hmmm, we're likely hosed at this point, should we 496 * Hmmm, we're likely hosed at this point, should we
508 * bother trying to tell the driver or not? 497 * bother trying to tell the driver or not?
509 */ 498 */
510 err("card in slot %s was improperly removed", 499 err("card in slot %s was improperly removed",
511 slot->hotplug_slot->name); 500 slot->hotplug_slot->name);
512 if(update_adapter_status(slot->hotplug_slot, 0)) { 501 if (update_adapter_status(slot->hotplug_slot, 0))
513 warn("failure to update adapter file"); 502 warn("failure to update adapter file");
514 }
515 slot->extracting = 0; 503 slot->extracting = 0;
516 atomic_dec(&extracting); 504 atomic_dec(&extracting);
517 } 505 }
@@ -520,10 +508,9 @@ check_slots(void)
520 up_read(&list_rwsem); 508 up_read(&list_rwsem);
521 dbg("inserted=%d, extracted=%d, extracting=%d", 509 dbg("inserted=%d, extracted=%d, extracting=%d",
522 inserted, extracted, atomic_read(&extracting)); 510 inserted, extracted, atomic_read(&extracting));
523 if(inserted || extracted) { 511 if (inserted || extracted)
524 return extracted; 512 return extracted;
525 } 513 else if (!atomic_read(&extracting)) {
526 else if(!atomic_read(&extracting)) {
527 err("cannot find ENUM# source, shutting down"); 514 err("cannot find ENUM# source, shutting down");
528 return -1; 515 return -1;
529 } 516 }
@@ -541,12 +528,12 @@ event_thread(void *data)
541 unlock_kernel(); 528 unlock_kernel();
542 529
543 dbg("%s - event thread started", __FUNCTION__); 530 dbg("%s - event thread started", __FUNCTION__);
544 while(1) { 531 while (1) {
545 dbg("event thread sleeping"); 532 dbg("event thread sleeping");
546 down_interruptible(&event_semaphore); 533 down_interruptible(&event_semaphore);
547 dbg("event thread woken, thread_finished = %d", 534 dbg("event thread woken, thread_finished = %d",
548 thread_finished); 535 thread_finished);
549 if(thread_finished || signal_pending(current)) 536 if (thread_finished || signal_pending(current))
550 break; 537 break;
551 do { 538 do {
552 rc = check_slots(); 539 rc = check_slots();
@@ -558,7 +545,9 @@ event_thread(void *data)
558 thread_finished = 1; 545 thread_finished = 1;
559 break; 546 break;
560 } 547 }
561 } while(atomic_read(&extracting) != 0); 548 } while (atomic_read(&extracting) && !thread_finished);
549 if (thread_finished)
550 break;
562 551
563 /* Re-enable ENUM# interrupt */ 552 /* Re-enable ENUM# interrupt */
564 dbg("%s - re-enabling irq", __FUNCTION__); 553 dbg("%s - re-enabling irq", __FUNCTION__);
@@ -579,21 +568,21 @@ poll_thread(void *data)
579 daemonize("cpci_hp_polld"); 568 daemonize("cpci_hp_polld");
580 unlock_kernel(); 569 unlock_kernel();
581 570
582 while(1) { 571 while (1) {
583 if(thread_finished || signal_pending(current)) 572 if (thread_finished || signal_pending(current))
584 break; 573 break;
585 if(controller->ops->query_enum()) { 574 if (controller->ops->query_enum()) {
586 do { 575 do {
587 rc = check_slots(); 576 rc = check_slots();
588 if(rc > 0) { 577 if (rc > 0) {
589 /* Give userspace a chance to handle extraction */ 578 /* Give userspace a chance to handle extraction */
590 msleep(500); 579 msleep(500);
591 } else if(rc < 0) { 580 } else if (rc < 0) {
592 dbg("%s - error checking slots", __FUNCTION__); 581 dbg("%s - error checking slots", __FUNCTION__);
593 thread_finished = 1; 582 thread_finished = 1;
594 break; 583 break;
595 } 584 }
596 } while(atomic_read(&extracting) != 0); 585 } while (atomic_read(&extracting) && !thread_finished);
597 } 586 }
598 msleep(100); 587 msleep(100);
599 } 588 }
@@ -612,12 +601,11 @@ cpci_start_thread(void)
612 init_MUTEX_LOCKED(&thread_exit); 601 init_MUTEX_LOCKED(&thread_exit);
613 thread_finished = 0; 602 thread_finished = 0;
614 603
615 if(controller->irq) { 604 if (controller->irq)
616 pid = kernel_thread(event_thread, NULL, 0); 605 pid = kernel_thread(event_thread, NULL, 0);
617 } else { 606 else
618 pid = kernel_thread(poll_thread, NULL, 0); 607 pid = kernel_thread(poll_thread, NULL, 0);
619 } 608 if (pid < 0) {
620 if(pid < 0) {
621 err("Can't start up our thread"); 609 err("Can't start up our thread");
622 return -1; 610 return -1;
623 } 611 }
@@ -630,9 +618,8 @@ cpci_stop_thread(void)
630{ 618{
631 thread_finished = 1; 619 thread_finished = 1;
632 dbg("thread finish command given"); 620 dbg("thread finish command given");
633 if(controller->irq) { 621 if (controller->irq)
634 up(&event_semaphore); 622 up(&event_semaphore);
635 }
636 dbg("wait for thread to exit"); 623 dbg("wait for thread to exit");
637 down(&thread_exit); 624 down(&thread_exit);
638} 625}
@@ -642,45 +629,67 @@ cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
642{ 629{
643 int status = 0; 630 int status = 0;
644 631
645 if(!controller) { 632 if (controller)
646 controller = new_controller; 633 return -1;
647 if(controller->irq) { 634 if (!(new_controller && new_controller->ops))
648 if(request_irq(controller->irq, 635 return -EINVAL;
649 cpci_hp_intr, 636 if (new_controller->irq) {
650 controller->irq_flags, 637 if (!(new_controller->ops->enable_irq &&
651 MY_NAME, controller->dev_id)) { 638 new_controller->ops->disable_irq))
652 err("Can't get irq %d for the hotplug cPCI controller", controller->irq); 639 status = -EINVAL;
653 status = -ENODEV; 640 if (request_irq(new_controller->irq,
654 } 641 cpci_hp_intr,
655 dbg("%s - acquired controller irq %d", __FUNCTION__, 642 new_controller->irq_flags,
656 controller->irq); 643 MY_NAME,
644 new_controller->dev_id)) {
645 err("Can't get irq %d for the hotplug cPCI controller",
646 new_controller->irq);
647 status = -ENODEV;
657 } 648 }
658 } else { 649 dbg("%s - acquired controller irq %d",
659 err("cPCI hotplug controller already registered"); 650 __FUNCTION__, new_controller->irq);
660 status = -1;
661 } 651 }
652 if (!status)
653 controller = new_controller;
662 return status; 654 return status;
663} 655}
664 656
657static void
658cleanup_slots(void)
659{
660 struct slot *slot;
661 struct slot *tmp;
662
663 /*
664 * Unregister all of our slots with the pci_hotplug subsystem,
665 * and free up all memory that we had allocated.
666 */
667 down_write(&list_rwsem);
668 if (!slots)
669 goto cleanup_null;
670 list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
671 list_del(&slot->slot_list);
672 pci_hp_deregister(slot->hotplug_slot);
673 }
674cleanup_null:
675 up_write(&list_rwsem);
676 return;
677}
678
665int 679int
666cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller) 680cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
667{ 681{
668 int status = 0; 682 int status = 0;
669 683
670 if(controller) { 684 if (controller) {
671 if(atomic_read(&extracting) != 0) { 685 if (!thread_finished)
672 return -EBUSY;
673 }
674 if(!thread_finished) {
675 cpci_stop_thread(); 686 cpci_stop_thread();
676 } 687 if (controller->irq)
677 if(controller->irq) {
678 free_irq(controller->irq, controller->dev_id); 688 free_irq(controller->irq, controller->dev_id);
679 }
680 controller = NULL; 689 controller = NULL;
681 } else { 690 cleanup_slots();
691 } else
682 status = -ENODEV; 692 status = -ENODEV;
683 }
684 return status; 693 return status;
685} 694}
686 695
@@ -691,32 +700,28 @@ cpci_hp_start(void)
691 int status; 700 int status;
692 701
693 dbg("%s - enter", __FUNCTION__); 702 dbg("%s - enter", __FUNCTION__);
694 if(!controller) { 703 if (!controller)
695 return -ENODEV; 704 return -ENODEV;
696 }
697 705
698 down_read(&list_rwsem); 706 down_read(&list_rwsem);
699 if(list_empty(&slot_list)) { 707 if (list_empty(&slot_list)) {
700 up_read(&list_rwsem); 708 up_read(&list_rwsem);
701 return -ENODEV; 709 return -ENODEV;
702 } 710 }
703 up_read(&list_rwsem); 711 up_read(&list_rwsem);
704 712
705 if(first) { 713 status = init_slots(first);
706 status = init_slots(); 714 if (first)
707 if(status) {
708 return status;
709 }
710 first = 0; 715 first = 0;
711 } 716 if (status)
717 return status;
712 718
713 status = cpci_start_thread(); 719 status = cpci_start_thread();
714 if(status) { 720 if (status)
715 return status; 721 return status;
716 }
717 dbg("%s - thread started", __FUNCTION__); 722 dbg("%s - thread started", __FUNCTION__);
718 723
719 if(controller->irq) { 724 if (controller->irq) {
720 /* Start enum interrupt processing */ 725 /* Start enum interrupt processing */
721 dbg("%s - enabling irq", __FUNCTION__); 726 dbg("%s - enabling irq", __FUNCTION__);
722 controller->ops->enable_irq(); 727 controller->ops->enable_irq();
@@ -728,13 +733,9 @@ cpci_hp_start(void)
728int 733int
729cpci_hp_stop(void) 734cpci_hp_stop(void)
730{ 735{
731 if(!controller) { 736 if (!controller)
732 return -ENODEV; 737 return -ENODEV;
733 } 738 if (controller->irq) {
734 if(atomic_read(&extracting) != 0) {
735 return -EBUSY;
736 }
737 if(controller->irq) {
738 /* Stop enum interrupt processing */ 739 /* Stop enum interrupt processing */
739 dbg("%s - disabling irq", __FUNCTION__); 740 dbg("%s - disabling irq", __FUNCTION__);
740 controller->ops->disable_irq(); 741 controller->ops->disable_irq();
@@ -743,34 +744,6 @@ cpci_hp_stop(void)
743 return 0; 744 return 0;
744} 745}
745 746
746static void __exit
747cleanup_slots(void)
748{
749 struct list_head *tmp;
750 struct slot *slot;
751
752 /*
753 * Unregister all of our slots with the pci_hotplug subsystem,
754 * and free up all memory that we had allocated.
755 */
756 down_write(&list_rwsem);
757 if(!slots) {
758 goto null_cleanup;
759 }
760 list_for_each(tmp, &slot_list) {
761 slot = list_entry(tmp, struct slot, slot_list);
762 list_del(&slot->slot_list);
763 pci_hp_deregister(slot->hotplug_slot);
764 kfree(slot->hotplug_slot->info);
765 kfree(slot->hotplug_slot->name);
766 kfree(slot->hotplug_slot);
767 kfree(slot);
768 }
769 null_cleanup:
770 up_write(&list_rwsem);
771 return;
772}
773
774int __init 747int __init
775cpci_hotplug_init(int debug) 748cpci_hotplug_init(int debug)
776{ 749{
@@ -784,7 +757,8 @@ cpci_hotplug_exit(void)
784 /* 757 /*
785 * Clean everything up. 758 * Clean everything up.
786 */ 759 */
787 cleanup_slots(); 760 cpci_hp_stop();
761 cpci_hp_unregister_controller(controller);
788} 762}
789 763
790EXPORT_SYMBOL_GPL(cpci_hp_register_controller); 764EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
diff --git a/drivers/pci/hotplug/cpci_hotplug_pci.c b/drivers/pci/hotplug/cpci_hotplug_pci.c
index 69eb4fc54f2f..c878028ad215 100644
--- a/drivers/pci/hotplug/cpci_hotplug_pci.c
+++ b/drivers/pci/hotplug/cpci_hotplug_pci.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * CompactPCI Hot Plug Driver PCI functions 2 * CompactPCI Hot Plug Driver PCI functions
3 * 3 *
4 * Copyright (C) 2002 by SOMA Networks, Inc. 4 * Copyright (C) 2002,2005 by SOMA Networks, Inc.
5 * 5 *
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
@@ -38,10 +38,10 @@ extern int cpci_debug;
38 38
39#define dbg(format, arg...) \ 39#define dbg(format, arg...) \
40 do { \ 40 do { \
41 if(cpci_debug) \ 41 if (cpci_debug) \
42 printk (KERN_DEBUG "%s: " format "\n", \ 42 printk (KERN_DEBUG "%s: " format "\n", \
43 MY_NAME , ## arg); \ 43 MY_NAME , ## arg); \
44 } while(0) 44 } while (0)
45#define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg) 45#define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
46#define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg) 46#define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
47#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg) 47#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
@@ -57,16 +57,15 @@ u8 cpci_get_attention_status(struct slot* slot)
57 hs_cap = pci_bus_find_capability(slot->bus, 57 hs_cap = pci_bus_find_capability(slot->bus,
58 slot->devfn, 58 slot->devfn,
59 PCI_CAP_ID_CHSWP); 59 PCI_CAP_ID_CHSWP);
60 if(!hs_cap) { 60 if (!hs_cap)
61 return 0; 61 return 0;
62 }
63 62
64 if(pci_bus_read_config_word(slot->bus, 63 if (pci_bus_read_config_word(slot->bus,
65 slot->devfn, 64 slot->devfn,
66 hs_cap + 2, 65 hs_cap + 2,
67 &hs_csr)) { 66 &hs_csr))
68 return 0; 67 return 0;
69 } 68
70 return hs_csr & 0x0008 ? 1 : 0; 69 return hs_csr & 0x0008 ? 1 : 0;
71} 70}
72 71
@@ -78,27 +77,22 @@ int cpci_set_attention_status(struct slot* slot, int status)
78 hs_cap = pci_bus_find_capability(slot->bus, 77 hs_cap = pci_bus_find_capability(slot->bus,
79 slot->devfn, 78 slot->devfn,
80 PCI_CAP_ID_CHSWP); 79 PCI_CAP_ID_CHSWP);
81 if(!hs_cap) { 80 if (!hs_cap)
82 return 0; 81 return 0;
83 } 82 if (pci_bus_read_config_word(slot->bus,
84
85 if(pci_bus_read_config_word(slot->bus,
86 slot->devfn, 83 slot->devfn,
87 hs_cap + 2, 84 hs_cap + 2,
88 &hs_csr)) { 85 &hs_csr))
89 return 0; 86 return 0;
90 } 87 if (status)
91 if(status) {
92 hs_csr |= HS_CSR_LOO; 88 hs_csr |= HS_CSR_LOO;
93 } else { 89 else
94 hs_csr &= ~HS_CSR_LOO; 90 hs_csr &= ~HS_CSR_LOO;
95 } 91 if (pci_bus_write_config_word(slot->bus,
96 if(pci_bus_write_config_word(slot->bus,
97 slot->devfn, 92 slot->devfn,
98 hs_cap + 2, 93 hs_cap + 2,
99 hs_csr)) { 94 hs_csr))
100 return 0; 95 return 0;
101 }
102 return 1; 96 return 1;
103} 97}
104 98
@@ -110,16 +104,13 @@ u16 cpci_get_hs_csr(struct slot* slot)
110 hs_cap = pci_bus_find_capability(slot->bus, 104 hs_cap = pci_bus_find_capability(slot->bus,
111 slot->devfn, 105 slot->devfn,
112 PCI_CAP_ID_CHSWP); 106 PCI_CAP_ID_CHSWP);
113 if(!hs_cap) { 107 if (!hs_cap)
114 return 0xFFFF; 108 return 0xFFFF;
115 } 109 if (pci_bus_read_config_word(slot->bus,
116
117 if(pci_bus_read_config_word(slot->bus,
118 slot->devfn, 110 slot->devfn,
119 hs_cap + 2, 111 hs_cap + 2,
120 &hs_csr)) { 112 &hs_csr))
121 return 0xFFFF; 113 return 0xFFFF;
122 }
123 return hs_csr; 114 return hs_csr;
124} 115}
125 116
@@ -132,24 +123,22 @@ int cpci_check_and_clear_ins(struct slot* slot)
132 hs_cap = pci_bus_find_capability(slot->bus, 123 hs_cap = pci_bus_find_capability(slot->bus,
133 slot->devfn, 124 slot->devfn,
134 PCI_CAP_ID_CHSWP); 125 PCI_CAP_ID_CHSWP);
135 if(!hs_cap) { 126 if (!hs_cap)
136 return 0; 127 return 0;
137 } 128 if (pci_bus_read_config_word(slot->bus,
138 if(pci_bus_read_config_word(slot->bus,
139 slot->devfn, 129 slot->devfn,
140 hs_cap + 2, 130 hs_cap + 2,
141 &hs_csr)) { 131 &hs_csr))
142 return 0; 132 return 0;
143 } 133 if (hs_csr & HS_CSR_INS) {
144 if(hs_csr & HS_CSR_INS) {
145 /* Clear INS (by setting it) */ 134 /* Clear INS (by setting it) */
146 if(pci_bus_write_config_word(slot->bus, 135 if (pci_bus_write_config_word(slot->bus,
147 slot->devfn, 136 slot->devfn,
148 hs_cap + 2, 137 hs_cap + 2,
149 hs_csr)) { 138 hs_csr))
150 ins = 0; 139 ins = 0;
151 } 140 else
152 ins = 1; 141 ins = 1;
153 } 142 }
154 return ins; 143 return ins;
155} 144}
@@ -163,18 +152,15 @@ int cpci_check_ext(struct slot* slot)
163 hs_cap = pci_bus_find_capability(slot->bus, 152 hs_cap = pci_bus_find_capability(slot->bus,
164 slot->devfn, 153 slot->devfn,
165 PCI_CAP_ID_CHSWP); 154 PCI_CAP_ID_CHSWP);
166 if(!hs_cap) { 155 if (!hs_cap)
167 return 0; 156 return 0;
168 } 157 if (pci_bus_read_config_word(slot->bus,
169 if(pci_bus_read_config_word(slot->bus,
170 slot->devfn, 158 slot->devfn,
171 hs_cap + 2, 159 hs_cap + 2,
172 &hs_csr)) { 160 &hs_csr))
173 return 0; 161 return 0;
174 } 162 if (hs_csr & HS_CSR_EXT)
175 if(hs_csr & HS_CSR_EXT) {
176 ext = 1; 163 ext = 1;
177 }
178 return ext; 164 return ext;
179} 165}
180 166
@@ -186,23 +172,20 @@ int cpci_clear_ext(struct slot* slot)
186 hs_cap = pci_bus_find_capability(slot->bus, 172 hs_cap = pci_bus_find_capability(slot->bus,
187 slot->devfn, 173 slot->devfn,
188 PCI_CAP_ID_CHSWP); 174 PCI_CAP_ID_CHSWP);
189 if(!hs_cap) { 175 if (!hs_cap)
190 return -ENODEV; 176 return -ENODEV;
191 } 177 if (pci_bus_read_config_word(slot->bus,
192 if(pci_bus_read_config_word(slot->bus,
193 slot->devfn, 178 slot->devfn,
194 hs_cap + 2, 179 hs_cap + 2,
195 &hs_csr)) { 180 &hs_csr))
196 return -ENODEV; 181 return -ENODEV;
197 } 182 if (hs_csr & HS_CSR_EXT) {
198 if(hs_csr & HS_CSR_EXT) {
199 /* Clear EXT (by setting it) */ 183 /* Clear EXT (by setting it) */
200 if(pci_bus_write_config_word(slot->bus, 184 if (pci_bus_write_config_word(slot->bus,
201 slot->devfn, 185 slot->devfn,
202 hs_cap + 2, 186 hs_cap + 2,
203 hs_csr)) { 187 hs_csr))
204 return -ENODEV; 188 return -ENODEV;
205 }
206 } 189 }
207 return 0; 190 return 0;
208} 191}
@@ -215,18 +198,16 @@ int cpci_led_on(struct slot* slot)
215 hs_cap = pci_bus_find_capability(slot->bus, 198 hs_cap = pci_bus_find_capability(slot->bus,
216 slot->devfn, 199 slot->devfn,
217 PCI_CAP_ID_CHSWP); 200 PCI_CAP_ID_CHSWP);
218 if(!hs_cap) { 201 if (!hs_cap)
219 return -ENODEV; 202 return -ENODEV;
220 } 203 if (pci_bus_read_config_word(slot->bus,
221 if(pci_bus_read_config_word(slot->bus,
222 slot->devfn, 204 slot->devfn,
223 hs_cap + 2, 205 hs_cap + 2,
224 &hs_csr)) { 206 &hs_csr))
225 return -ENODEV; 207 return -ENODEV;
226 } 208 if ((hs_csr & HS_CSR_LOO) != HS_CSR_LOO) {
227 if((hs_csr & HS_CSR_LOO) != HS_CSR_LOO) {
228 hs_csr |= HS_CSR_LOO; 209 hs_csr |= HS_CSR_LOO;
229 if(pci_bus_write_config_word(slot->bus, 210 if (pci_bus_write_config_word(slot->bus,
230 slot->devfn, 211 slot->devfn,
231 hs_cap + 2, 212 hs_cap + 2,
232 hs_csr)) { 213 hs_csr)) {
@@ -246,18 +227,16 @@ int cpci_led_off(struct slot* slot)
246 hs_cap = pci_bus_find_capability(slot->bus, 227 hs_cap = pci_bus_find_capability(slot->bus,
247 slot->devfn, 228 slot->devfn,
248 PCI_CAP_ID_CHSWP); 229 PCI_CAP_ID_CHSWP);
249 if(!hs_cap) { 230 if (!hs_cap)
250 return -ENODEV; 231 return -ENODEV;
251 } 232 if (pci_bus_read_config_word(slot->bus,
252 if(pci_bus_read_config_word(slot->bus,
253 slot->devfn, 233 slot->devfn,
254 hs_cap + 2, 234 hs_cap + 2,
255 &hs_csr)) { 235 &hs_csr))
256 return -ENODEV; 236 return -ENODEV;
257 } 237 if (hs_csr & HS_CSR_LOO) {
258 if(hs_csr & HS_CSR_LOO) {
259 hs_csr &= ~HS_CSR_LOO; 238 hs_csr &= ~HS_CSR_LOO;
260 if(pci_bus_write_config_word(slot->bus, 239 if (pci_bus_write_config_word(slot->bus,
261 slot->devfn, 240 slot->devfn,
262 hs_cap + 2, 241 hs_cap + 2,
263 hs_csr)) { 242 hs_csr)) {
@@ -274,19 +253,6 @@ int cpci_led_off(struct slot* slot)
274 * Device configuration functions 253 * Device configuration functions
275 */ 254 */
276 255
277static void cpci_enable_device(struct pci_dev *dev)
278{
279 struct pci_bus *bus;
280
281 pci_enable_device(dev);
282 if(dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
283 bus = dev->subordinate;
284 list_for_each_entry(dev, &bus->devices, bus_list) {
285 cpci_enable_device(dev);
286 }
287 }
288}
289
290int cpci_configure_slot(struct slot* slot) 256int cpci_configure_slot(struct slot* slot)
291{ 257{
292 unsigned char busnr; 258 unsigned char busnr;
@@ -294,14 +260,14 @@ int cpci_configure_slot(struct slot* slot)
294 260
295 dbg("%s - enter", __FUNCTION__); 261 dbg("%s - enter", __FUNCTION__);
296 262
297 if(slot->dev == NULL) { 263 if (slot->dev == NULL) {
298 dbg("pci_dev null, finding %02x:%02x:%x", 264 dbg("pci_dev null, finding %02x:%02x:%x",
299 slot->bus->number, PCI_SLOT(slot->devfn), PCI_FUNC(slot->devfn)); 265 slot->bus->number, PCI_SLOT(slot->devfn), PCI_FUNC(slot->devfn));
300 slot->dev = pci_find_slot(slot->bus->number, slot->devfn); 266 slot->dev = pci_get_slot(slot->bus, slot->devfn);
301 } 267 }
302 268
303 /* Still NULL? Well then scan for it! */ 269 /* Still NULL? Well then scan for it! */
304 if(slot->dev == NULL) { 270 if (slot->dev == NULL) {
305 int n; 271 int n;
306 dbg("pci_dev still null"); 272 dbg("pci_dev still null");
307 273
@@ -311,10 +277,10 @@ int cpci_configure_slot(struct slot* slot)
311 */ 277 */
312 n = pci_scan_slot(slot->bus, slot->devfn); 278 n = pci_scan_slot(slot->bus, slot->devfn);
313 dbg("%s: pci_scan_slot returned %d", __FUNCTION__, n); 279 dbg("%s: pci_scan_slot returned %d", __FUNCTION__, n);
314 if(n > 0) 280 if (n > 0)
315 pci_bus_add_devices(slot->bus); 281 pci_bus_add_devices(slot->bus);
316 slot->dev = pci_find_slot(slot->bus->number, slot->devfn); 282 slot->dev = pci_get_slot(slot->bus, slot->devfn);
317 if(slot->dev == NULL) { 283 if (slot->dev == NULL) {
318 err("Could not find PCI device for slot %02x", slot->number); 284 err("Could not find PCI device for slot %02x", slot->number);
319 return 1; 285 return 1;
320 } 286 }
@@ -329,8 +295,6 @@ int cpci_configure_slot(struct slot* slot)
329 295
330 pci_bus_assign_resources(slot->dev->bus); 296 pci_bus_assign_resources(slot->dev->bus);
331 297
332 cpci_enable_device(slot->dev);
333
334 dbg("%s - exit", __FUNCTION__); 298 dbg("%s - exit", __FUNCTION__);
335 return 0; 299 return 0;
336} 300}
@@ -341,15 +305,15 @@ int cpci_unconfigure_slot(struct slot* slot)
341 struct pci_dev *dev; 305 struct pci_dev *dev;
342 306
343 dbg("%s - enter", __FUNCTION__); 307 dbg("%s - enter", __FUNCTION__);
344 if(!slot->dev) { 308 if (!slot->dev) {
345 err("No device for slot %02x\n", slot->number); 309 err("No device for slot %02x\n", slot->number);
346 return -ENODEV; 310 return -ENODEV;
347 } 311 }
348 312
349 for (i = 0; i < 8; i++) { 313 for (i = 0; i < 8; i++) {
350 dev = pci_find_slot(slot->bus->number, 314 dev = pci_get_slot(slot->bus,
351 PCI_DEVFN(PCI_SLOT(slot->devfn), i)); 315 PCI_DEVFN(PCI_SLOT(slot->devfn), i));
352 if(dev) { 316 if (dev) {
353 pci_remove_bus_device(dev); 317 pci_remove_bus_device(dev);
354 slot->dev = NULL; 318 slot->dev = NULL;
355 } 319 }
diff --git a/drivers/pci/hotplug/shpchprm_acpi.c b/drivers/pci/hotplug/shpchprm_acpi.c
index 243a51d88b86..7957cdc72cd0 100644
--- a/drivers/pci/hotplug/shpchprm_acpi.c
+++ b/drivers/pci/hotplug/shpchprm_acpi.c
@@ -1626,7 +1626,7 @@ int shpchprm_set_hpp(
1626 pci_bus->number = func->bus; 1626 pci_bus->number = func->bus;
1627 devfn = PCI_DEVFN(func->device, func->function); 1627 devfn = PCI_DEVFN(func->device, func->function);
1628 1628
1629 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus); 1629 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->slot_bus);
1630 1630
1631 if (ab) { 1631 if (ab) {
1632 if (ab->_hpp) { 1632 if (ab->_hpp) {
@@ -1681,7 +1681,7 @@ void shpchprm_enable_card(
1681 | PCI_COMMAND_IO | PCI_COMMAND_MEMORY; 1681 | PCI_COMMAND_IO | PCI_COMMAND_MEMORY;
1682 bcmd = bcommand = bcommand | PCI_BRIDGE_CTL_NO_ISA; 1682 bcmd = bcommand = bcommand | PCI_BRIDGE_CTL_NO_ISA;
1683 1683
1684 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus); 1684 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->slot_bus);
1685 if (ab) { 1685 if (ab) {
1686 if (ab->_hpp) { 1686 if (ab->_hpp) {
1687 if (ab->_hpp->enable_perr) { 1687 if (ab->_hpp->enable_perr) {
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-30 23:40:12 -0500