diff options
Diffstat (limited to 'drivers')
228 files changed, 8271 insertions, 3334 deletions
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig index dd8729d674e5..0ed42d8870c7 100644 --- a/drivers/acpi/Kconfig +++ b/drivers/acpi/Kconfig | |||
@@ -211,6 +211,18 @@ config ACPI_HOTPLUG_CPU | |||
211 | select ACPI_CONTAINER | 211 | select ACPI_CONTAINER |
212 | default y | 212 | default y |
213 | 213 | ||
214 | config ACPI_PROCESSOR_AGGREGATOR | ||
215 | tristate "Processor Aggregator" | ||
216 | depends on ACPI_PROCESSOR | ||
217 | depends on EXPERIMENTAL | ||
218 | depends on X86 | ||
219 | help | ||
220 | ACPI 4.0 defines processor Aggregator, which enables OS to perform | ||
221 | specfic processor configuration and control that applies to all | ||
222 | processors in the platform. Currently only logical processor idling | ||
223 | is defined, which is to reduce power consumption. This driver | ||
224 | support the new device. | ||
225 | |||
214 | config ACPI_THERMAL | 226 | config ACPI_THERMAL |
215 | tristate "Thermal Zone" | 227 | tristate "Thermal Zone" |
216 | depends on ACPI_PROCESSOR | 228 | depends on ACPI_PROCESSOR |
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile index 82cd49dc603b..7702118509a0 100644 --- a/drivers/acpi/Makefile +++ b/drivers/acpi/Makefile | |||
@@ -62,3 +62,5 @@ obj-$(CONFIG_ACPI_POWER_METER) += power_meter.o | |||
62 | processor-y := processor_core.o processor_throttling.o | 62 | processor-y := processor_core.o processor_throttling.o |
63 | processor-y += processor_idle.o processor_thermal.o | 63 | processor-y += processor_idle.o processor_thermal.o |
64 | processor-$(CONFIG_CPU_FREQ) += processor_perflib.o | 64 | processor-$(CONFIG_CPU_FREQ) += processor_perflib.o |
65 | |||
66 | obj-$(CONFIG_ACPI_PROCESSOR_AGGREGATOR) += acpi_pad.o | ||
diff --git a/drivers/acpi/acpi_pad.c b/drivers/acpi/acpi_pad.c new file mode 100644 index 000000000000..0d2cdb86158b --- /dev/null +++ b/drivers/acpi/acpi_pad.c | |||
@@ -0,0 +1,514 @@ | |||
1 | /* | ||
2 | * acpi_pad.c ACPI Processor Aggregator Driver | ||
3 | * | ||
4 | * Copyright (c) 2009, Intel Corporation. | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify it | ||
7 | * under the terms and conditions of the GNU General Public License, | ||
8 | * version 2, as published by the Free Software Foundation. | ||
9 | * | ||
10 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
13 | * more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License along with | ||
16 | * this program; if not, write to the Free Software Foundation, Inc., | ||
17 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | ||
18 | * | ||
19 | */ | ||
20 | |||
21 | #include <linux/kernel.h> | ||
22 | #include <linux/cpumask.h> | ||
23 | #include <linux/module.h> | ||
24 | #include <linux/init.h> | ||
25 | #include <linux/types.h> | ||
26 | #include <linux/kthread.h> | ||
27 | #include <linux/freezer.h> | ||
28 | #include <linux/cpu.h> | ||
29 | #include <linux/clockchips.h> | ||
30 | #include <acpi/acpi_bus.h> | ||
31 | #include <acpi/acpi_drivers.h> | ||
32 | |||
33 | #define ACPI_PROCESSOR_AGGREGATOR_CLASS "processor_aggregator" | ||
34 | #define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator" | ||
35 | #define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80 | ||
36 | static DEFINE_MUTEX(isolated_cpus_lock); | ||
37 | |||
38 | #define MWAIT_SUBSTATE_MASK (0xf) | ||
39 | #define MWAIT_CSTATE_MASK (0xf) | ||
40 | #define MWAIT_SUBSTATE_SIZE (4) | ||
41 | #define CPUID_MWAIT_LEAF (5) | ||
42 | #define CPUID5_ECX_EXTENSIONS_SUPPORTED (0x1) | ||
43 | #define CPUID5_ECX_INTERRUPT_BREAK (0x2) | ||
44 | static unsigned long power_saving_mwait_eax; | ||
45 | static void power_saving_mwait_init(void) | ||
46 | { | ||
47 | unsigned int eax, ebx, ecx, edx; | ||
48 | unsigned int highest_cstate = 0; | ||
49 | unsigned int highest_subcstate = 0; | ||
50 | int i; | ||
51 | |||
52 | if (!boot_cpu_has(X86_FEATURE_MWAIT)) | ||
53 | return; | ||
54 | if (boot_cpu_data.cpuid_level < CPUID_MWAIT_LEAF) | ||
55 | return; | ||
56 | |||
57 | cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &edx); | ||
58 | |||
59 | if (!(ecx & CPUID5_ECX_EXTENSIONS_SUPPORTED) || | ||
60 | !(ecx & CPUID5_ECX_INTERRUPT_BREAK)) | ||
61 | return; | ||
62 | |||
63 | edx >>= MWAIT_SUBSTATE_SIZE; | ||
64 | for (i = 0; i < 7 && edx; i++, edx >>= MWAIT_SUBSTATE_SIZE) { | ||
65 | if (edx & MWAIT_SUBSTATE_MASK) { | ||
66 | highest_cstate = i; | ||
67 | highest_subcstate = edx & MWAIT_SUBSTATE_MASK; | ||
68 | } | ||
69 | } | ||
70 | power_saving_mwait_eax = (highest_cstate << MWAIT_SUBSTATE_SIZE) | | ||
71 | (highest_subcstate - 1); | ||
72 | |||
73 | for_each_online_cpu(i) | ||
74 | clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ON, &i); | ||
75 | |||
76 | #if defined(CONFIG_GENERIC_TIME) && defined(CONFIG_X86) | ||
77 | switch (boot_cpu_data.x86_vendor) { | ||
78 | case X86_VENDOR_AMD: | ||
79 | case X86_VENDOR_INTEL: | ||
80 | /* | ||
81 | * AMD Fam10h TSC will tick in all | ||
82 | * C/P/S0/S1 states when this bit is set. | ||
83 | */ | ||
84 | if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC)) | ||
85 | return; | ||
86 | |||
87 | /*FALL THROUGH*/ | ||
88 | default: | ||
89 | /* TSC could halt in idle, so notify users */ | ||
90 | mark_tsc_unstable("TSC halts in idle"); | ||
91 | } | ||
92 | #endif | ||
93 | } | ||
94 | |||
95 | static unsigned long cpu_weight[NR_CPUS]; | ||
96 | static int tsk_in_cpu[NR_CPUS] = {[0 ... NR_CPUS-1] = -1}; | ||
97 | static DECLARE_BITMAP(pad_busy_cpus_bits, NR_CPUS); | ||
98 | static void round_robin_cpu(unsigned int tsk_index) | ||
99 | { | ||
100 | struct cpumask *pad_busy_cpus = to_cpumask(pad_busy_cpus_bits); | ||
101 | cpumask_var_t tmp; | ||
102 | int cpu; | ||
103 | unsigned long min_weight = -1, preferred_cpu; | ||
104 | |||
105 | if (!alloc_cpumask_var(&tmp, GFP_KERNEL)) | ||
106 | return; | ||
107 | |||
108 | mutex_lock(&isolated_cpus_lock); | ||
109 | cpumask_clear(tmp); | ||
110 | for_each_cpu(cpu, pad_busy_cpus) | ||
111 | cpumask_or(tmp, tmp, topology_thread_cpumask(cpu)); | ||
112 | cpumask_andnot(tmp, cpu_online_mask, tmp); | ||
113 | /* avoid HT sibilings if possible */ | ||
114 | if (cpumask_empty(tmp)) | ||
115 | cpumask_andnot(tmp, cpu_online_mask, pad_busy_cpus); | ||
116 | if (cpumask_empty(tmp)) { | ||
117 | mutex_unlock(&isolated_cpus_lock); | ||
118 | return; | ||
119 | } | ||
120 | for_each_cpu(cpu, tmp) { | ||
121 | if (cpu_weight[cpu] < min_weight) { | ||
122 | min_weight = cpu_weight[cpu]; | ||
123 | preferred_cpu = cpu; | ||
124 | } | ||
125 | } | ||
126 | |||
127 | if (tsk_in_cpu[tsk_index] != -1) | ||
128 | cpumask_clear_cpu(tsk_in_cpu[tsk_index], pad_busy_cpus); | ||
129 | tsk_in_cpu[tsk_index] = preferred_cpu; | ||
130 | cpumask_set_cpu(preferred_cpu, pad_busy_cpus); | ||
131 | cpu_weight[preferred_cpu]++; | ||
132 | mutex_unlock(&isolated_cpus_lock); | ||
133 | |||
134 | set_cpus_allowed_ptr(current, cpumask_of(preferred_cpu)); | ||
135 | } | ||
136 | |||
137 | static void exit_round_robin(unsigned int tsk_index) | ||
138 | { | ||
139 | struct cpumask *pad_busy_cpus = to_cpumask(pad_busy_cpus_bits); | ||
140 | cpumask_clear_cpu(tsk_in_cpu[tsk_index], pad_busy_cpus); | ||
141 | tsk_in_cpu[tsk_index] = -1; | ||
142 | } | ||
143 | |||
144 | static unsigned int idle_pct = 5; /* percentage */ | ||
145 | static unsigned int round_robin_time = 10; /* second */ | ||
146 | static int power_saving_thread(void *data) | ||
147 | { | ||
148 | struct sched_param param = {.sched_priority = 1}; | ||
149 | int do_sleep; | ||
150 | unsigned int tsk_index = (unsigned long)data; | ||
151 | u64 last_jiffies = 0; | ||
152 | |||
153 | sched_setscheduler(current, SCHED_RR, ¶m); | ||
154 | |||
155 | while (!kthread_should_stop()) { | ||
156 | int cpu; | ||
157 | u64 expire_time; | ||
158 | |||
159 | try_to_freeze(); | ||
160 | |||
161 | /* round robin to cpus */ | ||
162 | if (last_jiffies + round_robin_time * HZ < jiffies) { | ||
163 | last_jiffies = jiffies; | ||
164 | round_robin_cpu(tsk_index); | ||
165 | } | ||
166 | |||
167 | do_sleep = 0; | ||
168 | |||
169 | current_thread_info()->status &= ~TS_POLLING; | ||
170 | /* | ||
171 | * TS_POLLING-cleared state must be visible before we test | ||
172 | * NEED_RESCHED: | ||
173 | */ | ||
174 | smp_mb(); | ||
175 | |||
176 | expire_time = jiffies + HZ * (100 - idle_pct) / 100; | ||
177 | |||
178 | while (!need_resched()) { | ||
179 | local_irq_disable(); | ||
180 | cpu = smp_processor_id(); | ||
181 | clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, | ||
182 | &cpu); | ||
183 | stop_critical_timings(); | ||
184 | |||
185 | __monitor((void *)¤t_thread_info()->flags, 0, 0); | ||
186 | smp_mb(); | ||
187 | if (!need_resched()) | ||
188 | __mwait(power_saving_mwait_eax, 1); | ||
189 | |||
190 | start_critical_timings(); | ||
191 | clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, | ||
192 | &cpu); | ||
193 | local_irq_enable(); | ||
194 | |||
195 | if (jiffies > expire_time) { | ||
196 | do_sleep = 1; | ||
197 | break; | ||
198 | } | ||
199 | } | ||
200 | |||
201 | current_thread_info()->status |= TS_POLLING; | ||
202 | |||
203 | /* | ||
204 | * current sched_rt has threshold for rt task running time. | ||
205 | * When a rt task uses 95% CPU time, the rt thread will be | ||
206 | * scheduled out for 5% CPU time to not starve other tasks. But | ||
207 | * the mechanism only works when all CPUs have RT task running, | ||
208 | * as if one CPU hasn't RT task, RT task from other CPUs will | ||
209 | * borrow CPU time from this CPU and cause RT task use > 95% | ||
210 | * CPU time. To make 'avoid staration' work, takes a nap here. | ||
211 | */ | ||
212 | if (do_sleep) | ||
213 | schedule_timeout_killable(HZ * idle_pct / 100); | ||
214 | } | ||
215 | |||
216 | exit_round_robin(tsk_index); | ||
217 | return 0; | ||
218 | } | ||
219 | |||
220 | static struct task_struct *ps_tsks[NR_CPUS]; | ||
221 | static unsigned int ps_tsk_num; | ||
222 | static int create_power_saving_task(void) | ||
223 | { | ||
224 | ps_tsks[ps_tsk_num] = kthread_run(power_saving_thread, | ||
225 | (void *)(unsigned long)ps_tsk_num, | ||
226 | "power_saving/%d", ps_tsk_num); | ||
227 | if (ps_tsks[ps_tsk_num]) { | ||
228 | ps_tsk_num++; | ||
229 | return 0; | ||
230 | } | ||
231 | return -EINVAL; | ||
232 | } | ||
233 | |||
234 | static void destroy_power_saving_task(void) | ||
235 | { | ||
236 | if (ps_tsk_num > 0) { | ||
237 | ps_tsk_num--; | ||
238 | kthread_stop(ps_tsks[ps_tsk_num]); | ||
239 | } | ||
240 | } | ||
241 | |||
242 | static void set_power_saving_task_num(unsigned int num) | ||
243 | { | ||
244 | if (num > ps_tsk_num) { | ||
245 | while (ps_tsk_num < num) { | ||
246 | if (create_power_saving_task()) | ||
247 | return; | ||
248 | } | ||
249 | } else if (num < ps_tsk_num) { | ||
250 | while (ps_tsk_num > num) | ||
251 | destroy_power_saving_task(); | ||
252 | } | ||
253 | } | ||
254 | |||
255 | static int acpi_pad_idle_cpus(unsigned int num_cpus) | ||
256 | { | ||
257 | get_online_cpus(); | ||
258 | |||
259 | num_cpus = min_t(unsigned int, num_cpus, num_online_cpus()); | ||
260 | set_power_saving_task_num(num_cpus); | ||
261 | |||
262 | put_online_cpus(); | ||
263 | return 0; | ||
264 | } | ||
265 | |||
266 | static uint32_t acpi_pad_idle_cpus_num(void) | ||
267 | { | ||
268 | return ps_tsk_num; | ||
269 | } | ||
270 | |||
271 | static ssize_t acpi_pad_rrtime_store(struct device *dev, | ||
272 | struct device_attribute *attr, const char *buf, size_t count) | ||
273 | { | ||
274 | unsigned long num; | ||
275 | if (strict_strtoul(buf, 0, &num)) | ||
276 | return -EINVAL; | ||
277 | if (num < 1 || num >= 100) | ||
278 | return -EINVAL; | ||
279 | mutex_lock(&isolated_cpus_lock); | ||
280 | round_robin_time = num; | ||
281 | mutex_unlock(&isolated_cpus_lock); | ||
282 | return count; | ||
283 | } | ||
284 | |||
285 | static ssize_t acpi_pad_rrtime_show(struct device *dev, | ||
286 | struct device_attribute *attr, char *buf) | ||
287 | { | ||
288 | return scnprintf(buf, PAGE_SIZE, "%d", round_robin_time); | ||
289 | } | ||
290 | static DEVICE_ATTR(rrtime, S_IRUGO|S_IWUSR, | ||
291 | acpi_pad_rrtime_show, | ||
292 | acpi_pad_rrtime_store); | ||
293 | |||
294 | static ssize_t acpi_pad_idlepct_store(struct device *dev, | ||
295 | struct device_attribute *attr, const char *buf, size_t count) | ||
296 | { | ||
297 | unsigned long num; | ||
298 | if (strict_strtoul(buf, 0, &num)) | ||
299 | return -EINVAL; | ||
300 | if (num < 1 || num >= 100) | ||
301 | return -EINVAL; | ||
302 | mutex_lock(&isolated_cpus_lock); | ||
303 | idle_pct = num; | ||
304 | mutex_unlock(&isolated_cpus_lock); | ||
305 | return count; | ||
306 | } | ||
307 | |||
308 | static ssize_t acpi_pad_idlepct_show(struct device *dev, | ||
309 | struct device_attribute *attr, char *buf) | ||
310 | { | ||
311 | return scnprintf(buf, PAGE_SIZE, "%d", idle_pct); | ||
312 | } | ||
313 | static DEVICE_ATTR(idlepct, S_IRUGO|S_IWUSR, | ||
314 | acpi_pad_idlepct_show, | ||
315 | acpi_pad_idlepct_store); | ||
316 | |||
317 | static ssize_t acpi_pad_idlecpus_store(struct device *dev, | ||
318 | struct device_attribute *attr, const char *buf, size_t count) | ||
319 | { | ||
320 | unsigned long num; | ||
321 | if (strict_strtoul(buf, 0, &num)) | ||
322 | return -EINVAL; | ||
323 | mutex_lock(&isolated_cpus_lock); | ||
324 | acpi_pad_idle_cpus(num); | ||
325 | mutex_unlock(&isolated_cpus_lock); | ||
326 | return count; | ||
327 | } | ||
328 | |||
329 | static ssize_t acpi_pad_idlecpus_show(struct device *dev, | ||
330 | struct device_attribute *attr, char *buf) | ||
331 | { | ||
332 | return cpumask_scnprintf(buf, PAGE_SIZE, | ||
333 | to_cpumask(pad_busy_cpus_bits)); | ||
334 | } | ||
335 | static DEVICE_ATTR(idlecpus, S_IRUGO|S_IWUSR, | ||
336 | acpi_pad_idlecpus_show, | ||
337 | acpi_pad_idlecpus_store); | ||
338 | |||
339 | static int acpi_pad_add_sysfs(struct acpi_device *device) | ||
340 | { | ||
341 | int result; | ||
342 | |||
343 | result = device_create_file(&device->dev, &dev_attr_idlecpus); | ||
344 | if (result) | ||
345 | return -ENODEV; | ||
346 | result = device_create_file(&device->dev, &dev_attr_idlepct); | ||
347 | if (result) { | ||
348 | device_remove_file(&device->dev, &dev_attr_idlecpus); | ||
349 | return -ENODEV; | ||
350 | } | ||
351 | result = device_create_file(&device->dev, &dev_attr_rrtime); | ||
352 | if (result) { | ||
353 | device_remove_file(&device->dev, &dev_attr_idlecpus); | ||
354 | device_remove_file(&device->dev, &dev_attr_idlepct); | ||
355 | return -ENODEV; | ||
356 | } | ||
357 | return 0; | ||
358 | } | ||
359 | |||
360 | static void acpi_pad_remove_sysfs(struct acpi_device *device) | ||
361 | { | ||
362 | device_remove_file(&device->dev, &dev_attr_idlecpus); | ||
363 | device_remove_file(&device->dev, &dev_attr_idlepct); | ||
364 | device_remove_file(&device->dev, &dev_attr_rrtime); | ||
365 | } | ||
366 | |||
367 | /* Query firmware how many CPUs should be idle */ | ||
368 | static int acpi_pad_pur(acpi_handle handle, int *num_cpus) | ||
369 | { | ||
370 | struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; | ||
371 | acpi_status status; | ||
372 | union acpi_object *package; | ||
373 | int rev, num, ret = -EINVAL; | ||
374 | |||
375 | status = acpi_evaluate_object(handle, "_PUR", NULL, &buffer); | ||
376 | if (ACPI_FAILURE(status)) | ||
377 | return -EINVAL; | ||
378 | package = buffer.pointer; | ||
379 | if (package->type != ACPI_TYPE_PACKAGE || package->package.count != 2) | ||
380 | goto out; | ||
381 | rev = package->package.elements[0].integer.value; | ||
382 | num = package->package.elements[1].integer.value; | ||
383 | if (rev != 1) | ||
384 | goto out; | ||
385 | *num_cpus = num; | ||
386 | ret = 0; | ||
387 | out: | ||
388 | kfree(buffer.pointer); | ||
389 | return ret; | ||
390 | } | ||
391 | |||
392 | /* Notify firmware how many CPUs are idle */ | ||
393 | static void acpi_pad_ost(acpi_handle handle, int stat, | ||
394 | uint32_t idle_cpus) | ||
395 | { | ||
396 | union acpi_object params[3] = { | ||
397 | {.type = ACPI_TYPE_INTEGER,}, | ||
398 | {.type = ACPI_TYPE_INTEGER,}, | ||
399 | {.type = ACPI_TYPE_BUFFER,}, | ||
400 | }; | ||
401 | struct acpi_object_list arg_list = {3, params}; | ||
402 | |||
403 | params[0].integer.value = ACPI_PROCESSOR_AGGREGATOR_NOTIFY; | ||
404 | params[1].integer.value = stat; | ||
405 | params[2].buffer.length = 4; | ||
406 | params[2].buffer.pointer = (void *)&idle_cpus; | ||
407 | acpi_evaluate_object(handle, "_OST", &arg_list, NULL); | ||
408 | } | ||
409 | |||
410 | static void acpi_pad_handle_notify(acpi_handle handle) | ||
411 | { | ||
412 | int num_cpus, ret; | ||
413 | uint32_t idle_cpus; | ||
414 | |||
415 | mutex_lock(&isolated_cpus_lock); | ||
416 | if (acpi_pad_pur(handle, &num_cpus)) { | ||
417 | mutex_unlock(&isolated_cpus_lock); | ||
418 | return; | ||
419 | } | ||
420 | ret = acpi_pad_idle_cpus(num_cpus); | ||
421 | idle_cpus = acpi_pad_idle_cpus_num(); | ||
422 | if (!ret) | ||
423 | acpi_pad_ost(handle, 0, idle_cpus); | ||
424 | else | ||
425 | acpi_pad_ost(handle, 1, 0); | ||
426 | mutex_unlock(&isolated_cpus_lock); | ||
427 | } | ||
428 | |||
429 | static void acpi_pad_notify(acpi_handle handle, u32 event, | ||
430 | void *data) | ||
431 | { | ||
432 | struct acpi_device *device = data; | ||
433 | |||
434 | switch (event) { | ||
435 | case ACPI_PROCESSOR_AGGREGATOR_NOTIFY: | ||
436 | acpi_pad_handle_notify(handle); | ||
437 | acpi_bus_generate_proc_event(device, event, 0); | ||
438 | acpi_bus_generate_netlink_event(device->pnp.device_class, | ||
439 | dev_name(&device->dev), event, 0); | ||
440 | break; | ||
441 | default: | ||
442 | printk(KERN_WARNING"Unsupported event [0x%x]\n", event); | ||
443 | break; | ||
444 | } | ||
445 | } | ||
446 | |||
447 | static int acpi_pad_add(struct acpi_device *device) | ||
448 | { | ||
449 | acpi_status status; | ||
450 | |||
451 | strcpy(acpi_device_name(device), ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME); | ||
452 | strcpy(acpi_device_class(device), ACPI_PROCESSOR_AGGREGATOR_CLASS); | ||
453 | |||
454 | if (acpi_pad_add_sysfs(device)) | ||
455 | return -ENODEV; | ||
456 | |||
457 | status = acpi_install_notify_handler(device->handle, | ||
458 | ACPI_DEVICE_NOTIFY, acpi_pad_notify, device); | ||
459 | if (ACPI_FAILURE(status)) { | ||
460 | acpi_pad_remove_sysfs(device); | ||
461 | return -ENODEV; | ||
462 | } | ||
463 | |||
464 | return 0; | ||
465 | } | ||
466 | |||
467 | static int acpi_pad_remove(struct acpi_device *device, | ||
468 | int type) | ||
469 | { | ||
470 | mutex_lock(&isolated_cpus_lock); | ||
471 | acpi_pad_idle_cpus(0); | ||
472 | mutex_unlock(&isolated_cpus_lock); | ||
473 | |||
474 | acpi_remove_notify_handler(device->handle, | ||
475 | ACPI_DEVICE_NOTIFY, acpi_pad_notify); | ||
476 | acpi_pad_remove_sysfs(device); | ||
477 | return 0; | ||
478 | } | ||
479 | |||
480 | static const struct acpi_device_id pad_device_ids[] = { | ||
481 | {"ACPI000C", 0}, | ||
482 | {"", 0}, | ||
483 | }; | ||
484 | MODULE_DEVICE_TABLE(acpi, pad_device_ids); | ||
485 | |||
486 | static struct acpi_driver acpi_pad_driver = { | ||
487 | .name = "processor_aggregator", | ||
488 | .class = ACPI_PROCESSOR_AGGREGATOR_CLASS, | ||
489 | .ids = pad_device_ids, | ||
490 | .ops = { | ||
491 | .add = acpi_pad_add, | ||
492 | .remove = acpi_pad_remove, | ||
493 | }, | ||
494 | }; | ||
495 | |||
496 | static int __init acpi_pad_init(void) | ||
497 | { | ||
498 | power_saving_mwait_init(); | ||
499 | if (power_saving_mwait_eax == 0) | ||
500 | return -EINVAL; | ||
501 | |||
502 | return acpi_bus_register_driver(&acpi_pad_driver); | ||
503 | } | ||
504 | |||
505 | static void __exit acpi_pad_exit(void) | ||
506 | { | ||
507 | acpi_bus_unregister_driver(&acpi_pad_driver); | ||
508 | } | ||
509 | |||
510 | module_init(acpi_pad_init); | ||
511 | module_exit(acpi_pad_exit); | ||
512 | MODULE_AUTHOR("Shaohua Li<shaohua.li@intel.com>"); | ||
513 | MODULE_DESCRIPTION("ACPI Processor Aggregator Driver"); | ||
514 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c index 3a2cfefc71ab..7338b6a3e049 100644 --- a/drivers/acpi/dock.c +++ b/drivers/acpi/dock.c | |||
@@ -67,7 +67,7 @@ struct dock_station { | |||
67 | struct list_head dependent_devices; | 67 | struct list_head dependent_devices; |
68 | struct list_head hotplug_devices; | 68 | struct list_head hotplug_devices; |
69 | 69 | ||
70 | struct list_head sibiling; | 70 | struct list_head sibling; |
71 | struct platform_device *dock_device; | 71 | struct platform_device *dock_device; |
72 | }; | 72 | }; |
73 | static LIST_HEAD(dock_stations); | 73 | static LIST_HEAD(dock_stations); |
@@ -275,7 +275,7 @@ int is_dock_device(acpi_handle handle) | |||
275 | 275 | ||
276 | if (is_dock(handle)) | 276 | if (is_dock(handle)) |
277 | return 1; | 277 | return 1; |
278 | list_for_each_entry(dock_station, &dock_stations, sibiling) { | 278 | list_for_each_entry(dock_station, &dock_stations, sibling) { |
279 | if (find_dock_dependent_device(dock_station, handle)) | 279 | if (find_dock_dependent_device(dock_station, handle)) |
280 | return 1; | 280 | return 1; |
281 | } | 281 | } |
@@ -619,7 +619,7 @@ register_hotplug_dock_device(acpi_handle handle, struct acpi_dock_ops *ops, | |||
619 | * make sure this handle is for a device dependent on the dock, | 619 | * make sure this handle is for a device dependent on the dock, |
620 | * this would include the dock station itself | 620 | * this would include the dock station itself |
621 | */ | 621 | */ |
622 | list_for_each_entry(dock_station, &dock_stations, sibiling) { | 622 | list_for_each_entry(dock_station, &dock_stations, sibling) { |
623 | /* | 623 | /* |
624 | * An ATA bay can be in a dock and itself can be ejected | 624 | * An ATA bay can be in a dock and itself can be ejected |
625 | * seperately, so there are two 'dock stations' which need the | 625 | * seperately, so there are two 'dock stations' which need the |
@@ -651,7 +651,7 @@ void unregister_hotplug_dock_device(acpi_handle handle) | |||
651 | if (!dock_station_count) | 651 | if (!dock_station_count) |
652 | return; | 652 | return; |
653 | 653 | ||
654 | list_for_each_entry(dock_station, &dock_stations, sibiling) { | 654 | list_for_each_entry(dock_station, &dock_stations, sibling) { |
655 | dd = find_dock_dependent_device(dock_station, handle); | 655 | dd = find_dock_dependent_device(dock_station, handle); |
656 | if (dd) | 656 | if (dd) |
657 | dock_del_hotplug_device(dock_station, dd); | 657 | dock_del_hotplug_device(dock_station, dd); |
@@ -787,7 +787,7 @@ static int acpi_dock_notifier_call(struct notifier_block *this, | |||
787 | if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK | 787 | if (event != ACPI_NOTIFY_BUS_CHECK && event != ACPI_NOTIFY_DEVICE_CHECK |
788 | && event != ACPI_NOTIFY_EJECT_REQUEST) | 788 | && event != ACPI_NOTIFY_EJECT_REQUEST) |
789 | return 0; | 789 | return 0; |
790 | list_for_each_entry(dock_station, &dock_stations, sibiling) { | 790 | list_for_each_entry(dock_station, &dock_stations, sibling) { |
791 | if (dock_station->handle == handle) { | 791 | if (dock_station->handle == handle) { |
792 | struct dock_data *dock_data; | 792 | struct dock_data *dock_data; |
793 | 793 | ||
@@ -958,7 +958,7 @@ static int dock_add(acpi_handle handle) | |||
958 | dock_station->last_dock_time = jiffies - HZ; | 958 | dock_station->last_dock_time = jiffies - HZ; |
959 | INIT_LIST_HEAD(&dock_station->dependent_devices); | 959 | INIT_LIST_HEAD(&dock_station->dependent_devices); |
960 | INIT_LIST_HEAD(&dock_station->hotplug_devices); | 960 | INIT_LIST_HEAD(&dock_station->hotplug_devices); |
961 | INIT_LIST_HEAD(&dock_station->sibiling); | 961 | INIT_LIST_HEAD(&dock_station->sibling); |
962 | spin_lock_init(&dock_station->dd_lock); | 962 | spin_lock_init(&dock_station->dd_lock); |
963 | mutex_init(&dock_station->hp_lock); | 963 | mutex_init(&dock_station->hp_lock); |
964 | ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list); | 964 | ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list); |
@@ -1044,7 +1044,7 @@ static int dock_add(acpi_handle handle) | |||
1044 | add_dock_dependent_device(dock_station, dd); | 1044 | add_dock_dependent_device(dock_station, dd); |
1045 | 1045 | ||
1046 | dock_station_count++; | 1046 | dock_station_count++; |
1047 | list_add(&dock_station->sibiling, &dock_stations); | 1047 | list_add(&dock_station->sibling, &dock_stations); |
1048 | return 0; | 1048 | return 0; |
1049 | 1049 | ||
1050 | dock_add_err_unregister: | 1050 | dock_add_err_unregister: |
@@ -1149,7 +1149,7 @@ static void __exit dock_exit(void) | |||
1149 | struct dock_station *tmp; | 1149 | struct dock_station *tmp; |
1150 | 1150 | ||
1151 | unregister_acpi_bus_notifier(&dock_acpi_notifier); | 1151 | unregister_acpi_bus_notifier(&dock_acpi_notifier); |
1152 | list_for_each_entry_safe(dock_station, tmp, &dock_stations, sibiling) | 1152 | list_for_each_entry_safe(dock_station, tmp, &dock_stations, sibling) |
1153 | dock_remove(dock_station); | 1153 | dock_remove(dock_station); |
1154 | } | 1154 | } |
1155 | 1155 | ||
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c index f70796081c4c..baef28c1e630 100644 --- a/drivers/acpi/ec.c +++ b/drivers/acpi/ec.c | |||
@@ -119,6 +119,8 @@ static struct acpi_ec { | |||
119 | } *boot_ec, *first_ec; | 119 | } *boot_ec, *first_ec; |
120 | 120 | ||
121 | static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */ | 121 | static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */ |
122 | static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */ | ||
123 | static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */ | ||
122 | 124 | ||
123 | /* -------------------------------------------------------------------------- | 125 | /* -------------------------------------------------------------------------- |
124 | Transaction Management | 126 | Transaction Management |
@@ -232,10 +234,8 @@ static int ec_poll(struct acpi_ec *ec) | |||
232 | } | 234 | } |
233 | advance_transaction(ec, acpi_ec_read_status(ec)); | 235 | advance_transaction(ec, acpi_ec_read_status(ec)); |
234 | } while (time_before(jiffies, delay)); | 236 | } while (time_before(jiffies, delay)); |
235 | if (!ec->curr->irq_count || | 237 | if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) |
236 | (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)) | ||
237 | break; | 238 | break; |
238 | /* try restart command if we get any false interrupts */ | ||
239 | pr_debug(PREFIX "controller reset, restart transaction\n"); | 239 | pr_debug(PREFIX "controller reset, restart transaction\n"); |
240 | spin_lock_irqsave(&ec->curr_lock, flags); | 240 | spin_lock_irqsave(&ec->curr_lock, flags); |
241 | start_transaction(ec); | 241 | start_transaction(ec); |
@@ -899,6 +899,44 @@ static const struct acpi_device_id ec_device_ids[] = { | |||
899 | {"", 0}, | 899 | {"", 0}, |
900 | }; | 900 | }; |
901 | 901 | ||
902 | /* Some BIOS do not survive early DSDT scan, skip it */ | ||
903 | static int ec_skip_dsdt_scan(const struct dmi_system_id *id) | ||
904 | { | ||
905 | EC_FLAGS_SKIP_DSDT_SCAN = 1; | ||
906 | return 0; | ||
907 | } | ||
908 | |||
909 | /* ASUStek often supplies us with broken ECDT, validate it */ | ||
910 | static int ec_validate_ecdt(const struct dmi_system_id *id) | ||
911 | { | ||
912 | EC_FLAGS_VALIDATE_ECDT = 1; | ||
913 | return 0; | ||
914 | } | ||
915 | |||
916 | /* MSI EC needs special treatment, enable it */ | ||
917 | static int ec_flag_msi(const struct dmi_system_id *id) | ||
918 | { | ||
919 | EC_FLAGS_MSI = 1; | ||
920 | EC_FLAGS_VALIDATE_ECDT = 1; | ||
921 | return 0; | ||
922 | } | ||
923 | |||
924 | static struct dmi_system_id __initdata ec_dmi_table[] = { | ||
925 | { | ||
926 | ec_skip_dsdt_scan, "Compal JFL92", { | ||
927 | DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"), | ||
928 | DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL}, | ||
929 | { | ||
930 | ec_flag_msi, "MSI hardware", { | ||
931 | DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star"), | ||
932 | DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star") }, NULL}, | ||
933 | { | ||
934 | ec_validate_ecdt, "ASUS hardware", { | ||
935 | DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL}, | ||
936 | {}, | ||
937 | }; | ||
938 | |||
939 | |||
902 | int __init acpi_ec_ecdt_probe(void) | 940 | int __init acpi_ec_ecdt_probe(void) |
903 | { | 941 | { |
904 | acpi_status status; | 942 | acpi_status status; |
@@ -911,11 +949,7 @@ int __init acpi_ec_ecdt_probe(void) | |||
911 | /* | 949 | /* |
912 | * Generate a boot ec context | 950 | * Generate a boot ec context |
913 | */ | 951 | */ |
914 | if (dmi_name_in_vendors("Micro-Star") || | 952 | dmi_check_system(ec_dmi_table); |
915 | dmi_name_in_vendors("Notebook")) { | ||
916 | pr_info(PREFIX "Enabling special treatment for EC from MSI.\n"); | ||
917 | EC_FLAGS_MSI = 1; | ||
918 | } | ||
919 | status = acpi_get_table(ACPI_SIG_ECDT, 1, | 953 | status = acpi_get_table(ACPI_SIG_ECDT, 1, |
920 | (struct acpi_table_header **)&ecdt_ptr); | 954 | (struct acpi_table_header **)&ecdt_ptr); |
921 | if (ACPI_SUCCESS(status)) { | 955 | if (ACPI_SUCCESS(status)) { |
@@ -926,7 +960,7 @@ int __init acpi_ec_ecdt_probe(void) | |||
926 | boot_ec->handle = ACPI_ROOT_OBJECT; | 960 | boot_ec->handle = ACPI_ROOT_OBJECT; |
927 | acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle); | 961 | acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle); |
928 | /* Don't trust ECDT, which comes from ASUSTek */ | 962 | /* Don't trust ECDT, which comes from ASUSTek */ |
929 | if (!dmi_name_in_vendors("ASUS") && EC_FLAGS_MSI == 0) | 963 | if (!EC_FLAGS_VALIDATE_ECDT) |
930 | goto install; | 964 | goto install; |
931 | saved_ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL); | 965 | saved_ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL); |
932 | if (!saved_ec) | 966 | if (!saved_ec) |
@@ -934,6 +968,10 @@ int __init acpi_ec_ecdt_probe(void) | |||
934 | memcpy(saved_ec, boot_ec, sizeof(struct acpi_ec)); | 968 | memcpy(saved_ec, boot_ec, sizeof(struct acpi_ec)); |
935 | /* fall through */ | 969 | /* fall through */ |
936 | } | 970 | } |
971 | |||
972 | if (EC_FLAGS_SKIP_DSDT_SCAN) | ||
973 | return -ENODEV; | ||
974 | |||
937 | /* This workaround is needed only on some broken machines, | 975 | /* This workaround is needed only on some broken machines, |
938 | * which require early EC, but fail to provide ECDT */ | 976 | * which require early EC, but fail to provide ECDT */ |
939 | printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n"); | 977 | printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n"); |
diff --git a/drivers/acpi/proc.c b/drivers/acpi/proc.c index d0d550d22a6d..f8b6f555ba52 100644 --- a/drivers/acpi/proc.c +++ b/drivers/acpi/proc.c | |||
@@ -398,6 +398,8 @@ acpi_system_write_wakeup_device(struct file *file, | |||
398 | 398 | ||
399 | if (len > 4) | 399 | if (len > 4) |
400 | len = 4; | 400 | len = 4; |
401 | if (len < 0) | ||
402 | return -EFAULT; | ||
401 | 403 | ||
402 | if (copy_from_user(strbuf, buffer, len)) | 404 | if (copy_from_user(strbuf, buffer, len)) |
403 | return -EFAULT; | 405 | return -EFAULT; |
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c index c2d4d6e09364..c567b46dfa0f 100644 --- a/drivers/acpi/processor_core.c +++ b/drivers/acpi/processor_core.c | |||
@@ -863,13 +863,6 @@ static int acpi_processor_add(struct acpi_device *device) | |||
863 | goto err_remove_sysfs; | 863 | goto err_remove_sysfs; |
864 | } | 864 | } |
865 | 865 | ||
866 | if (pr->flags.throttling) { | ||
867 | printk(KERN_INFO PREFIX "%s [%s] (supports", | ||
868 | acpi_device_name(device), acpi_device_bid(device)); | ||
869 | printk(" %d throttling states", pr->throttling.state_count); | ||
870 | printk(")\n"); | ||
871 | } | ||
872 | |||
873 | return 0; | 866 | return 0; |
874 | 867 | ||
875 | err_remove_sysfs: | 868 | err_remove_sysfs: |
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c index 468921bed22f..14a7481c97d7 100644 --- a/drivers/acpi/scan.c +++ b/drivers/acpi/scan.c | |||
@@ -1052,6 +1052,8 @@ static void acpi_device_set_id(struct acpi_device *device) | |||
1052 | device->flags.bus_address = 1; | 1052 | device->flags.bus_address = 1; |
1053 | } | 1053 | } |
1054 | 1054 | ||
1055 | kfree(info); | ||
1056 | |||
1055 | /* | 1057 | /* |
1056 | * Some devices don't reliably have _HIDs & _CIDs, so add | 1058 | * Some devices don't reliably have _HIDs & _CIDs, so add |
1057 | * synthetic HIDs to make sure drivers can find them. | 1059 | * synthetic HIDs to make sure drivers can find them. |
@@ -1325,13 +1327,8 @@ static int acpi_bus_scan(acpi_handle handle, struct acpi_bus_ops *ops, | |||
1325 | struct acpi_device **child) | 1327 | struct acpi_device **child) |
1326 | { | 1328 | { |
1327 | acpi_status status; | 1329 | acpi_status status; |
1328 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; | ||
1329 | void *device = NULL; | 1330 | void *device = NULL; |
1330 | 1331 | ||
1331 | acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); | ||
1332 | printk(KERN_INFO PREFIX "Enumerating devices from [%s]\n", | ||
1333 | (char *) buffer.pointer); | ||
1334 | |||
1335 | status = acpi_bus_check_add(handle, 0, ops, &device); | 1332 | status = acpi_bus_check_add(handle, 0, ops, &device); |
1336 | if (ACPI_SUCCESS(status)) | 1333 | if (ACPI_SUCCESS(status)) |
1337 | acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, | 1334 | acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, |
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c index a4fddb24476f..f6e54bf8dd96 100644 --- a/drivers/acpi/video.c +++ b/drivers/acpi/video.c | |||
@@ -285,7 +285,7 @@ static int acpi_video_device_brightness_open_fs(struct inode *inode, | |||
285 | struct file *file); | 285 | struct file *file); |
286 | static ssize_t acpi_video_device_write_brightness(struct file *file, | 286 | static ssize_t acpi_video_device_write_brightness(struct file *file, |
287 | const char __user *buffer, size_t count, loff_t *data); | 287 | const char __user *buffer, size_t count, loff_t *data); |
288 | static struct file_operations acpi_video_device_brightness_fops = { | 288 | static const struct file_operations acpi_video_device_brightness_fops = { |
289 | .owner = THIS_MODULE, | 289 | .owner = THIS_MODULE, |
290 | .open = acpi_video_device_brightness_open_fs, | 290 | .open = acpi_video_device_brightness_open_fs, |
291 | .read = seq_read, | 291 | .read = seq_read, |
diff --git a/drivers/atm/ambassador.c b/drivers/atm/ambassador.c index 703364b52170..66e181345b3a 100644 --- a/drivers/atm/ambassador.c +++ b/drivers/atm/ambassador.c | |||
@@ -1306,14 +1306,6 @@ static void amb_close (struct atm_vcc * atm_vcc) { | |||
1306 | return; | 1306 | return; |
1307 | } | 1307 | } |
1308 | 1308 | ||
1309 | /********** Set socket options for a VC **********/ | ||
1310 | |||
1311 | // int amb_getsockopt (struct atm_vcc * atm_vcc, int level, int optname, void * optval, int optlen); | ||
1312 | |||
1313 | /********** Set socket options for a VC **********/ | ||
1314 | |||
1315 | // int amb_setsockopt (struct atm_vcc * atm_vcc, int level, int optname, void * optval, int optlen); | ||
1316 | |||
1317 | /********** Send **********/ | 1309 | /********** Send **********/ |
1318 | 1310 | ||
1319 | static int amb_send (struct atm_vcc * atm_vcc, struct sk_buff * skb) { | 1311 | static int amb_send (struct atm_vcc * atm_vcc, struct sk_buff * skb) { |
diff --git a/drivers/atm/eni.c b/drivers/atm/eni.c index 5503bfc8e132..0c3026145443 100644 --- a/drivers/atm/eni.c +++ b/drivers/atm/eni.c | |||
@@ -2031,7 +2031,7 @@ static int eni_getsockopt(struct atm_vcc *vcc,int level,int optname, | |||
2031 | 2031 | ||
2032 | 2032 | ||
2033 | static int eni_setsockopt(struct atm_vcc *vcc,int level,int optname, | 2033 | static int eni_setsockopt(struct atm_vcc *vcc,int level,int optname, |
2034 | void __user *optval,int optlen) | 2034 | void __user *optval,unsigned int optlen) |
2035 | { | 2035 | { |
2036 | return -EINVAL; | 2036 | return -EINVAL; |
2037 | } | 2037 | } |
diff --git a/drivers/atm/firestream.c b/drivers/atm/firestream.c index b119640e1ee9..cd5049af47a9 100644 --- a/drivers/atm/firestream.c +++ b/drivers/atm/firestream.c | |||
@@ -1244,7 +1244,7 @@ static int fs_getsockopt(struct atm_vcc *vcc,int level,int optname, | |||
1244 | 1244 | ||
1245 | 1245 | ||
1246 | static int fs_setsockopt(struct atm_vcc *vcc,int level,int optname, | 1246 | static int fs_setsockopt(struct atm_vcc *vcc,int level,int optname, |
1247 | void __user *optval,int optlen) | 1247 | void __user *optval,unsigned int optlen) |
1248 | { | 1248 | { |
1249 | func_enter (); | 1249 | func_enter (); |
1250 | func_exit (); | 1250 | func_exit (); |
diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c index 10f000dbe448..f766cc46b4c4 100644 --- a/drivers/atm/fore200e.c +++ b/drivers/atm/fore200e.c | |||
@@ -1795,7 +1795,7 @@ fore200e_getsockopt(struct atm_vcc* vcc, int level, int optname, void __user *op | |||
1795 | 1795 | ||
1796 | 1796 | ||
1797 | static int | 1797 | static int |
1798 | fore200e_setsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, int optlen) | 1798 | fore200e_setsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, unsigned int optlen) |
1799 | { | 1799 | { |
1800 | /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */ | 1800 | /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */ |
1801 | 1801 | ||
diff --git a/drivers/atm/horizon.c b/drivers/atm/horizon.c index 01ce241dbeae..4e49021e67ee 100644 --- a/drivers/atm/horizon.c +++ b/drivers/atm/horizon.c | |||
@@ -2590,7 +2590,7 @@ static int hrz_getsockopt (struct atm_vcc * atm_vcc, int level, int optname, | |||
2590 | } | 2590 | } |
2591 | 2591 | ||
2592 | static int hrz_setsockopt (struct atm_vcc * atm_vcc, int level, int optname, | 2592 | static int hrz_setsockopt (struct atm_vcc * atm_vcc, int level, int optname, |
2593 | void *optval, int optlen) { | 2593 | void *optval, unsigned int optlen) { |
2594 | hrz_dev * dev = HRZ_DEV(atm_vcc->dev); | 2594 | hrz_dev * dev = HRZ_DEV(atm_vcc->dev); |
2595 | PRINTD (DBG_FLOW|DBG_VCC, "hrz_setsockopt"); | 2595 | PRINTD (DBG_FLOW|DBG_VCC, "hrz_setsockopt"); |
2596 | switch (level) { | 2596 | switch (level) { |
diff --git a/drivers/atm/iphase.c b/drivers/atm/iphase.c index 78c9736c3579..b2c1b37ab2e4 100644 --- a/drivers/atm/iphase.c +++ b/drivers/atm/iphase.c | |||
@@ -2862,7 +2862,7 @@ static int ia_getsockopt(struct atm_vcc *vcc, int level, int optname, | |||
2862 | } | 2862 | } |
2863 | 2863 | ||
2864 | static int ia_setsockopt(struct atm_vcc *vcc, int level, int optname, | 2864 | static int ia_setsockopt(struct atm_vcc *vcc, int level, int optname, |
2865 | void __user *optval, int optlen) | 2865 | void __user *optval, unsigned int optlen) |
2866 | { | 2866 | { |
2867 | IF_EVENT(printk(">ia_setsockopt\n");) | 2867 | IF_EVENT(printk(">ia_setsockopt\n");) |
2868 | return -EINVAL; | 2868 | return -EINVAL; |
diff --git a/drivers/atm/zatm.c b/drivers/atm/zatm.c index 752b1ba81f7e..2e9635be048c 100644 --- a/drivers/atm/zatm.c +++ b/drivers/atm/zatm.c | |||
@@ -1517,7 +1517,7 @@ static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname, | |||
1517 | 1517 | ||
1518 | 1518 | ||
1519 | static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname, | 1519 | static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname, |
1520 | void __user *optval,int optlen) | 1520 | void __user *optval,unsigned int optlen) |
1521 | { | 1521 | { |
1522 | return -EINVAL; | 1522 | return -EINVAL; |
1523 | } | 1523 | } |
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c index 6fa7b0fdbdfd..eb4fa1943944 100644 --- a/drivers/block/DAC960.c +++ b/drivers/block/DAC960.c | |||
@@ -38,6 +38,7 @@ | |||
38 | #include <linux/slab.h> | 38 | #include <linux/slab.h> |
39 | #include <linux/smp_lock.h> | 39 | #include <linux/smp_lock.h> |
40 | #include <linux/proc_fs.h> | 40 | #include <linux/proc_fs.h> |
41 | #include <linux/seq_file.h> | ||
41 | #include <linux/reboot.h> | 42 | #include <linux/reboot.h> |
42 | #include <linux/spinlock.h> | 43 | #include <linux/spinlock.h> |
43 | #include <linux/timer.h> | 44 | #include <linux/timer.h> |
@@ -6422,16 +6423,10 @@ static bool DAC960_V2_ExecuteUserCommand(DAC960_Controller_T *Controller, | |||
6422 | return true; | 6423 | return true; |
6423 | } | 6424 | } |
6424 | 6425 | ||
6425 | 6426 | static int dac960_proc_show(struct seq_file *m, void *v) | |
6426 | /* | ||
6427 | DAC960_ProcReadStatus implements reading /proc/rd/status. | ||
6428 | */ | ||
6429 | |||
6430 | static int DAC960_ProcReadStatus(char *Page, char **Start, off_t Offset, | ||
6431 | int Count, int *EOF, void *Data) | ||
6432 | { | 6427 | { |
6433 | unsigned char *StatusMessage = "OK\n"; | 6428 | unsigned char *StatusMessage = "OK\n"; |
6434 | int ControllerNumber, BytesAvailable; | 6429 | int ControllerNumber; |
6435 | for (ControllerNumber = 0; | 6430 | for (ControllerNumber = 0; |
6436 | ControllerNumber < DAC960_ControllerCount; | 6431 | ControllerNumber < DAC960_ControllerCount; |
6437 | ControllerNumber++) | 6432 | ControllerNumber++) |
@@ -6444,52 +6439,49 @@ static int DAC960_ProcReadStatus(char *Page, char **Start, off_t Offset, | |||
6444 | break; | 6439 | break; |
6445 | } | 6440 | } |
6446 | } | 6441 | } |
6447 | BytesAvailable = strlen(StatusMessage) - Offset; | 6442 | seq_puts(m, StatusMessage); |
6448 | if (Count >= BytesAvailable) | 6443 | return 0; |
6449 | { | ||
6450 | Count = BytesAvailable; | ||
6451 | *EOF = true; | ||
6452 | } | ||
6453 | if (Count <= 0) return 0; | ||
6454 | *Start = Page; | ||
6455 | memcpy(Page, &StatusMessage[Offset], Count); | ||
6456 | return Count; | ||
6457 | } | 6444 | } |
6458 | 6445 | ||
6446 | static int dac960_proc_open(struct inode *inode, struct file *file) | ||
6447 | { | ||
6448 | return single_open(file, dac960_proc_show, NULL); | ||
6449 | } | ||
6459 | 6450 | ||
6460 | /* | 6451 | static const struct file_operations dac960_proc_fops = { |
6461 | DAC960_ProcReadInitialStatus implements reading /proc/rd/cN/initial_status. | 6452 | .owner = THIS_MODULE, |
6462 | */ | 6453 | .open = dac960_proc_open, |
6454 | .read = seq_read, | ||
6455 | .llseek = seq_lseek, | ||
6456 | .release = single_release, | ||
6457 | }; | ||
6463 | 6458 | ||
6464 | static int DAC960_ProcReadInitialStatus(char *Page, char **Start, off_t Offset, | 6459 | static int dac960_initial_status_proc_show(struct seq_file *m, void *v) |
6465 | int Count, int *EOF, void *Data) | ||
6466 | { | 6460 | { |
6467 | DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data; | 6461 | DAC960_Controller_T *Controller = (DAC960_Controller_T *)m->private; |
6468 | int BytesAvailable = Controller->InitialStatusLength - Offset; | 6462 | seq_printf(m, "%.*s", Controller->InitialStatusLength, Controller->CombinedStatusBuffer); |
6469 | if (Count >= BytesAvailable) | 6463 | return 0; |
6470 | { | ||
6471 | Count = BytesAvailable; | ||
6472 | *EOF = true; | ||
6473 | } | ||
6474 | if (Count <= 0) return 0; | ||
6475 | *Start = Page; | ||
6476 | memcpy(Page, &Controller->CombinedStatusBuffer[Offset], Count); | ||
6477 | return Count; | ||
6478 | } | 6464 | } |
6479 | 6465 | ||
6466 | static int dac960_initial_status_proc_open(struct inode *inode, struct file *file) | ||
6467 | { | ||
6468 | return single_open(file, dac960_initial_status_proc_show, PDE(inode)->data); | ||
6469 | } | ||
6480 | 6470 | ||
6481 | /* | 6471 | static const struct file_operations dac960_initial_status_proc_fops = { |
6482 | DAC960_ProcReadCurrentStatus implements reading /proc/rd/cN/current_status. | 6472 | .owner = THIS_MODULE, |
6483 | */ | 6473 | .open = dac960_initial_status_proc_open, |
6474 | .read = seq_read, | ||
6475 | .llseek = seq_lseek, | ||
6476 | .release = single_release, | ||
6477 | }; | ||
6484 | 6478 | ||
6485 | static int DAC960_ProcReadCurrentStatus(char *Page, char **Start, off_t Offset, | 6479 | static int dac960_current_status_proc_show(struct seq_file *m, void *v) |
6486 | int Count, int *EOF, void *Data) | ||
6487 | { | 6480 | { |
6488 | DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data; | 6481 | DAC960_Controller_T *Controller = (DAC960_Controller_T *) m->private; |
6489 | unsigned char *StatusMessage = | 6482 | unsigned char *StatusMessage = |
6490 | "No Rebuild or Consistency Check in Progress\n"; | 6483 | "No Rebuild or Consistency Check in Progress\n"; |
6491 | int ProgressMessageLength = strlen(StatusMessage); | 6484 | int ProgressMessageLength = strlen(StatusMessage); |
6492 | int BytesAvailable; | ||
6493 | if (jiffies != Controller->LastCurrentStatusTime) | 6485 | if (jiffies != Controller->LastCurrentStatusTime) |
6494 | { | 6486 | { |
6495 | Controller->CurrentStatusLength = 0; | 6487 | Controller->CurrentStatusLength = 0; |
@@ -6513,49 +6505,41 @@ static int DAC960_ProcReadCurrentStatus(char *Page, char **Start, off_t Offset, | |||
6513 | } | 6505 | } |
6514 | Controller->LastCurrentStatusTime = jiffies; | 6506 | Controller->LastCurrentStatusTime = jiffies; |
6515 | } | 6507 | } |
6516 | BytesAvailable = Controller->CurrentStatusLength - Offset; | 6508 | seq_printf(m, "%.*s", Controller->CurrentStatusLength, Controller->CurrentStatusBuffer); |
6517 | if (Count >= BytesAvailable) | 6509 | return 0; |
6518 | { | ||
6519 | Count = BytesAvailable; | ||
6520 | *EOF = true; | ||
6521 | } | ||
6522 | if (Count <= 0) return 0; | ||
6523 | *Start = Page; | ||
6524 | memcpy(Page, &Controller->CurrentStatusBuffer[Offset], Count); | ||
6525 | return Count; | ||
6526 | } | 6510 | } |
6527 | 6511 | ||
6512 | static int dac960_current_status_proc_open(struct inode *inode, struct file *file) | ||
6513 | { | ||
6514 | return single_open(file, dac960_current_status_proc_show, PDE(inode)->data); | ||
6515 | } | ||
6528 | 6516 | ||
6529 | /* | 6517 | static const struct file_operations dac960_current_status_proc_fops = { |
6530 | DAC960_ProcReadUserCommand implements reading /proc/rd/cN/user_command. | 6518 | .owner = THIS_MODULE, |
6531 | */ | 6519 | .open = dac960_current_status_proc_open, |
6520 | .read = seq_read, | ||
6521 | .llseek = seq_lseek, | ||
6522 | .release = single_release, | ||
6523 | }; | ||
6532 | 6524 | ||
6533 | static int DAC960_ProcReadUserCommand(char *Page, char **Start, off_t Offset, | 6525 | static int dac960_user_command_proc_show(struct seq_file *m, void *v) |
6534 | int Count, int *EOF, void *Data) | ||
6535 | { | 6526 | { |
6536 | DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data; | 6527 | DAC960_Controller_T *Controller = (DAC960_Controller_T *)m->private; |
6537 | int BytesAvailable = Controller->UserStatusLength - Offset; | ||
6538 | if (Count >= BytesAvailable) | ||
6539 | { | ||
6540 | Count = BytesAvailable; | ||
6541 | *EOF = true; | ||
6542 | } | ||
6543 | if (Count <= 0) return 0; | ||
6544 | *Start = Page; | ||
6545 | memcpy(Page, &Controller->UserStatusBuffer[Offset], Count); | ||
6546 | return Count; | ||
6547 | } | ||
6548 | 6528 | ||
6529 | seq_printf(m, "%.*s", Controller->UserStatusLength, Controller->UserStatusBuffer); | ||
6530 | return 0; | ||
6531 | } | ||
6549 | 6532 | ||
6550 | /* | 6533 | static int dac960_user_command_proc_open(struct inode *inode, struct file *file) |
6551 | DAC960_ProcWriteUserCommand implements writing /proc/rd/cN/user_command. | 6534 | { |
6552 | */ | 6535 | return single_open(file, dac960_user_command_proc_show, PDE(inode)->data); |
6536 | } | ||
6553 | 6537 | ||
6554 | static int DAC960_ProcWriteUserCommand(struct file *file, | 6538 | static ssize_t dac960_user_command_proc_write(struct file *file, |
6555 | const char __user *Buffer, | 6539 | const char __user *Buffer, |
6556 | unsigned long Count, void *Data) | 6540 | size_t Count, loff_t *pos) |
6557 | { | 6541 | { |
6558 | DAC960_Controller_T *Controller = (DAC960_Controller_T *) Data; | 6542 | DAC960_Controller_T *Controller = (DAC960_Controller_T *) PDE(file->f_path.dentry->d_inode)->data; |
6559 | unsigned char CommandBuffer[80]; | 6543 | unsigned char CommandBuffer[80]; |
6560 | int Length; | 6544 | int Length; |
6561 | if (Count > sizeof(CommandBuffer)-1) return -EINVAL; | 6545 | if (Count > sizeof(CommandBuffer)-1) return -EINVAL; |
@@ -6572,6 +6556,14 @@ static int DAC960_ProcWriteUserCommand(struct file *file, | |||
6572 | ? Count : -EBUSY); | 6556 | ? Count : -EBUSY); |
6573 | } | 6557 | } |
6574 | 6558 | ||
6559 | static const struct file_operations dac960_user_command_proc_fops = { | ||
6560 | .owner = THIS_MODULE, | ||
6561 | .open = dac960_user_command_proc_open, | ||
6562 | .read = seq_read, | ||
6563 | .llseek = seq_lseek, | ||
6564 | .release = single_release, | ||
6565 | .write = dac960_user_command_proc_write, | ||
6566 | }; | ||
6575 | 6567 | ||
6576 | /* | 6568 | /* |
6577 | DAC960_CreateProcEntries creates the /proc/rd/... entries for the | 6569 | DAC960_CreateProcEntries creates the /proc/rd/... entries for the |
@@ -6586,23 +6578,17 @@ static void DAC960_CreateProcEntries(DAC960_Controller_T *Controller) | |||
6586 | 6578 | ||
6587 | if (DAC960_ProcDirectoryEntry == NULL) { | 6579 | if (DAC960_ProcDirectoryEntry == NULL) { |
6588 | DAC960_ProcDirectoryEntry = proc_mkdir("rd", NULL); | 6580 | DAC960_ProcDirectoryEntry = proc_mkdir("rd", NULL); |
6589 | StatusProcEntry = create_proc_read_entry("status", 0, | 6581 | StatusProcEntry = proc_create("status", 0, |
6590 | DAC960_ProcDirectoryEntry, | 6582 | DAC960_ProcDirectoryEntry, |
6591 | DAC960_ProcReadStatus, NULL); | 6583 | &dac960_proc_fops); |
6592 | } | 6584 | } |
6593 | 6585 | ||
6594 | sprintf(Controller->ControllerName, "c%d", Controller->ControllerNumber); | 6586 | sprintf(Controller->ControllerName, "c%d", Controller->ControllerNumber); |
6595 | ControllerProcEntry = proc_mkdir(Controller->ControllerName, | 6587 | ControllerProcEntry = proc_mkdir(Controller->ControllerName, |
6596 | DAC960_ProcDirectoryEntry); | 6588 | DAC960_ProcDirectoryEntry); |
6597 | create_proc_read_entry("initial_status", 0, ControllerProcEntry, | 6589 | proc_create_data("initial_status", 0, ControllerProcEntry, &dac960_initial_status_proc_fops, Controller); |
6598 | DAC960_ProcReadInitialStatus, Controller); | 6590 | proc_create_data("current_status", 0, ControllerProcEntry, &dac960_current_status_proc_fops, Controller); |
6599 | create_proc_read_entry("current_status", 0, ControllerProcEntry, | 6591 | UserCommandProcEntry = proc_create_data("user_command", S_IWUSR | S_IRUSR, ControllerProcEntry, &dac960_user_command_proc_fops, Controller); |
6600 | DAC960_ProcReadCurrentStatus, Controller); | ||
6601 | UserCommandProcEntry = | ||
6602 | create_proc_read_entry("user_command", S_IWUSR | S_IRUSR, | ||
6603 | ControllerProcEntry, DAC960_ProcReadUserCommand, | ||
6604 | Controller); | ||
6605 | UserCommandProcEntry->write_proc = DAC960_ProcWriteUserCommand; | ||
6606 | Controller->ControllerProcEntry = ControllerProcEntry; | 6592 | Controller->ControllerProcEntry = ControllerProcEntry; |
6607 | } | 6593 | } |
6608 | 6594 | ||
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c index 24c3e21ab263..fb5be2d95d52 100644 --- a/drivers/block/cciss.c +++ b/drivers/block/cciss.c | |||
@@ -36,9 +36,11 @@ | |||
36 | #include <linux/proc_fs.h> | 36 | #include <linux/proc_fs.h> |
37 | #include <linux/seq_file.h> | 37 | #include <linux/seq_file.h> |
38 | #include <linux/init.h> | 38 | #include <linux/init.h> |
39 | #include <linux/jiffies.h> | ||
39 | #include <linux/hdreg.h> | 40 | #include <linux/hdreg.h> |
40 | #include <linux/spinlock.h> | 41 | #include <linux/spinlock.h> |
41 | #include <linux/compat.h> | 42 | #include <linux/compat.h> |
43 | #include <linux/mutex.h> | ||
42 | #include <asm/uaccess.h> | 44 | #include <asm/uaccess.h> |
43 | #include <asm/io.h> | 45 | #include <asm/io.h> |
44 | 46 | ||
@@ -155,6 +157,10 @@ static struct board_type products[] = { | |||
155 | 157 | ||
156 | static ctlr_info_t *hba[MAX_CTLR]; | 158 | static ctlr_info_t *hba[MAX_CTLR]; |
157 | 159 | ||
160 | static struct task_struct *cciss_scan_thread; | ||
161 | static DEFINE_MUTEX(scan_mutex); | ||
162 | static LIST_HEAD(scan_q); | ||
163 | |||
158 | static void do_cciss_request(struct request_queue *q); | 164 | static void do_cciss_request(struct request_queue *q); |
159 | static irqreturn_t do_cciss_intr(int irq, void *dev_id); | 165 | static irqreturn_t do_cciss_intr(int irq, void *dev_id); |
160 | static int cciss_open(struct block_device *bdev, fmode_t mode); | 166 | static int cciss_open(struct block_device *bdev, fmode_t mode); |
@@ -164,9 +170,9 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode, | |||
164 | static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo); | 170 | static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo); |
165 | 171 | ||
166 | static int cciss_revalidate(struct gendisk *disk); | 172 | static int cciss_revalidate(struct gendisk *disk); |
167 | static int rebuild_lun_table(ctlr_info_t *h, int first_time); | 173 | static int rebuild_lun_table(ctlr_info_t *h, int first_time, int via_ioctl); |
168 | static int deregister_disk(ctlr_info_t *h, int drv_index, | 174 | static int deregister_disk(ctlr_info_t *h, int drv_index, |
169 | int clear_all); | 175 | int clear_all, int via_ioctl); |
170 | 176 | ||
171 | static void cciss_read_capacity(int ctlr, int logvol, int withirq, | 177 | static void cciss_read_capacity(int ctlr, int logvol, int withirq, |
172 | sector_t *total_size, unsigned int *block_size); | 178 | sector_t *total_size, unsigned int *block_size); |
@@ -189,8 +195,13 @@ static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c, | |||
189 | static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c); | 195 | static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c); |
190 | 196 | ||
191 | static void fail_all_cmds(unsigned long ctlr); | 197 | static void fail_all_cmds(unsigned long ctlr); |
198 | static int add_to_scan_list(struct ctlr_info *h); | ||
192 | static int scan_thread(void *data); | 199 | static int scan_thread(void *data); |
193 | static int check_for_unit_attention(ctlr_info_t *h, CommandList_struct *c); | 200 | static int check_for_unit_attention(ctlr_info_t *h, CommandList_struct *c); |
201 | static void cciss_hba_release(struct device *dev); | ||
202 | static void cciss_device_release(struct device *dev); | ||
203 | static void cciss_free_gendisk(ctlr_info_t *h, int drv_index); | ||
204 | static void cciss_free_drive_info(ctlr_info_t *h, int drv_index); | ||
194 | 205 | ||
195 | #ifdef CONFIG_PROC_FS | 206 | #ifdef CONFIG_PROC_FS |
196 | static void cciss_procinit(int i); | 207 | static void cciss_procinit(int i); |
@@ -245,7 +256,10 @@ static inline void removeQ(CommandList_struct *c) | |||
245 | 256 | ||
246 | #include "cciss_scsi.c" /* For SCSI tape support */ | 257 | #include "cciss_scsi.c" /* For SCSI tape support */ |
247 | 258 | ||
248 | #define RAID_UNKNOWN 6 | 259 | static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG", |
260 | "UNKNOWN" | ||
261 | }; | ||
262 | #define RAID_UNKNOWN (sizeof(raid_label) / sizeof(raid_label[0])-1) | ||
249 | 263 | ||
250 | #ifdef CONFIG_PROC_FS | 264 | #ifdef CONFIG_PROC_FS |
251 | 265 | ||
@@ -255,9 +269,6 @@ static inline void removeQ(CommandList_struct *c) | |||
255 | #define ENG_GIG 1000000000 | 269 | #define ENG_GIG 1000000000 |
256 | #define ENG_GIG_FACTOR (ENG_GIG/512) | 270 | #define ENG_GIG_FACTOR (ENG_GIG/512) |
257 | #define ENGAGE_SCSI "engage scsi" | 271 | #define ENGAGE_SCSI "engage scsi" |
258 | static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG", | ||
259 | "UNKNOWN" | ||
260 | }; | ||
261 | 272 | ||
262 | static struct proc_dir_entry *proc_cciss; | 273 | static struct proc_dir_entry *proc_cciss; |
263 | 274 | ||
@@ -318,7 +329,7 @@ static int cciss_seq_show(struct seq_file *seq, void *v) | |||
318 | ctlr_info_t *h = seq->private; | 329 | ctlr_info_t *h = seq->private; |
319 | unsigned ctlr = h->ctlr; | 330 | unsigned ctlr = h->ctlr; |
320 | loff_t *pos = v; | 331 | loff_t *pos = v; |
321 | drive_info_struct *drv = &h->drv[*pos]; | 332 | drive_info_struct *drv = h->drv[*pos]; |
322 | 333 | ||
323 | if (*pos > h->highest_lun) | 334 | if (*pos > h->highest_lun) |
324 | return 0; | 335 | return 0; |
@@ -331,7 +342,7 @@ static int cciss_seq_show(struct seq_file *seq, void *v) | |||
331 | vol_sz_frac *= 100; | 342 | vol_sz_frac *= 100; |
332 | sector_div(vol_sz_frac, ENG_GIG_FACTOR); | 343 | sector_div(vol_sz_frac, ENG_GIG_FACTOR); |
333 | 344 | ||
334 | if (drv->raid_level > 5) | 345 | if (drv->raid_level < 0 || drv->raid_level > RAID_UNKNOWN) |
335 | drv->raid_level = RAID_UNKNOWN; | 346 | drv->raid_level = RAID_UNKNOWN; |
336 | seq_printf(seq, "cciss/c%dd%d:" | 347 | seq_printf(seq, "cciss/c%dd%d:" |
337 | "\t%4u.%02uGB\tRAID %s\n", | 348 | "\t%4u.%02uGB\tRAID %s\n", |
@@ -426,7 +437,7 @@ out: | |||
426 | return err; | 437 | return err; |
427 | } | 438 | } |
428 | 439 | ||
429 | static struct file_operations cciss_proc_fops = { | 440 | static const struct file_operations cciss_proc_fops = { |
430 | .owner = THIS_MODULE, | 441 | .owner = THIS_MODULE, |
431 | .open = cciss_seq_open, | 442 | .open = cciss_seq_open, |
432 | .read = seq_read, | 443 | .read = seq_read, |
@@ -454,9 +465,19 @@ static void __devinit cciss_procinit(int i) | |||
454 | #define to_hba(n) container_of(n, struct ctlr_info, dev) | 465 | #define to_hba(n) container_of(n, struct ctlr_info, dev) |
455 | #define to_drv(n) container_of(n, drive_info_struct, dev) | 466 | #define to_drv(n) container_of(n, drive_info_struct, dev) |
456 | 467 | ||
457 | static struct device_type cciss_host_type = { | 468 | static ssize_t host_store_rescan(struct device *dev, |
458 | .name = "cciss_host", | 469 | struct device_attribute *attr, |
459 | }; | 470 | const char *buf, size_t count) |
471 | { | ||
472 | struct ctlr_info *h = to_hba(dev); | ||
473 | |||
474 | add_to_scan_list(h); | ||
475 | wake_up_process(cciss_scan_thread); | ||
476 | wait_for_completion_interruptible(&h->scan_wait); | ||
477 | |||
478 | return count; | ||
479 | } | ||
480 | DEVICE_ATTR(rescan, S_IWUSR, NULL, host_store_rescan); | ||
460 | 481 | ||
461 | static ssize_t dev_show_unique_id(struct device *dev, | 482 | static ssize_t dev_show_unique_id(struct device *dev, |
462 | struct device_attribute *attr, | 483 | struct device_attribute *attr, |
@@ -560,11 +581,101 @@ static ssize_t dev_show_rev(struct device *dev, | |||
560 | } | 581 | } |
561 | DEVICE_ATTR(rev, S_IRUGO, dev_show_rev, NULL); | 582 | DEVICE_ATTR(rev, S_IRUGO, dev_show_rev, NULL); |
562 | 583 | ||
584 | static ssize_t cciss_show_lunid(struct device *dev, | ||
585 | struct device_attribute *attr, char *buf) | ||
586 | { | ||
587 | drive_info_struct *drv = to_drv(dev); | ||
588 | struct ctlr_info *h = to_hba(drv->dev.parent); | ||
589 | unsigned long flags; | ||
590 | unsigned char lunid[8]; | ||
591 | |||
592 | spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); | ||
593 | if (h->busy_configuring) { | ||
594 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | ||
595 | return -EBUSY; | ||
596 | } | ||
597 | if (!drv->heads) { | ||
598 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | ||
599 | return -ENOTTY; | ||
600 | } | ||
601 | memcpy(lunid, drv->LunID, sizeof(lunid)); | ||
602 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | ||
603 | return snprintf(buf, 20, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", | ||
604 | lunid[0], lunid[1], lunid[2], lunid[3], | ||
605 | lunid[4], lunid[5], lunid[6], lunid[7]); | ||
606 | } | ||
607 | DEVICE_ATTR(lunid, S_IRUGO, cciss_show_lunid, NULL); | ||
608 | |||
609 | static ssize_t cciss_show_raid_level(struct device *dev, | ||
610 | struct device_attribute *attr, char *buf) | ||
611 | { | ||
612 | drive_info_struct *drv = to_drv(dev); | ||
613 | struct ctlr_info *h = to_hba(drv->dev.parent); | ||
614 | int raid; | ||
615 | unsigned long flags; | ||
616 | |||
617 | spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); | ||
618 | if (h->busy_configuring) { | ||
619 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | ||
620 | return -EBUSY; | ||
621 | } | ||
622 | raid = drv->raid_level; | ||
623 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | ||
624 | if (raid < 0 || raid > RAID_UNKNOWN) | ||
625 | raid = RAID_UNKNOWN; | ||
626 | |||
627 | return snprintf(buf, strlen(raid_label[raid]) + 7, "RAID %s\n", | ||
628 | raid_label[raid]); | ||
629 | } | ||
630 | DEVICE_ATTR(raid_level, S_IRUGO, cciss_show_raid_level, NULL); | ||
631 | |||
632 | static ssize_t cciss_show_usage_count(struct device *dev, | ||
633 | struct device_attribute *attr, char *buf) | ||
634 | { | ||
635 | drive_info_struct *drv = to_drv(dev); | ||
636 | struct ctlr_info *h = to_hba(drv->dev.parent); | ||
637 | unsigned long flags; | ||
638 | int count; | ||
639 | |||
640 | spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); | ||
641 | if (h->busy_configuring) { | ||
642 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | ||
643 | return -EBUSY; | ||
644 | } | ||
645 | count = drv->usage_count; | ||
646 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | ||
647 | return snprintf(buf, 20, "%d\n", count); | ||
648 | } | ||
649 | DEVICE_ATTR(usage_count, S_IRUGO, cciss_show_usage_count, NULL); | ||
650 | |||
651 | static struct attribute *cciss_host_attrs[] = { | ||
652 | &dev_attr_rescan.attr, | ||
653 | NULL | ||
654 | }; | ||
655 | |||
656 | static struct attribute_group cciss_host_attr_group = { | ||
657 | .attrs = cciss_host_attrs, | ||
658 | }; | ||
659 | |||
660 | static const struct attribute_group *cciss_host_attr_groups[] = { | ||
661 | &cciss_host_attr_group, | ||
662 | NULL | ||
663 | }; | ||
664 | |||
665 | static struct device_type cciss_host_type = { | ||
666 | .name = "cciss_host", | ||
667 | .groups = cciss_host_attr_groups, | ||
668 | .release = cciss_hba_release, | ||
669 | }; | ||
670 | |||
563 | static struct attribute *cciss_dev_attrs[] = { | 671 | static struct attribute *cciss_dev_attrs[] = { |
564 | &dev_attr_unique_id.attr, | 672 | &dev_attr_unique_id.attr, |
565 | &dev_attr_model.attr, | 673 | &dev_attr_model.attr, |
566 | &dev_attr_vendor.attr, | 674 | &dev_attr_vendor.attr, |
567 | &dev_attr_rev.attr, | 675 | &dev_attr_rev.attr, |
676 | &dev_attr_lunid.attr, | ||
677 | &dev_attr_raid_level.attr, | ||
678 | &dev_attr_usage_count.attr, | ||
568 | NULL | 679 | NULL |
569 | }; | 680 | }; |
570 | 681 | ||
@@ -580,12 +691,24 @@ static const struct attribute_group *cciss_dev_attr_groups[] = { | |||
580 | static struct device_type cciss_dev_type = { | 691 | static struct device_type cciss_dev_type = { |
581 | .name = "cciss_device", | 692 | .name = "cciss_device", |
582 | .groups = cciss_dev_attr_groups, | 693 | .groups = cciss_dev_attr_groups, |
694 | .release = cciss_device_release, | ||
583 | }; | 695 | }; |
584 | 696 | ||
585 | static struct bus_type cciss_bus_type = { | 697 | static struct bus_type cciss_bus_type = { |
586 | .name = "cciss", | 698 | .name = "cciss", |
587 | }; | 699 | }; |
588 | 700 | ||
701 | /* | ||
702 | * cciss_hba_release is called when the reference count | ||
703 | * of h->dev goes to zero. | ||
704 | */ | ||
705 | static void cciss_hba_release(struct device *dev) | ||
706 | { | ||
707 | /* | ||
708 | * nothing to do, but need this to avoid a warning | ||
709 | * about not having a release handler from lib/kref.c. | ||
710 | */ | ||
711 | } | ||
589 | 712 | ||
590 | /* | 713 | /* |
591 | * Initialize sysfs entry for each controller. This sets up and registers | 714 | * Initialize sysfs entry for each controller. This sets up and registers |
@@ -609,6 +732,16 @@ static int cciss_create_hba_sysfs_entry(struct ctlr_info *h) | |||
609 | static void cciss_destroy_hba_sysfs_entry(struct ctlr_info *h) | 732 | static void cciss_destroy_hba_sysfs_entry(struct ctlr_info *h) |
610 | { | 733 | { |
611 | device_del(&h->dev); | 734 | device_del(&h->dev); |
735 | put_device(&h->dev); /* final put. */ | ||
736 | } | ||
737 | |||
738 | /* cciss_device_release is called when the reference count | ||
739 | * of h->drv[x]dev goes to zero. | ||
740 | */ | ||
741 | static void cciss_device_release(struct device *dev) | ||
742 | { | ||
743 | drive_info_struct *drv = to_drv(dev); | ||
744 | kfree(drv); | ||
612 | } | 745 | } |
613 | 746 | ||
614 | /* | 747 | /* |
@@ -617,24 +750,39 @@ static void cciss_destroy_hba_sysfs_entry(struct ctlr_info *h) | |||
617 | * /sys/bus/pci/devices/<dev/ccis#/. We also create a link from | 750 | * /sys/bus/pci/devices/<dev/ccis#/. We also create a link from |
618 | * /sys/block/cciss!c#d# to this entry. | 751 | * /sys/block/cciss!c#d# to this entry. |
619 | */ | 752 | */ |
620 | static int cciss_create_ld_sysfs_entry(struct ctlr_info *h, | 753 | static long cciss_create_ld_sysfs_entry(struct ctlr_info *h, |
621 | drive_info_struct *drv, | ||
622 | int drv_index) | 754 | int drv_index) |
623 | { | 755 | { |
624 | device_initialize(&drv->dev); | 756 | struct device *dev; |
625 | drv->dev.type = &cciss_dev_type; | 757 | |
626 | drv->dev.bus = &cciss_bus_type; | 758 | if (h->drv[drv_index]->device_initialized) |
627 | dev_set_name(&drv->dev, "c%dd%d", h->ctlr, drv_index); | 759 | return 0; |
628 | drv->dev.parent = &h->dev; | 760 | |
629 | return device_add(&drv->dev); | 761 | dev = &h->drv[drv_index]->dev; |
762 | device_initialize(dev); | ||
763 | dev->type = &cciss_dev_type; | ||
764 | dev->bus = &cciss_bus_type; | ||
765 | dev_set_name(dev, "c%dd%d", h->ctlr, drv_index); | ||
766 | dev->parent = &h->dev; | ||
767 | h->drv[drv_index]->device_initialized = 1; | ||
768 | return device_add(dev); | ||
630 | } | 769 | } |
631 | 770 | ||
632 | /* | 771 | /* |
633 | * Remove sysfs entries for a logical drive. | 772 | * Remove sysfs entries for a logical drive. |
634 | */ | 773 | */ |
635 | static void cciss_destroy_ld_sysfs_entry(drive_info_struct *drv) | 774 | static void cciss_destroy_ld_sysfs_entry(struct ctlr_info *h, int drv_index, |
775 | int ctlr_exiting) | ||
636 | { | 776 | { |
637 | device_del(&drv->dev); | 777 | struct device *dev = &h->drv[drv_index]->dev; |
778 | |||
779 | /* special case for c*d0, we only destroy it on controller exit */ | ||
780 | if (drv_index == 0 && !ctlr_exiting) | ||
781 | return; | ||
782 | |||
783 | device_del(dev); | ||
784 | put_device(dev); /* the "final" put. */ | ||
785 | h->drv[drv_index] = NULL; | ||
638 | } | 786 | } |
639 | 787 | ||
640 | /* | 788 | /* |
@@ -751,7 +899,7 @@ static int cciss_open(struct block_device *bdev, fmode_t mode) | |||
751 | printk(KERN_DEBUG "cciss_open %s\n", bdev->bd_disk->disk_name); | 899 | printk(KERN_DEBUG "cciss_open %s\n", bdev->bd_disk->disk_name); |
752 | #endif /* CCISS_DEBUG */ | 900 | #endif /* CCISS_DEBUG */ |
753 | 901 | ||
754 | if (host->busy_initializing || drv->busy_configuring) | 902 | if (drv->busy_configuring) |
755 | return -EBUSY; | 903 | return -EBUSY; |
756 | /* | 904 | /* |
757 | * Root is allowed to open raw volume zero even if it's not configured | 905 | * Root is allowed to open raw volume zero even if it's not configured |
@@ -767,7 +915,8 @@ static int cciss_open(struct block_device *bdev, fmode_t mode) | |||
767 | if (MINOR(bdev->bd_dev) & 0x0f) { | 915 | if (MINOR(bdev->bd_dev) & 0x0f) { |
768 | return -ENXIO; | 916 | return -ENXIO; |
769 | /* if it is, make sure we have a LUN ID */ | 917 | /* if it is, make sure we have a LUN ID */ |
770 | } else if (drv->LunID == 0) { | 918 | } else if (memcmp(drv->LunID, CTLR_LUNID, |
919 | sizeof(drv->LunID))) { | ||
771 | return -ENXIO; | 920 | return -ENXIO; |
772 | } | 921 | } |
773 | } | 922 | } |
@@ -1132,12 +1281,13 @@ static int cciss_ioctl(struct block_device *bdev, fmode_t mode, | |||
1132 | case CCISS_DEREGDISK: | 1281 | case CCISS_DEREGDISK: |
1133 | case CCISS_REGNEWD: | 1282 | case CCISS_REGNEWD: |
1134 | case CCISS_REVALIDVOLS: | 1283 | case CCISS_REVALIDVOLS: |
1135 | return rebuild_lun_table(host, 0); | 1284 | return rebuild_lun_table(host, 0, 1); |
1136 | 1285 | ||
1137 | case CCISS_GETLUNINFO:{ | 1286 | case CCISS_GETLUNINFO:{ |
1138 | LogvolInfo_struct luninfo; | 1287 | LogvolInfo_struct luninfo; |
1139 | 1288 | ||
1140 | luninfo.LunID = drv->LunID; | 1289 | memcpy(&luninfo.LunID, drv->LunID, |
1290 | sizeof(luninfo.LunID)); | ||
1141 | luninfo.num_opens = drv->usage_count; | 1291 | luninfo.num_opens = drv->usage_count; |
1142 | luninfo.num_parts = 0; | 1292 | luninfo.num_parts = 0; |
1143 | if (copy_to_user(argp, &luninfo, | 1293 | if (copy_to_user(argp, &luninfo, |
@@ -1475,7 +1625,10 @@ static void cciss_check_queues(ctlr_info_t *h) | |||
1475 | /* make sure the disk has been added and the drive is real | 1625 | /* make sure the disk has been added and the drive is real |
1476 | * because this can be called from the middle of init_one. | 1626 | * because this can be called from the middle of init_one. |
1477 | */ | 1627 | */ |
1478 | if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads)) | 1628 | if (!h->drv[curr_queue]) |
1629 | continue; | ||
1630 | if (!(h->drv[curr_queue]->queue) || | ||
1631 | !(h->drv[curr_queue]->heads)) | ||
1479 | continue; | 1632 | continue; |
1480 | blk_start_queue(h->gendisk[curr_queue]->queue); | 1633 | blk_start_queue(h->gendisk[curr_queue]->queue); |
1481 | 1634 | ||
@@ -1532,13 +1685,11 @@ static void cciss_softirq_done(struct request *rq) | |||
1532 | spin_unlock_irqrestore(&h->lock, flags); | 1685 | spin_unlock_irqrestore(&h->lock, flags); |
1533 | } | 1686 | } |
1534 | 1687 | ||
1535 | static void log_unit_to_scsi3addr(ctlr_info_t *h, unsigned char scsi3addr[], | 1688 | static inline void log_unit_to_scsi3addr(ctlr_info_t *h, |
1536 | uint32_t log_unit) | 1689 | unsigned char scsi3addr[], uint32_t log_unit) |
1537 | { | 1690 | { |
1538 | log_unit = h->drv[log_unit].LunID & 0x03fff; | 1691 | memcpy(scsi3addr, h->drv[log_unit]->LunID, |
1539 | memset(&scsi3addr[4], 0, 4); | 1692 | sizeof(h->drv[log_unit]->LunID)); |
1540 | memcpy(&scsi3addr[0], &log_unit, 4); | ||
1541 | scsi3addr[3] |= 0x40; | ||
1542 | } | 1693 | } |
1543 | 1694 | ||
1544 | /* This function gets the SCSI vendor, model, and revision of a logical drive | 1695 | /* This function gets the SCSI vendor, model, and revision of a logical drive |
@@ -1615,16 +1766,23 @@ static void cciss_get_serial_no(int ctlr, int logvol, int withirq, | |||
1615 | return; | 1766 | return; |
1616 | } | 1767 | } |
1617 | 1768 | ||
1618 | static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk, | 1769 | /* |
1770 | * cciss_add_disk sets up the block device queue for a logical drive | ||
1771 | */ | ||
1772 | static int cciss_add_disk(ctlr_info_t *h, struct gendisk *disk, | ||
1619 | int drv_index) | 1773 | int drv_index) |
1620 | { | 1774 | { |
1621 | disk->queue = blk_init_queue(do_cciss_request, &h->lock); | 1775 | disk->queue = blk_init_queue(do_cciss_request, &h->lock); |
1776 | if (!disk->queue) | ||
1777 | goto init_queue_failure; | ||
1622 | sprintf(disk->disk_name, "cciss/c%dd%d", h->ctlr, drv_index); | 1778 | sprintf(disk->disk_name, "cciss/c%dd%d", h->ctlr, drv_index); |
1623 | disk->major = h->major; | 1779 | disk->major = h->major; |
1624 | disk->first_minor = drv_index << NWD_SHIFT; | 1780 | disk->first_minor = drv_index << NWD_SHIFT; |
1625 | disk->fops = &cciss_fops; | 1781 | disk->fops = &cciss_fops; |
1626 | disk->private_data = &h->drv[drv_index]; | 1782 | if (cciss_create_ld_sysfs_entry(h, drv_index)) |
1627 | disk->driverfs_dev = &h->drv[drv_index].dev; | 1783 | goto cleanup_queue; |
1784 | disk->private_data = h->drv[drv_index]; | ||
1785 | disk->driverfs_dev = &h->drv[drv_index]->dev; | ||
1628 | 1786 | ||
1629 | /* Set up queue information */ | 1787 | /* Set up queue information */ |
1630 | blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask); | 1788 | blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask); |
@@ -1642,14 +1800,21 @@ static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk, | |||
1642 | disk->queue->queuedata = h; | 1800 | disk->queue->queuedata = h; |
1643 | 1801 | ||
1644 | blk_queue_logical_block_size(disk->queue, | 1802 | blk_queue_logical_block_size(disk->queue, |
1645 | h->drv[drv_index].block_size); | 1803 | h->drv[drv_index]->block_size); |
1646 | 1804 | ||
1647 | /* Make sure all queue data is written out before */ | 1805 | /* Make sure all queue data is written out before */ |
1648 | /* setting h->drv[drv_index].queue, as setting this */ | 1806 | /* setting h->drv[drv_index]->queue, as setting this */ |
1649 | /* allows the interrupt handler to start the queue */ | 1807 | /* allows the interrupt handler to start the queue */ |
1650 | wmb(); | 1808 | wmb(); |
1651 | h->drv[drv_index].queue = disk->queue; | 1809 | h->drv[drv_index]->queue = disk->queue; |
1652 | add_disk(disk); | 1810 | add_disk(disk); |
1811 | return 0; | ||
1812 | |||
1813 | cleanup_queue: | ||
1814 | blk_cleanup_queue(disk->queue); | ||
1815 | disk->queue = NULL; | ||
1816 | init_queue_failure: | ||
1817 | return -1; | ||
1653 | } | 1818 | } |
1654 | 1819 | ||
1655 | /* This function will check the usage_count of the drive to be updated/added. | 1820 | /* This function will check the usage_count of the drive to be updated/added. |
@@ -1662,7 +1827,8 @@ static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk, | |||
1662 | * is also the controller node. Any changes to disk 0 will show up on | 1827 | * is also the controller node. Any changes to disk 0 will show up on |
1663 | * the next reboot. | 1828 | * the next reboot. |
1664 | */ | 1829 | */ |
1665 | static void cciss_update_drive_info(int ctlr, int drv_index, int first_time) | 1830 | static void cciss_update_drive_info(int ctlr, int drv_index, int first_time, |
1831 | int via_ioctl) | ||
1666 | { | 1832 | { |
1667 | ctlr_info_t *h = hba[ctlr]; | 1833 | ctlr_info_t *h = hba[ctlr]; |
1668 | struct gendisk *disk; | 1834 | struct gendisk *disk; |
@@ -1672,21 +1838,13 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time) | |||
1672 | unsigned long flags = 0; | 1838 | unsigned long flags = 0; |
1673 | int ret = 0; | 1839 | int ret = 0; |
1674 | drive_info_struct *drvinfo; | 1840 | drive_info_struct *drvinfo; |
1675 | int was_only_controller_node; | ||
1676 | 1841 | ||
1677 | /* Get information about the disk and modify the driver structure */ | 1842 | /* Get information about the disk and modify the driver structure */ |
1678 | inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); | 1843 | inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL); |
1679 | drvinfo = kmalloc(sizeof(*drvinfo), GFP_KERNEL); | 1844 | drvinfo = kzalloc(sizeof(*drvinfo), GFP_KERNEL); |
1680 | if (inq_buff == NULL || drvinfo == NULL) | 1845 | if (inq_buff == NULL || drvinfo == NULL) |
1681 | goto mem_msg; | 1846 | goto mem_msg; |
1682 | 1847 | ||
1683 | /* See if we're trying to update the "controller node" | ||
1684 | * this will happen the when the first logical drive gets | ||
1685 | * created by ACU. | ||
1686 | */ | ||
1687 | was_only_controller_node = (drv_index == 0 && | ||
1688 | h->drv[0].raid_level == -1); | ||
1689 | |||
1690 | /* testing to see if 16-byte CDBs are already being used */ | 1848 | /* testing to see if 16-byte CDBs are already being used */ |
1691 | if (h->cciss_read == CCISS_READ_16) { | 1849 | if (h->cciss_read == CCISS_READ_16) { |
1692 | cciss_read_capacity_16(h->ctlr, drv_index, 1, | 1850 | cciss_read_capacity_16(h->ctlr, drv_index, 1, |
@@ -1719,16 +1877,19 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time) | |||
1719 | drvinfo->model, drvinfo->rev); | 1877 | drvinfo->model, drvinfo->rev); |
1720 | cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no, | 1878 | cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no, |
1721 | sizeof(drvinfo->serial_no)); | 1879 | sizeof(drvinfo->serial_no)); |
1880 | /* Save the lunid in case we deregister the disk, below. */ | ||
1881 | memcpy(drvinfo->LunID, h->drv[drv_index]->LunID, | ||
1882 | sizeof(drvinfo->LunID)); | ||
1722 | 1883 | ||
1723 | /* Is it the same disk we already know, and nothing's changed? */ | 1884 | /* Is it the same disk we already know, and nothing's changed? */ |
1724 | if (h->drv[drv_index].raid_level != -1 && | 1885 | if (h->drv[drv_index]->raid_level != -1 && |
1725 | ((memcmp(drvinfo->serial_no, | 1886 | ((memcmp(drvinfo->serial_no, |
1726 | h->drv[drv_index].serial_no, 16) == 0) && | 1887 | h->drv[drv_index]->serial_no, 16) == 0) && |
1727 | drvinfo->block_size == h->drv[drv_index].block_size && | 1888 | drvinfo->block_size == h->drv[drv_index]->block_size && |
1728 | drvinfo->nr_blocks == h->drv[drv_index].nr_blocks && | 1889 | drvinfo->nr_blocks == h->drv[drv_index]->nr_blocks && |
1729 | drvinfo->heads == h->drv[drv_index].heads && | 1890 | drvinfo->heads == h->drv[drv_index]->heads && |
1730 | drvinfo->sectors == h->drv[drv_index].sectors && | 1891 | drvinfo->sectors == h->drv[drv_index]->sectors && |
1731 | drvinfo->cylinders == h->drv[drv_index].cylinders)) | 1892 | drvinfo->cylinders == h->drv[drv_index]->cylinders)) |
1732 | /* The disk is unchanged, nothing to update */ | 1893 | /* The disk is unchanged, nothing to update */ |
1733 | goto freeret; | 1894 | goto freeret; |
1734 | 1895 | ||
@@ -1738,18 +1899,17 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time) | |||
1738 | * If the disk already exists then deregister it before proceeding | 1899 | * If the disk already exists then deregister it before proceeding |
1739 | * (unless it's the first disk (for the controller node). | 1900 | * (unless it's the first disk (for the controller node). |
1740 | */ | 1901 | */ |
1741 | if (h->drv[drv_index].raid_level != -1 && drv_index != 0) { | 1902 | if (h->drv[drv_index]->raid_level != -1 && drv_index != 0) { |
1742 | printk(KERN_WARNING "disk %d has changed.\n", drv_index); | 1903 | printk(KERN_WARNING "disk %d has changed.\n", drv_index); |
1743 | spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); | 1904 | spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); |
1744 | h->drv[drv_index].busy_configuring = 1; | 1905 | h->drv[drv_index]->busy_configuring = 1; |
1745 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | 1906 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
1746 | 1907 | ||
1747 | /* deregister_disk sets h->drv[drv_index].queue = NULL | 1908 | /* deregister_disk sets h->drv[drv_index]->queue = NULL |
1748 | * which keeps the interrupt handler from starting | 1909 | * which keeps the interrupt handler from starting |
1749 | * the queue. | 1910 | * the queue. |
1750 | */ | 1911 | */ |
1751 | ret = deregister_disk(h, drv_index, 0); | 1912 | ret = deregister_disk(h, drv_index, 0, via_ioctl); |
1752 | h->drv[drv_index].busy_configuring = 0; | ||
1753 | } | 1913 | } |
1754 | 1914 | ||
1755 | /* If the disk is in use return */ | 1915 | /* If the disk is in use return */ |
@@ -1757,22 +1917,31 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time) | |||
1757 | goto freeret; | 1917 | goto freeret; |
1758 | 1918 | ||
1759 | /* Save the new information from cciss_geometry_inquiry | 1919 | /* Save the new information from cciss_geometry_inquiry |
1760 | * and serial number inquiry. | 1920 | * and serial number inquiry. If the disk was deregistered |
1921 | * above, then h->drv[drv_index] will be NULL. | ||
1761 | */ | 1922 | */ |
1762 | h->drv[drv_index].block_size = drvinfo->block_size; | 1923 | if (h->drv[drv_index] == NULL) { |
1763 | h->drv[drv_index].nr_blocks = drvinfo->nr_blocks; | 1924 | drvinfo->device_initialized = 0; |
1764 | h->drv[drv_index].heads = drvinfo->heads; | 1925 | h->drv[drv_index] = drvinfo; |
1765 | h->drv[drv_index].sectors = drvinfo->sectors; | 1926 | drvinfo = NULL; /* so it won't be freed below. */ |
1766 | h->drv[drv_index].cylinders = drvinfo->cylinders; | 1927 | } else { |
1767 | h->drv[drv_index].raid_level = drvinfo->raid_level; | 1928 | /* special case for cxd0 */ |
1768 | memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16); | 1929 | h->drv[drv_index]->block_size = drvinfo->block_size; |
1769 | memcpy(h->drv[drv_index].vendor, drvinfo->vendor, VENDOR_LEN + 1); | 1930 | h->drv[drv_index]->nr_blocks = drvinfo->nr_blocks; |
1770 | memcpy(h->drv[drv_index].model, drvinfo->model, MODEL_LEN + 1); | 1931 | h->drv[drv_index]->heads = drvinfo->heads; |
1771 | memcpy(h->drv[drv_index].rev, drvinfo->rev, REV_LEN + 1); | 1932 | h->drv[drv_index]->sectors = drvinfo->sectors; |
1933 | h->drv[drv_index]->cylinders = drvinfo->cylinders; | ||
1934 | h->drv[drv_index]->raid_level = drvinfo->raid_level; | ||
1935 | memcpy(h->drv[drv_index]->serial_no, drvinfo->serial_no, 16); | ||
1936 | memcpy(h->drv[drv_index]->vendor, drvinfo->vendor, | ||
1937 | VENDOR_LEN + 1); | ||
1938 | memcpy(h->drv[drv_index]->model, drvinfo->model, MODEL_LEN + 1); | ||
1939 | memcpy(h->drv[drv_index]->rev, drvinfo->rev, REV_LEN + 1); | ||
1940 | } | ||
1772 | 1941 | ||
1773 | ++h->num_luns; | 1942 | ++h->num_luns; |
1774 | disk = h->gendisk[drv_index]; | 1943 | disk = h->gendisk[drv_index]; |
1775 | set_capacity(disk, h->drv[drv_index].nr_blocks); | 1944 | set_capacity(disk, h->drv[drv_index]->nr_blocks); |
1776 | 1945 | ||
1777 | /* If it's not disk 0 (drv_index != 0) | 1946 | /* If it's not disk 0 (drv_index != 0) |
1778 | * or if it was disk 0, but there was previously | 1947 | * or if it was disk 0, but there was previously |
@@ -1780,8 +1949,15 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time) | |||
1780 | * (raid_leve == -1) then we want to update the | 1949 | * (raid_leve == -1) then we want to update the |
1781 | * logical drive's information. | 1950 | * logical drive's information. |
1782 | */ | 1951 | */ |
1783 | if (drv_index || first_time) | 1952 | if (drv_index || first_time) { |
1784 | cciss_add_disk(h, disk, drv_index); | 1953 | if (cciss_add_disk(h, disk, drv_index) != 0) { |
1954 | cciss_free_gendisk(h, drv_index); | ||
1955 | cciss_free_drive_info(h, drv_index); | ||
1956 | printk(KERN_WARNING "cciss:%d could not update " | ||
1957 | "disk %d\n", h->ctlr, drv_index); | ||
1958 | --h->num_luns; | ||
1959 | } | ||
1960 | } | ||
1785 | 1961 | ||
1786 | freeret: | 1962 | freeret: |
1787 | kfree(inq_buff); | 1963 | kfree(inq_buff); |
@@ -1793,28 +1969,70 @@ mem_msg: | |||
1793 | } | 1969 | } |
1794 | 1970 | ||
1795 | /* This function will find the first index of the controllers drive array | 1971 | /* This function will find the first index of the controllers drive array |
1796 | * that has a -1 for the raid_level and will return that index. This is | 1972 | * that has a null drv pointer and allocate the drive info struct and |
1797 | * where new drives will be added. If the index to be returned is greater | 1973 | * will return that index This is where new drives will be added. |
1798 | * than the highest_lun index for the controller then highest_lun is set | 1974 | * If the index to be returned is greater than the highest_lun index for |
1799 | * to this new index. If there are no available indexes then -1 is returned. | 1975 | * the controller then highest_lun is set * to this new index. |
1800 | * "controller_node" is used to know if this is a real logical drive, or just | 1976 | * If there are no available indexes or if tha allocation fails, then -1 |
1801 | * the controller node, which determines if this counts towards highest_lun. | 1977 | * is returned. * "controller_node" is used to know if this is a real |
1978 | * logical drive, or just the controller node, which determines if this | ||
1979 | * counts towards highest_lun. | ||
1802 | */ | 1980 | */ |
1803 | static int cciss_find_free_drive_index(int ctlr, int controller_node) | 1981 | static int cciss_alloc_drive_info(ctlr_info_t *h, int controller_node) |
1804 | { | 1982 | { |
1805 | int i; | 1983 | int i; |
1984 | drive_info_struct *drv; | ||
1806 | 1985 | ||
1986 | /* Search for an empty slot for our drive info */ | ||
1807 | for (i = 0; i < CISS_MAX_LUN; i++) { | 1987 | for (i = 0; i < CISS_MAX_LUN; i++) { |
1808 | if (hba[ctlr]->drv[i].raid_level == -1) { | 1988 | |
1809 | if (i > hba[ctlr]->highest_lun) | 1989 | /* if not cxd0 case, and it's occupied, skip it. */ |
1810 | if (!controller_node) | 1990 | if (h->drv[i] && i != 0) |
1811 | hba[ctlr]->highest_lun = i; | 1991 | continue; |
1992 | /* | ||
1993 | * If it's cxd0 case, and drv is alloc'ed already, and a | ||
1994 | * disk is configured there, skip it. | ||
1995 | */ | ||
1996 | if (i == 0 && h->drv[i] && h->drv[i]->raid_level != -1) | ||
1997 | continue; | ||
1998 | |||
1999 | /* | ||
2000 | * We've found an empty slot. Update highest_lun | ||
2001 | * provided this isn't just the fake cxd0 controller node. | ||
2002 | */ | ||
2003 | if (i > h->highest_lun && !controller_node) | ||
2004 | h->highest_lun = i; | ||
2005 | |||
2006 | /* If adding a real disk at cxd0, and it's already alloc'ed */ | ||
2007 | if (i == 0 && h->drv[i] != NULL) | ||
1812 | return i; | 2008 | return i; |
1813 | } | 2009 | |
2010 | /* | ||
2011 | * Found an empty slot, not already alloc'ed. Allocate it. | ||
2012 | * Mark it with raid_level == -1, so we know it's new later on. | ||
2013 | */ | ||
2014 | drv = kzalloc(sizeof(*drv), GFP_KERNEL); | ||
2015 | if (!drv) | ||
2016 | return -1; | ||
2017 | drv->raid_level = -1; /* so we know it's new */ | ||
2018 | h->drv[i] = drv; | ||
2019 | return i; | ||
1814 | } | 2020 | } |
1815 | return -1; | 2021 | return -1; |
1816 | } | 2022 | } |
1817 | 2023 | ||
2024 | static void cciss_free_drive_info(ctlr_info_t *h, int drv_index) | ||
2025 | { | ||
2026 | kfree(h->drv[drv_index]); | ||
2027 | h->drv[drv_index] = NULL; | ||
2028 | } | ||
2029 | |||
2030 | static void cciss_free_gendisk(ctlr_info_t *h, int drv_index) | ||
2031 | { | ||
2032 | put_disk(h->gendisk[drv_index]); | ||
2033 | h->gendisk[drv_index] = NULL; | ||
2034 | } | ||
2035 | |||
1818 | /* cciss_add_gendisk finds a free hba[]->drv structure | 2036 | /* cciss_add_gendisk finds a free hba[]->drv structure |
1819 | * and allocates a gendisk if needed, and sets the lunid | 2037 | * and allocates a gendisk if needed, and sets the lunid |
1820 | * in the drvinfo structure. It returns the index into | 2038 | * in the drvinfo structure. It returns the index into |
@@ -1824,13 +2042,15 @@ static int cciss_find_free_drive_index(int ctlr, int controller_node) | |||
1824 | * a means to talk to the controller in case no logical | 2042 | * a means to talk to the controller in case no logical |
1825 | * drives have yet been configured. | 2043 | * drives have yet been configured. |
1826 | */ | 2044 | */ |
1827 | static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node) | 2045 | static int cciss_add_gendisk(ctlr_info_t *h, unsigned char lunid[], |
2046 | int controller_node) | ||
1828 | { | 2047 | { |
1829 | int drv_index; | 2048 | int drv_index; |
1830 | 2049 | ||
1831 | drv_index = cciss_find_free_drive_index(h->ctlr, controller_node); | 2050 | drv_index = cciss_alloc_drive_info(h, controller_node); |
1832 | if (drv_index == -1) | 2051 | if (drv_index == -1) |
1833 | return -1; | 2052 | return -1; |
2053 | |||
1834 | /*Check if the gendisk needs to be allocated */ | 2054 | /*Check if the gendisk needs to be allocated */ |
1835 | if (!h->gendisk[drv_index]) { | 2055 | if (!h->gendisk[drv_index]) { |
1836 | h->gendisk[drv_index] = | 2056 | h->gendisk[drv_index] = |
@@ -1839,23 +2059,24 @@ static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node) | |||
1839 | printk(KERN_ERR "cciss%d: could not " | 2059 | printk(KERN_ERR "cciss%d: could not " |
1840 | "allocate a new disk %d\n", | 2060 | "allocate a new disk %d\n", |
1841 | h->ctlr, drv_index); | 2061 | h->ctlr, drv_index); |
1842 | return -1; | 2062 | goto err_free_drive_info; |
1843 | } | 2063 | } |
1844 | } | 2064 | } |
1845 | h->drv[drv_index].LunID = lunid; | 2065 | memcpy(h->drv[drv_index]->LunID, lunid, |
1846 | if (cciss_create_ld_sysfs_entry(h, &h->drv[drv_index], drv_index)) | 2066 | sizeof(h->drv[drv_index]->LunID)); |
2067 | if (cciss_create_ld_sysfs_entry(h, drv_index)) | ||
1847 | goto err_free_disk; | 2068 | goto err_free_disk; |
1848 | |||
1849 | /* Don't need to mark this busy because nobody */ | 2069 | /* Don't need to mark this busy because nobody */ |
1850 | /* else knows about this disk yet to contend */ | 2070 | /* else knows about this disk yet to contend */ |
1851 | /* for access to it. */ | 2071 | /* for access to it. */ |
1852 | h->drv[drv_index].busy_configuring = 0; | 2072 | h->drv[drv_index]->busy_configuring = 0; |
1853 | wmb(); | 2073 | wmb(); |
1854 | return drv_index; | 2074 | return drv_index; |
1855 | 2075 | ||
1856 | err_free_disk: | 2076 | err_free_disk: |
1857 | put_disk(h->gendisk[drv_index]); | 2077 | cciss_free_gendisk(h, drv_index); |
1858 | h->gendisk[drv_index] = NULL; | 2078 | err_free_drive_info: |
2079 | cciss_free_drive_info(h, drv_index); | ||
1859 | return -1; | 2080 | return -1; |
1860 | } | 2081 | } |
1861 | 2082 | ||
@@ -1872,21 +2093,25 @@ static void cciss_add_controller_node(ctlr_info_t *h) | |||
1872 | if (h->gendisk[0] != NULL) /* already did this? Then bail. */ | 2093 | if (h->gendisk[0] != NULL) /* already did this? Then bail. */ |
1873 | return; | 2094 | return; |
1874 | 2095 | ||
1875 | drv_index = cciss_add_gendisk(h, 0, 1); | 2096 | drv_index = cciss_add_gendisk(h, CTLR_LUNID, 1); |
1876 | if (drv_index == -1) { | 2097 | if (drv_index == -1) |
1877 | printk(KERN_WARNING "cciss%d: could not " | 2098 | goto error; |
1878 | "add disk 0.\n", h->ctlr); | 2099 | h->drv[drv_index]->block_size = 512; |
1879 | return; | 2100 | h->drv[drv_index]->nr_blocks = 0; |
1880 | } | 2101 | h->drv[drv_index]->heads = 0; |
1881 | h->drv[drv_index].block_size = 512; | 2102 | h->drv[drv_index]->sectors = 0; |
1882 | h->drv[drv_index].nr_blocks = 0; | 2103 | h->drv[drv_index]->cylinders = 0; |
1883 | h->drv[drv_index].heads = 0; | 2104 | h->drv[drv_index]->raid_level = -1; |
1884 | h->drv[drv_index].sectors = 0; | 2105 | memset(h->drv[drv_index]->serial_no, 0, 16); |
1885 | h->drv[drv_index].cylinders = 0; | ||
1886 | h->drv[drv_index].raid_level = -1; | ||
1887 | memset(h->drv[drv_index].serial_no, 0, 16); | ||
1888 | disk = h->gendisk[drv_index]; | 2106 | disk = h->gendisk[drv_index]; |
1889 | cciss_add_disk(h, disk, drv_index); | 2107 | if (cciss_add_disk(h, disk, drv_index) == 0) |
2108 | return; | ||
2109 | cciss_free_gendisk(h, drv_index); | ||
2110 | cciss_free_drive_info(h, drv_index); | ||
2111 | error: | ||
2112 | printk(KERN_WARNING "cciss%d: could not " | ||
2113 | "add disk 0.\n", h->ctlr); | ||
2114 | return; | ||
1890 | } | 2115 | } |
1891 | 2116 | ||
1892 | /* This function will add and remove logical drives from the Logical | 2117 | /* This function will add and remove logical drives from the Logical |
@@ -1897,7 +2122,8 @@ static void cciss_add_controller_node(ctlr_info_t *h) | |||
1897 | * INPUT | 2122 | * INPUT |
1898 | * h = The controller to perform the operations on | 2123 | * h = The controller to perform the operations on |
1899 | */ | 2124 | */ |
1900 | static int rebuild_lun_table(ctlr_info_t *h, int first_time) | 2125 | static int rebuild_lun_table(ctlr_info_t *h, int first_time, |
2126 | int via_ioctl) | ||
1901 | { | 2127 | { |
1902 | int ctlr = h->ctlr; | 2128 | int ctlr = h->ctlr; |
1903 | int num_luns; | 2129 | int num_luns; |
@@ -1907,7 +2133,7 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time) | |||
1907 | int i; | 2133 | int i; |
1908 | int drv_found; | 2134 | int drv_found; |
1909 | int drv_index = 0; | 2135 | int drv_index = 0; |
1910 | __u32 lunid = 0; | 2136 | unsigned char lunid[8] = CTLR_LUNID; |
1911 | unsigned long flags; | 2137 | unsigned long flags; |
1912 | 2138 | ||
1913 | if (!capable(CAP_SYS_RAWIO)) | 2139 | if (!capable(CAP_SYS_RAWIO)) |
@@ -1960,13 +2186,13 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time) | |||
1960 | drv_found = 0; | 2186 | drv_found = 0; |
1961 | 2187 | ||
1962 | /* skip holes in the array from already deleted drives */ | 2188 | /* skip holes in the array from already deleted drives */ |
1963 | if (h->drv[i].raid_level == -1) | 2189 | if (h->drv[i] == NULL) |
1964 | continue; | 2190 | continue; |
1965 | 2191 | ||
1966 | for (j = 0; j < num_luns; j++) { | 2192 | for (j = 0; j < num_luns; j++) { |
1967 | memcpy(&lunid, &ld_buff->LUN[j][0], 4); | 2193 | memcpy(lunid, &ld_buff->LUN[j][0], sizeof(lunid)); |
1968 | lunid = le32_to_cpu(lunid); | 2194 | if (memcmp(h->drv[i]->LunID, lunid, |
1969 | if (h->drv[i].LunID == lunid) { | 2195 | sizeof(lunid)) == 0) { |
1970 | drv_found = 1; | 2196 | drv_found = 1; |
1971 | break; | 2197 | break; |
1972 | } | 2198 | } |
@@ -1974,11 +2200,11 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time) | |||
1974 | if (!drv_found) { | 2200 | if (!drv_found) { |
1975 | /* Deregister it from the OS, it's gone. */ | 2201 | /* Deregister it from the OS, it's gone. */ |
1976 | spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); | 2202 | spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags); |
1977 | h->drv[i].busy_configuring = 1; | 2203 | h->drv[i]->busy_configuring = 1; |
1978 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); | 2204 | spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags); |
1979 | return_code = deregister_disk(h, i, 1); | 2205 | return_code = deregister_disk(h, i, 1, via_ioctl); |
1980 | cciss_destroy_ld_sysfs_entry(&h->drv[i]); | 2206 | if (h->drv[i] != NULL) |
1981 | h->drv[i].busy_configuring = 0; | 2207 | h->drv[i]->busy_configuring = 0; |
1982 | } | 2208 | } |
1983 | } | 2209 | } |
1984 | 2210 | ||
@@ -1992,17 +2218,16 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time) | |||
1992 | 2218 | ||
1993 | drv_found = 0; | 2219 | drv_found = 0; |
1994 | 2220 | ||
1995 | memcpy(&lunid, &ld_buff->LUN[i][0], 4); | 2221 | memcpy(lunid, &ld_buff->LUN[i][0], sizeof(lunid)); |
1996 | lunid = le32_to_cpu(lunid); | ||
1997 | |||
1998 | /* Find if the LUN is already in the drive array | 2222 | /* Find if the LUN is already in the drive array |
1999 | * of the driver. If so then update its info | 2223 | * of the driver. If so then update its info |
2000 | * if not in use. If it does not exist then find | 2224 | * if not in use. If it does not exist then find |
2001 | * the first free index and add it. | 2225 | * the first free index and add it. |
2002 | */ | 2226 | */ |
2003 | for (j = 0; j <= h->highest_lun; j++) { | 2227 | for (j = 0; j <= h->highest_lun; j++) { |
2004 | if (h->drv[j].raid_level != -1 && | 2228 | if (h->drv[j] != NULL && |
2005 | h->drv[j].LunID == lunid) { | 2229 | memcmp(h->drv[j]->LunID, lunid, |
2230 | sizeof(h->drv[j]->LunID)) == 0) { | ||
2006 | drv_index = j; | 2231 | drv_index = j; |
2007 | drv_found = 1; | 2232 | drv_found = 1; |
2008 | break; | 2233 | break; |
@@ -2015,7 +2240,8 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time) | |||
2015 | if (drv_index == -1) | 2240 | if (drv_index == -1) |
2016 | goto freeret; | 2241 | goto freeret; |
2017 | } | 2242 | } |
2018 | cciss_update_drive_info(ctlr, drv_index, first_time); | 2243 | cciss_update_drive_info(ctlr, drv_index, first_time, |
2244 | via_ioctl); | ||
2019 | } /* end for */ | 2245 | } /* end for */ |
2020 | 2246 | ||
2021 | freeret: | 2247 | freeret: |
@@ -2032,6 +2258,25 @@ mem_msg: | |||
2032 | goto freeret; | 2258 | goto freeret; |
2033 | } | 2259 | } |
2034 | 2260 | ||
2261 | static void cciss_clear_drive_info(drive_info_struct *drive_info) | ||
2262 | { | ||
2263 | /* zero out the disk size info */ | ||
2264 | drive_info->nr_blocks = 0; | ||
2265 | drive_info->block_size = 0; | ||
2266 | drive_info->heads = 0; | ||
2267 | drive_info->sectors = 0; | ||
2268 | drive_info->cylinders = 0; | ||
2269 | drive_info->raid_level = -1; | ||
2270 | memset(drive_info->serial_no, 0, sizeof(drive_info->serial_no)); | ||
2271 | memset(drive_info->model, 0, sizeof(drive_info->model)); | ||
2272 | memset(drive_info->rev, 0, sizeof(drive_info->rev)); | ||
2273 | memset(drive_info->vendor, 0, sizeof(drive_info->vendor)); | ||
2274 | /* | ||
2275 | * don't clear the LUNID though, we need to remember which | ||
2276 | * one this one is. | ||
2277 | */ | ||
2278 | } | ||
2279 | |||
2035 | /* This function will deregister the disk and it's queue from the | 2280 | /* This function will deregister the disk and it's queue from the |
2036 | * kernel. It must be called with the controller lock held and the | 2281 | * kernel. It must be called with the controller lock held and the |
2037 | * drv structures busy_configuring flag set. It's parameters are: | 2282 | * drv structures busy_configuring flag set. It's parameters are: |
@@ -2046,43 +2291,48 @@ mem_msg: | |||
2046 | * the disk in preparation for re-adding it. In this case | 2291 | * the disk in preparation for re-adding it. In this case |
2047 | * the highest_lun should be left unchanged and the LunID | 2292 | * the highest_lun should be left unchanged and the LunID |
2048 | * should not be cleared. | 2293 | * should not be cleared. |
2294 | * via_ioctl | ||
2295 | * This indicates whether we've reached this path via ioctl. | ||
2296 | * This affects the maximum usage count allowed for c0d0 to be messed with. | ||
2297 | * If this path is reached via ioctl(), then the max_usage_count will | ||
2298 | * be 1, as the process calling ioctl() has got to have the device open. | ||
2299 | * If we get here via sysfs, then the max usage count will be zero. | ||
2049 | */ | 2300 | */ |
2050 | static int deregister_disk(ctlr_info_t *h, int drv_index, | 2301 | static int deregister_disk(ctlr_info_t *h, int drv_index, |
2051 | int clear_all) | 2302 | int clear_all, int via_ioctl) |
2052 | { | 2303 | { |
2053 | int i; | 2304 | int i; |
2054 | struct gendisk *disk; | 2305 | struct gendisk *disk; |
2055 | drive_info_struct *drv; | 2306 | drive_info_struct *drv; |
2307 | int recalculate_highest_lun; | ||
2056 | 2308 | ||
2057 | if (!capable(CAP_SYS_RAWIO)) | 2309 | if (!capable(CAP_SYS_RAWIO)) |
2058 | return -EPERM; | 2310 | return -EPERM; |
2059 | 2311 | ||
2060 | drv = &h->drv[drv_index]; | 2312 | drv = h->drv[drv_index]; |
2061 | disk = h->gendisk[drv_index]; | 2313 | disk = h->gendisk[drv_index]; |
2062 | 2314 | ||
2063 | /* make sure logical volume is NOT is use */ | 2315 | /* make sure logical volume is NOT is use */ |
2064 | if (clear_all || (h->gendisk[0] == disk)) { | 2316 | if (clear_all || (h->gendisk[0] == disk)) { |
2065 | if (drv->usage_count > 1) | 2317 | if (drv->usage_count > via_ioctl) |
2066 | return -EBUSY; | 2318 | return -EBUSY; |
2067 | } else if (drv->usage_count > 0) | 2319 | } else if (drv->usage_count > 0) |
2068 | return -EBUSY; | 2320 | return -EBUSY; |
2069 | 2321 | ||
2322 | recalculate_highest_lun = (drv == h->drv[h->highest_lun]); | ||
2323 | |||
2070 | /* invalidate the devices and deregister the disk. If it is disk | 2324 | /* invalidate the devices and deregister the disk. If it is disk |
2071 | * zero do not deregister it but just zero out it's values. This | 2325 | * zero do not deregister it but just zero out it's values. This |
2072 | * allows us to delete disk zero but keep the controller registered. | 2326 | * allows us to delete disk zero but keep the controller registered. |
2073 | */ | 2327 | */ |
2074 | if (h->gendisk[0] != disk) { | 2328 | if (h->gendisk[0] != disk) { |
2075 | struct request_queue *q = disk->queue; | 2329 | struct request_queue *q = disk->queue; |
2076 | if (disk->flags & GENHD_FL_UP) | 2330 | if (disk->flags & GENHD_FL_UP) { |
2331 | cciss_destroy_ld_sysfs_entry(h, drv_index, 0); | ||
2077 | del_gendisk(disk); | 2332 | del_gendisk(disk); |
2078 | if (q) { | ||
2079 | blk_cleanup_queue(q); | ||
2080 | /* Set drv->queue to NULL so that we do not try | ||
2081 | * to call blk_start_queue on this queue in the | ||
2082 | * interrupt handler | ||
2083 | */ | ||
2084 | drv->queue = NULL; | ||
2085 | } | 2333 | } |
2334 | if (q) | ||
2335 | blk_cleanup_queue(q); | ||
2086 | /* If clear_all is set then we are deleting the logical | 2336 | /* If clear_all is set then we are deleting the logical |
2087 | * drive, not just refreshing its info. For drives | 2337 | * drive, not just refreshing its info. For drives |
2088 | * other than disk 0 we will call put_disk. We do not | 2338 | * other than disk 0 we will call put_disk. We do not |
@@ -2105,34 +2355,20 @@ static int deregister_disk(ctlr_info_t *h, int drv_index, | |||
2105 | } | 2355 | } |
2106 | } else { | 2356 | } else { |
2107 | set_capacity(disk, 0); | 2357 | set_capacity(disk, 0); |
2358 | cciss_clear_drive_info(drv); | ||
2108 | } | 2359 | } |
2109 | 2360 | ||
2110 | --h->num_luns; | 2361 | --h->num_luns; |
2111 | /* zero out the disk size info */ | ||
2112 | drv->nr_blocks = 0; | ||
2113 | drv->block_size = 0; | ||
2114 | drv->heads = 0; | ||
2115 | drv->sectors = 0; | ||
2116 | drv->cylinders = 0; | ||
2117 | drv->raid_level = -1; /* This can be used as a flag variable to | ||
2118 | * indicate that this element of the drive | ||
2119 | * array is free. | ||
2120 | */ | ||
2121 | |||
2122 | if (clear_all) { | ||
2123 | /* check to see if it was the last disk */ | ||
2124 | if (drv == h->drv + h->highest_lun) { | ||
2125 | /* if so, find the new hightest lun */ | ||
2126 | int i, newhighest = -1; | ||
2127 | for (i = 0; i <= h->highest_lun; i++) { | ||
2128 | /* if the disk has size > 0, it is available */ | ||
2129 | if (h->drv[i].heads) | ||
2130 | newhighest = i; | ||
2131 | } | ||
2132 | h->highest_lun = newhighest; | ||
2133 | } | ||
2134 | 2362 | ||
2135 | drv->LunID = 0; | 2363 | /* if it was the last disk, find the new hightest lun */ |
2364 | if (clear_all && recalculate_highest_lun) { | ||
2365 | int i, newhighest = -1; | ||
2366 | for (i = 0; i <= h->highest_lun; i++) { | ||
2367 | /* if the disk has size > 0, it is available */ | ||
2368 | if (h->drv[i] && h->drv[i]->heads) | ||
2369 | newhighest = i; | ||
2370 | } | ||
2371 | h->highest_lun = newhighest; | ||
2136 | } | 2372 | } |
2137 | return 0; | 2373 | return 0; |
2138 | } | 2374 | } |
@@ -2479,8 +2715,6 @@ static void cciss_geometry_inquiry(int ctlr, int logvol, | |||
2479 | } else { /* Get geometry failed */ | 2715 | } else { /* Get geometry failed */ |
2480 | printk(KERN_WARNING "cciss: reading geometry failed\n"); | 2716 | printk(KERN_WARNING "cciss: reading geometry failed\n"); |
2481 | } | 2717 | } |
2482 | printk(KERN_INFO " heads=%d, sectors=%d, cylinders=%d\n\n", | ||
2483 | drv->heads, drv->sectors, drv->cylinders); | ||
2484 | } | 2718 | } |
2485 | 2719 | ||
2486 | static void | 2720 | static void |
@@ -2514,9 +2748,6 @@ cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size, | |||
2514 | *total_size = 0; | 2748 | *total_size = 0; |
2515 | *block_size = BLOCK_SIZE; | 2749 | *block_size = BLOCK_SIZE; |
2516 | } | 2750 | } |
2517 | if (*total_size != 0) | ||
2518 | printk(KERN_INFO " blocks= %llu block_size= %d\n", | ||
2519 | (unsigned long long)*total_size+1, *block_size); | ||
2520 | kfree(buf); | 2751 | kfree(buf); |
2521 | } | 2752 | } |
2522 | 2753 | ||
@@ -2568,7 +2799,8 @@ static int cciss_revalidate(struct gendisk *disk) | |||
2568 | InquiryData_struct *inq_buff = NULL; | 2799 | InquiryData_struct *inq_buff = NULL; |
2569 | 2800 | ||
2570 | for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) { | 2801 | for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) { |
2571 | if (h->drv[logvol].LunID == drv->LunID) { | 2802 | if (memcmp(h->drv[logvol]->LunID, drv->LunID, |
2803 | sizeof(drv->LunID)) == 0) { | ||
2572 | FOUND = 1; | 2804 | FOUND = 1; |
2573 | break; | 2805 | break; |
2574 | } | 2806 | } |
@@ -3053,8 +3285,7 @@ static void do_cciss_request(struct request_queue *q) | |||
3053 | /* The first 2 bits are reserved for controller error reporting. */ | 3285 | /* The first 2 bits are reserved for controller error reporting. */ |
3054 | c->Header.Tag.lower = (c->cmdindex << 3); | 3286 | c->Header.Tag.lower = (c->cmdindex << 3); |
3055 | c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */ | 3287 | c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */ |
3056 | c->Header.LUN.LogDev.VolId = drv->LunID; | 3288 | memcpy(&c->Header.LUN, drv->LunID, sizeof(drv->LunID)); |
3057 | c->Header.LUN.LogDev.Mode = 1; | ||
3058 | c->Request.CDBLen = 10; // 12 byte commands not in FW yet; | 3289 | c->Request.CDBLen = 10; // 12 byte commands not in FW yet; |
3059 | c->Request.Type.Type = TYPE_CMD; // It is a command. | 3290 | c->Request.Type.Type = TYPE_CMD; // It is a command. |
3060 | c->Request.Type.Attribute = ATTR_SIMPLE; | 3291 | c->Request.Type.Attribute = ATTR_SIMPLE; |
@@ -3232,20 +3463,121 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id) | |||
3232 | return IRQ_HANDLED; | 3463 | return IRQ_HANDLED; |
3233 | } | 3464 | } |
3234 | 3465 | ||
3466 | /** | ||
3467 | * add_to_scan_list() - add controller to rescan queue | ||
3468 | * @h: Pointer to the controller. | ||
3469 | * | ||
3470 | * Adds the controller to the rescan queue if not already on the queue. | ||
3471 | * | ||
3472 | * returns 1 if added to the queue, 0 if skipped (could be on the | ||
3473 | * queue already, or the controller could be initializing or shutting | ||
3474 | * down). | ||
3475 | **/ | ||
3476 | static int add_to_scan_list(struct ctlr_info *h) | ||
3477 | { | ||
3478 | struct ctlr_info *test_h; | ||
3479 | int found = 0; | ||
3480 | int ret = 0; | ||
3481 | |||
3482 | if (h->busy_initializing) | ||
3483 | return 0; | ||
3484 | |||
3485 | if (!mutex_trylock(&h->busy_shutting_down)) | ||
3486 | return 0; | ||
3487 | |||
3488 | mutex_lock(&scan_mutex); | ||
3489 | list_for_each_entry(test_h, &scan_q, scan_list) { | ||
3490 | if (test_h == h) { | ||
3491 | found = 1; | ||
3492 | break; | ||
3493 | } | ||
3494 | } | ||
3495 | if (!found && !h->busy_scanning) { | ||
3496 | INIT_COMPLETION(h->scan_wait); | ||
3497 | list_add_tail(&h->scan_list, &scan_q); | ||
3498 | ret = 1; | ||
3499 | } | ||
3500 | mutex_unlock(&scan_mutex); | ||
3501 | mutex_unlock(&h->busy_shutting_down); | ||
3502 | |||
3503 | return ret; | ||
3504 | } | ||
3505 | |||
3506 | /** | ||
3507 | * remove_from_scan_list() - remove controller from rescan queue | ||
3508 | * @h: Pointer to the controller. | ||
3509 | * | ||
3510 | * Removes the controller from the rescan queue if present. Blocks if | ||
3511 | * the controller is currently conducting a rescan. | ||
3512 | **/ | ||
3513 | static void remove_from_scan_list(struct ctlr_info *h) | ||
3514 | { | ||
3515 | struct ctlr_info *test_h, *tmp_h; | ||
3516 | int scanning = 0; | ||
3517 | |||
3518 | mutex_lock(&scan_mutex); | ||
3519 | list_for_each_entry_safe(test_h, tmp_h, &scan_q, scan_list) { | ||
3520 | if (test_h == h) { | ||
3521 | list_del(&h->scan_list); | ||
3522 | complete_all(&h->scan_wait); | ||
3523 | mutex_unlock(&scan_mutex); | ||
3524 | return; | ||
3525 | } | ||
3526 | } | ||
3527 | if (&h->busy_scanning) | ||
3528 | scanning = 0; | ||
3529 | mutex_unlock(&scan_mutex); | ||
3530 | |||
3531 | if (scanning) | ||
3532 | wait_for_completion(&h->scan_wait); | ||
3533 | } | ||
3534 | |||
3535 | /** | ||
3536 | * scan_thread() - kernel thread used to rescan controllers | ||
3537 | * @data: Ignored. | ||
3538 | * | ||
3539 | * A kernel thread used scan for drive topology changes on | ||
3540 | * controllers. The thread processes only one controller at a time | ||
3541 | * using a queue. Controllers are added to the queue using | ||
3542 | * add_to_scan_list() and removed from the queue either after done | ||
3543 | * processing or using remove_from_scan_list(). | ||
3544 | * | ||
3545 | * returns 0. | ||
3546 | **/ | ||
3235 | static int scan_thread(void *data) | 3547 | static int scan_thread(void *data) |
3236 | { | 3548 | { |
3237 | ctlr_info_t *h = data; | 3549 | struct ctlr_info *h; |
3238 | int rc; | ||
3239 | DECLARE_COMPLETION_ONSTACK(wait); | ||
3240 | h->rescan_wait = &wait; | ||
3241 | 3550 | ||
3242 | for (;;) { | 3551 | while (1) { |
3243 | rc = wait_for_completion_interruptible(&wait); | 3552 | set_current_state(TASK_INTERRUPTIBLE); |
3553 | schedule(); | ||
3244 | if (kthread_should_stop()) | 3554 | if (kthread_should_stop()) |
3245 | break; | 3555 | break; |
3246 | if (!rc) | 3556 | |
3247 | rebuild_lun_table(h, 0); | 3557 | while (1) { |
3558 | mutex_lock(&scan_mutex); | ||
3559 | if (list_empty(&scan_q)) { | ||
3560 | mutex_unlock(&scan_mutex); | ||
3561 | break; | ||
3562 | } | ||
3563 | |||
3564 | h = list_entry(scan_q.next, | ||
3565 | struct ctlr_info, | ||
3566 | scan_list); | ||
3567 | list_del(&h->scan_list); | ||
3568 | h->busy_scanning = 1; | ||
3569 | mutex_unlock(&scan_mutex); | ||
3570 | |||
3571 | if (h) { | ||
3572 | rebuild_lun_table(h, 0, 0); | ||
3573 | complete_all(&h->scan_wait); | ||
3574 | mutex_lock(&scan_mutex); | ||
3575 | h->busy_scanning = 0; | ||
3576 | mutex_unlock(&scan_mutex); | ||
3577 | } | ||
3578 | } | ||
3248 | } | 3579 | } |
3580 | |||
3249 | return 0; | 3581 | return 0; |
3250 | } | 3582 | } |
3251 | 3583 | ||
@@ -3268,8 +3600,8 @@ static int check_for_unit_attention(ctlr_info_t *h, CommandList_struct *c) | |||
3268 | case REPORT_LUNS_CHANGED: | 3600 | case REPORT_LUNS_CHANGED: |
3269 | printk(KERN_WARNING "cciss%d: report LUN data " | 3601 | printk(KERN_WARNING "cciss%d: report LUN data " |
3270 | "changed\n", h->ctlr); | 3602 | "changed\n", h->ctlr); |
3271 | if (h->rescan_wait) | 3603 | add_to_scan_list(h); |
3272 | complete(h->rescan_wait); | 3604 | wake_up_process(cciss_scan_thread); |
3273 | return 1; | 3605 | return 1; |
3274 | break; | 3606 | break; |
3275 | case POWER_OR_RESET: | 3607 | case POWER_OR_RESET: |
@@ -3489,7 +3821,7 @@ static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev) | |||
3489 | if (scratchpad == CCISS_FIRMWARE_READY) | 3821 | if (scratchpad == CCISS_FIRMWARE_READY) |
3490 | break; | 3822 | break; |
3491 | set_current_state(TASK_INTERRUPTIBLE); | 3823 | set_current_state(TASK_INTERRUPTIBLE); |
3492 | schedule_timeout(HZ / 10); /* wait 100ms */ | 3824 | schedule_timeout(msecs_to_jiffies(100)); /* wait 100ms */ |
3493 | } | 3825 | } |
3494 | if (scratchpad != CCISS_FIRMWARE_READY) { | 3826 | if (scratchpad != CCISS_FIRMWARE_READY) { |
3495 | printk(KERN_WARNING "cciss: Board not ready. Timed out.\n"); | 3827 | printk(KERN_WARNING "cciss: Board not ready. Timed out.\n"); |
@@ -3615,7 +3947,7 @@ static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev) | |||
3615 | break; | 3947 | break; |
3616 | /* delay and try again */ | 3948 | /* delay and try again */ |
3617 | set_current_state(TASK_INTERRUPTIBLE); | 3949 | set_current_state(TASK_INTERRUPTIBLE); |
3618 | schedule_timeout(10); | 3950 | schedule_timeout(msecs_to_jiffies(1)); |
3619 | } | 3951 | } |
3620 | 3952 | ||
3621 | #ifdef CCISS_DEBUG | 3953 | #ifdef CCISS_DEBUG |
@@ -3669,15 +4001,16 @@ Enomem: | |||
3669 | return -1; | 4001 | return -1; |
3670 | } | 4002 | } |
3671 | 4003 | ||
3672 | static void free_hba(int i) | 4004 | static void free_hba(int n) |
3673 | { | 4005 | { |
3674 | ctlr_info_t *p = hba[i]; | 4006 | ctlr_info_t *h = hba[n]; |
3675 | int n; | 4007 | int i; |
3676 | 4008 | ||
3677 | hba[i] = NULL; | 4009 | hba[n] = NULL; |
3678 | for (n = 0; n < CISS_MAX_LUN; n++) | 4010 | for (i = 0; i < h->highest_lun + 1; i++) |
3679 | put_disk(p->gendisk[n]); | 4011 | if (h->gendisk[i] != NULL) |
3680 | kfree(p); | 4012 | put_disk(h->gendisk[i]); |
4013 | kfree(h); | ||
3681 | } | 4014 | } |
3682 | 4015 | ||
3683 | /* Send a message CDB to the firmware. */ | 4016 | /* Send a message CDB to the firmware. */ |
@@ -3918,6 +4251,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev, | |||
3918 | hba[i]->busy_initializing = 1; | 4251 | hba[i]->busy_initializing = 1; |
3919 | INIT_HLIST_HEAD(&hba[i]->cmpQ); | 4252 | INIT_HLIST_HEAD(&hba[i]->cmpQ); |
3920 | INIT_HLIST_HEAD(&hba[i]->reqQ); | 4253 | INIT_HLIST_HEAD(&hba[i]->reqQ); |
4254 | mutex_init(&hba[i]->busy_shutting_down); | ||
3921 | 4255 | ||
3922 | if (cciss_pci_init(hba[i], pdev) != 0) | 4256 | if (cciss_pci_init(hba[i], pdev) != 0) |
3923 | goto clean0; | 4257 | goto clean0; |
@@ -3926,6 +4260,8 @@ static int __devinit cciss_init_one(struct pci_dev *pdev, | |||
3926 | hba[i]->ctlr = i; | 4260 | hba[i]->ctlr = i; |
3927 | hba[i]->pdev = pdev; | 4261 | hba[i]->pdev = pdev; |
3928 | 4262 | ||
4263 | init_completion(&hba[i]->scan_wait); | ||
4264 | |||
3929 | if (cciss_create_hba_sysfs_entry(hba[i])) | 4265 | if (cciss_create_hba_sysfs_entry(hba[i])) |
3930 | goto clean0; | 4266 | goto clean0; |
3931 | 4267 | ||
@@ -4001,8 +4337,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev, | |||
4001 | hba[i]->num_luns = 0; | 4337 | hba[i]->num_luns = 0; |
4002 | hba[i]->highest_lun = -1; | 4338 | hba[i]->highest_lun = -1; |
4003 | for (j = 0; j < CISS_MAX_LUN; j++) { | 4339 | for (j = 0; j < CISS_MAX_LUN; j++) { |
4004 | hba[i]->drv[j].raid_level = -1; | 4340 | hba[i]->drv[j] = NULL; |
4005 | hba[i]->drv[j].queue = NULL; | ||
4006 | hba[i]->gendisk[j] = NULL; | 4341 | hba[i]->gendisk[j] = NULL; |
4007 | } | 4342 | } |
4008 | 4343 | ||
@@ -4035,14 +4370,8 @@ static int __devinit cciss_init_one(struct pci_dev *pdev, | |||
4035 | 4370 | ||
4036 | hba[i]->cciss_max_sectors = 2048; | 4371 | hba[i]->cciss_max_sectors = 2048; |
4037 | 4372 | ||
4373 | rebuild_lun_table(hba[i], 1, 0); | ||
4038 | hba[i]->busy_initializing = 0; | 4374 | hba[i]->busy_initializing = 0; |
4039 | |||
4040 | rebuild_lun_table(hba[i], 1); | ||
4041 | hba[i]->cciss_scan_thread = kthread_run(scan_thread, hba[i], | ||
4042 | "cciss_scan%02d", i); | ||
4043 | if (IS_ERR(hba[i]->cciss_scan_thread)) | ||
4044 | return PTR_ERR(hba[i]->cciss_scan_thread); | ||
4045 | |||
4046 | return 1; | 4375 | return 1; |
4047 | 4376 | ||
4048 | clean4: | 4377 | clean4: |
@@ -4063,12 +4392,7 @@ clean1: | |||
4063 | cciss_destroy_hba_sysfs_entry(hba[i]); | 4392 | cciss_destroy_hba_sysfs_entry(hba[i]); |
4064 | clean0: | 4393 | clean0: |
4065 | hba[i]->busy_initializing = 0; | 4394 | hba[i]->busy_initializing = 0; |
4066 | /* cleanup any queues that may have been initialized */ | 4395 | |
4067 | for (j=0; j <= hba[i]->highest_lun; j++){ | ||
4068 | drive_info_struct *drv = &(hba[i]->drv[j]); | ||
4069 | if (drv->queue) | ||
4070 | blk_cleanup_queue(drv->queue); | ||
4071 | } | ||
4072 | /* | 4396 | /* |
4073 | * Deliberately omit pci_disable_device(): it does something nasty to | 4397 | * Deliberately omit pci_disable_device(): it does something nasty to |
4074 | * Smart Array controllers that pci_enable_device does not undo | 4398 | * Smart Array controllers that pci_enable_device does not undo |
@@ -4125,8 +4449,9 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev) | |||
4125 | return; | 4449 | return; |
4126 | } | 4450 | } |
4127 | 4451 | ||
4128 | kthread_stop(hba[i]->cciss_scan_thread); | 4452 | mutex_lock(&hba[i]->busy_shutting_down); |
4129 | 4453 | ||
4454 | remove_from_scan_list(hba[i]); | ||
4130 | remove_proc_entry(hba[i]->devname, proc_cciss); | 4455 | remove_proc_entry(hba[i]->devname, proc_cciss); |
4131 | unregister_blkdev(hba[i]->major, hba[i]->devname); | 4456 | unregister_blkdev(hba[i]->major, hba[i]->devname); |
4132 | 4457 | ||
@@ -4136,8 +4461,10 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev) | |||
4136 | if (disk) { | 4461 | if (disk) { |
4137 | struct request_queue *q = disk->queue; | 4462 | struct request_queue *q = disk->queue; |
4138 | 4463 | ||
4139 | if (disk->flags & GENHD_FL_UP) | 4464 | if (disk->flags & GENHD_FL_UP) { |
4465 | cciss_destroy_ld_sysfs_entry(hba[i], j, 1); | ||
4140 | del_gendisk(disk); | 4466 | del_gendisk(disk); |
4467 | } | ||
4141 | if (q) | 4468 | if (q) |
4142 | blk_cleanup_queue(q); | 4469 | blk_cleanup_queue(q); |
4143 | } | 4470 | } |
@@ -4170,6 +4497,7 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev) | |||
4170 | pci_release_regions(pdev); | 4497 | pci_release_regions(pdev); |
4171 | pci_set_drvdata(pdev, NULL); | 4498 | pci_set_drvdata(pdev, NULL); |
4172 | cciss_destroy_hba_sysfs_entry(hba[i]); | 4499 | cciss_destroy_hba_sysfs_entry(hba[i]); |
4500 | mutex_unlock(&hba[i]->busy_shutting_down); | ||
4173 | free_hba(i); | 4501 | free_hba(i); |
4174 | } | 4502 | } |
4175 | 4503 | ||
@@ -4202,15 +4530,25 @@ static int __init cciss_init(void) | |||
4202 | if (err) | 4530 | if (err) |
4203 | return err; | 4531 | return err; |
4204 | 4532 | ||
4533 | /* Start the scan thread */ | ||
4534 | cciss_scan_thread = kthread_run(scan_thread, NULL, "cciss_scan"); | ||
4535 | if (IS_ERR(cciss_scan_thread)) { | ||
4536 | err = PTR_ERR(cciss_scan_thread); | ||
4537 | goto err_bus_unregister; | ||
4538 | } | ||
4539 | |||
4205 | /* Register for our PCI devices */ | 4540 | /* Register for our PCI devices */ |
4206 | err = pci_register_driver(&cciss_pci_driver); | 4541 | err = pci_register_driver(&cciss_pci_driver); |
4207 | if (err) | 4542 | if (err) |
4208 | goto err_bus_register; | 4543 | goto err_thread_stop; |
4209 | 4544 | ||
4210 | return 0; | 4545 | return err; |
4211 | 4546 | ||
4212 | err_bus_register: | 4547 | err_thread_stop: |
4548 | kthread_stop(cciss_scan_thread); | ||
4549 | err_bus_unregister: | ||
4213 | bus_unregister(&cciss_bus_type); | 4550 | bus_unregister(&cciss_bus_type); |
4551 | |||
4214 | return err; | 4552 | return err; |
4215 | } | 4553 | } |
4216 | 4554 | ||
@@ -4227,6 +4565,7 @@ static void __exit cciss_cleanup(void) | |||
4227 | cciss_remove_one(hba[i]->pdev); | 4565 | cciss_remove_one(hba[i]->pdev); |
4228 | } | 4566 | } |
4229 | } | 4567 | } |
4568 | kthread_stop(cciss_scan_thread); | ||
4230 | remove_proc_entry("driver/cciss", NULL); | 4569 | remove_proc_entry("driver/cciss", NULL); |
4231 | bus_unregister(&cciss_bus_type); | 4570 | bus_unregister(&cciss_bus_type); |
4232 | } | 4571 | } |
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h index 06a5db25b298..31524cf42c77 100644 --- a/drivers/block/cciss.h +++ b/drivers/block/cciss.h | |||
@@ -2,6 +2,7 @@ | |||
2 | #define CCISS_H | 2 | #define CCISS_H |
3 | 3 | ||
4 | #include <linux/genhd.h> | 4 | #include <linux/genhd.h> |
5 | #include <linux/mutex.h> | ||
5 | 6 | ||
6 | #include "cciss_cmd.h" | 7 | #include "cciss_cmd.h" |
7 | 8 | ||
@@ -29,7 +30,7 @@ struct access_method { | |||
29 | }; | 30 | }; |
30 | typedef struct _drive_info_struct | 31 | typedef struct _drive_info_struct |
31 | { | 32 | { |
32 | __u32 LunID; | 33 | unsigned char LunID[8]; |
33 | int usage_count; | 34 | int usage_count; |
34 | struct request_queue *queue; | 35 | struct request_queue *queue; |
35 | sector_t nr_blocks; | 36 | sector_t nr_blocks; |
@@ -51,6 +52,7 @@ typedef struct _drive_info_struct | |||
51 | char vendor[VENDOR_LEN + 1]; /* SCSI vendor string */ | 52 | char vendor[VENDOR_LEN + 1]; /* SCSI vendor string */ |
52 | char model[MODEL_LEN + 1]; /* SCSI model string */ | 53 | char model[MODEL_LEN + 1]; /* SCSI model string */ |
53 | char rev[REV_LEN + 1]; /* SCSI revision string */ | 54 | char rev[REV_LEN + 1]; /* SCSI revision string */ |
55 | char device_initialized; /* indicates whether dev is initialized */ | ||
54 | } drive_info_struct; | 56 | } drive_info_struct; |
55 | 57 | ||
56 | struct ctlr_info | 58 | struct ctlr_info |
@@ -86,7 +88,7 @@ struct ctlr_info | |||
86 | BYTE cciss_read_capacity; | 88 | BYTE cciss_read_capacity; |
87 | 89 | ||
88 | // information about each logical volume | 90 | // information about each logical volume |
89 | drive_info_struct drv[CISS_MAX_LUN]; | 91 | drive_info_struct *drv[CISS_MAX_LUN]; |
90 | 92 | ||
91 | struct access_method access; | 93 | struct access_method access; |
92 | 94 | ||
@@ -108,6 +110,8 @@ struct ctlr_info | |||
108 | int nr_frees; | 110 | int nr_frees; |
109 | int busy_configuring; | 111 | int busy_configuring; |
110 | int busy_initializing; | 112 | int busy_initializing; |
113 | int busy_scanning; | ||
114 | struct mutex busy_shutting_down; | ||
111 | 115 | ||
112 | /* This element holds the zero based queue number of the last | 116 | /* This element holds the zero based queue number of the last |
113 | * queue to be started. It is used for fairness. | 117 | * queue to be started. It is used for fairness. |
@@ -122,8 +126,8 @@ struct ctlr_info | |||
122 | /* and saved for later processing */ | 126 | /* and saved for later processing */ |
123 | #endif | 127 | #endif |
124 | unsigned char alive; | 128 | unsigned char alive; |
125 | struct completion *rescan_wait; | 129 | struct list_head scan_list; |
126 | struct task_struct *cciss_scan_thread; | 130 | struct completion scan_wait; |
127 | struct device dev; | 131 | struct device dev; |
128 | }; | 132 | }; |
129 | 133 | ||
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c index b82d438e2607..6422651ec364 100644 --- a/drivers/block/cpqarray.c +++ b/drivers/block/cpqarray.c | |||
@@ -32,6 +32,7 @@ | |||
32 | #include <linux/blkpg.h> | 32 | #include <linux/blkpg.h> |
33 | #include <linux/timer.h> | 33 | #include <linux/timer.h> |
34 | #include <linux/proc_fs.h> | 34 | #include <linux/proc_fs.h> |
35 | #include <linux/seq_file.h> | ||
35 | #include <linux/init.h> | 36 | #include <linux/init.h> |
36 | #include <linux/hdreg.h> | 37 | #include <linux/hdreg.h> |
37 | #include <linux/spinlock.h> | 38 | #include <linux/spinlock.h> |
@@ -177,7 +178,6 @@ static int cpqarray_register_ctlr(int ctlr, struct pci_dev *pdev); | |||
177 | 178 | ||
178 | #ifdef CONFIG_PROC_FS | 179 | #ifdef CONFIG_PROC_FS |
179 | static void ida_procinit(int i); | 180 | static void ida_procinit(int i); |
180 | static int ida_proc_get_info(char *buffer, char **start, off_t offset, int length, int *eof, void *data); | ||
181 | #else | 181 | #else |
182 | static void ida_procinit(int i) {} | 182 | static void ida_procinit(int i) {} |
183 | #endif | 183 | #endif |
@@ -206,6 +206,7 @@ static const struct block_device_operations ida_fops = { | |||
206 | #ifdef CONFIG_PROC_FS | 206 | #ifdef CONFIG_PROC_FS |
207 | 207 | ||
208 | static struct proc_dir_entry *proc_array; | 208 | static struct proc_dir_entry *proc_array; |
209 | static const struct file_operations ida_proc_fops; | ||
209 | 210 | ||
210 | /* | 211 | /* |
211 | * Get us a file in /proc/array that says something about each controller. | 212 | * Get us a file in /proc/array that says something about each controller. |
@@ -218,19 +219,16 @@ static void __init ida_procinit(int i) | |||
218 | if (!proc_array) return; | 219 | if (!proc_array) return; |
219 | } | 220 | } |
220 | 221 | ||
221 | create_proc_read_entry(hba[i]->devname, 0, proc_array, | 222 | proc_create_data(hba[i]->devname, 0, proc_array, &ida_proc_fops, hba[i]); |
222 | ida_proc_get_info, hba[i]); | ||
223 | } | 223 | } |
224 | 224 | ||
225 | /* | 225 | /* |
226 | * Report information about this controller. | 226 | * Report information about this controller. |
227 | */ | 227 | */ |
228 | static int ida_proc_get_info(char *buffer, char **start, off_t offset, int length, int *eof, void *data) | 228 | static int ida_proc_show(struct seq_file *m, void *v) |
229 | { | 229 | { |
230 | off_t pos = 0; | 230 | int i, ctlr; |
231 | off_t len = 0; | 231 | ctlr_info_t *h = (ctlr_info_t*)m->private; |
232 | int size, i, ctlr; | ||
233 | ctlr_info_t *h = (ctlr_info_t*)data; | ||
234 | drv_info_t *drv; | 232 | drv_info_t *drv; |
235 | #ifdef CPQ_PROC_PRINT_QUEUES | 233 | #ifdef CPQ_PROC_PRINT_QUEUES |
236 | cmdlist_t *c; | 234 | cmdlist_t *c; |
@@ -238,7 +236,7 @@ static int ida_proc_get_info(char *buffer, char **start, off_t offset, int lengt | |||
238 | #endif | 236 | #endif |
239 | 237 | ||
240 | ctlr = h->ctlr; | 238 | ctlr = h->ctlr; |
241 | size = sprintf(buffer, "%s: Compaq %s Controller\n" | 239 | seq_printf(m, "%s: Compaq %s Controller\n" |
242 | " Board ID: 0x%08lx\n" | 240 | " Board ID: 0x%08lx\n" |
243 | " Firmware Revision: %c%c%c%c\n" | 241 | " Firmware Revision: %c%c%c%c\n" |
244 | " Controller Sig: 0x%08lx\n" | 242 | " Controller Sig: 0x%08lx\n" |
@@ -258,55 +256,54 @@ static int ida_proc_get_info(char *buffer, char **start, off_t offset, int lengt | |||
258 | h->log_drives, h->phys_drives, | 256 | h->log_drives, h->phys_drives, |
259 | h->Qdepth, h->maxQsinceinit); | 257 | h->Qdepth, h->maxQsinceinit); |
260 | 258 | ||
261 | pos += size; len += size; | 259 | seq_puts(m, "Logical Drive Info:\n"); |
262 | |||
263 | size = sprintf(buffer+len, "Logical Drive Info:\n"); | ||
264 | pos += size; len += size; | ||
265 | 260 | ||
266 | for(i=0; i<h->log_drives; i++) { | 261 | for(i=0; i<h->log_drives; i++) { |
267 | drv = &h->drv[i]; | 262 | drv = &h->drv[i]; |
268 | size = sprintf(buffer+len, "ida/c%dd%d: blksz=%d nr_blks=%d\n", | 263 | seq_printf(m, "ida/c%dd%d: blksz=%d nr_blks=%d\n", |
269 | ctlr, i, drv->blk_size, drv->nr_blks); | 264 | ctlr, i, drv->blk_size, drv->nr_blks); |
270 | pos += size; len += size; | ||
271 | } | 265 | } |
272 | 266 | ||
273 | #ifdef CPQ_PROC_PRINT_QUEUES | 267 | #ifdef CPQ_PROC_PRINT_QUEUES |
274 | spin_lock_irqsave(IDA_LOCK(h->ctlr), flags); | 268 | spin_lock_irqsave(IDA_LOCK(h->ctlr), flags); |
275 | size = sprintf(buffer+len, "\nCurrent Queues:\n"); | 269 | seq_puts(m, "\nCurrent Queues:\n"); |
276 | pos += size; len += size; | ||
277 | 270 | ||
278 | c = h->reqQ; | 271 | c = h->reqQ; |
279 | size = sprintf(buffer+len, "reqQ = %p", c); pos += size; len += size; | 272 | seq_printf(m, "reqQ = %p", c); |
280 | if (c) c=c->next; | 273 | if (c) c=c->next; |
281 | while(c && c != h->reqQ) { | 274 | while(c && c != h->reqQ) { |
282 | size = sprintf(buffer+len, "->%p", c); | 275 | seq_printf(m, "->%p", c); |
283 | pos += size; len += size; | ||
284 | c=c->next; | 276 | c=c->next; |
285 | } | 277 | } |
286 | 278 | ||
287 | c = h->cmpQ; | 279 | c = h->cmpQ; |
288 | size = sprintf(buffer+len, "\ncmpQ = %p", c); pos += size; len += size; | 280 | seq_printf(m, "\ncmpQ = %p", c); |
289 | if (c) c=c->next; | 281 | if (c) c=c->next; |
290 | while(c && c != h->cmpQ) { | 282 | while(c && c != h->cmpQ) { |
291 | size = sprintf(buffer+len, "->%p", c); | 283 | seq_printf(m, "->%p", c); |
292 | pos += size; len += size; | ||
293 | c=c->next; | 284 | c=c->next; |
294 | } | 285 | } |
295 | 286 | ||
296 | size = sprintf(buffer+len, "\n"); pos += size; len += size; | 287 | seq_putc(m, '\n'); |
297 | spin_unlock_irqrestore(IDA_LOCK(h->ctlr), flags); | 288 | spin_unlock_irqrestore(IDA_LOCK(h->ctlr), flags); |
298 | #endif | 289 | #endif |
299 | size = sprintf(buffer+len, "nr_allocs = %d\nnr_frees = %d\n", | 290 | seq_printf(m, "nr_allocs = %d\nnr_frees = %d\n", |
300 | h->nr_allocs, h->nr_frees); | 291 | h->nr_allocs, h->nr_frees); |
301 | pos += size; len += size; | 292 | return 0; |
302 | 293 | } | |
303 | *eof = 1; | 294 | |
304 | *start = buffer+offset; | 295 | static int ida_proc_open(struct inode *inode, struct file *file) |
305 | len -= offset; | 296 | { |
306 | if (len>length) | 297 | return single_open(file, ida_proc_show, PDE(inode)->data); |
307 | len = length; | ||
308 | return len; | ||
309 | } | 298 | } |
299 | |||
300 | static const struct file_operations ida_proc_fops = { | ||
301 | .owner = THIS_MODULE, | ||
302 | .open = ida_proc_open, | ||
303 | .read = seq_read, | ||
304 | .llseek = seq_lseek, | ||
305 | .release = single_release, | ||
306 | }; | ||
310 | #endif /* CONFIG_PROC_FS */ | 307 | #endif /* CONFIG_PROC_FS */ |
311 | 308 | ||
312 | module_param_array(eisa, int, NULL, 0); | 309 | module_param_array(eisa, int, NULL, 0); |
diff --git a/drivers/char/agp/parisc-agp.c b/drivers/char/agp/parisc-agp.c index 60ab75104da9..1c129211302d 100644 --- a/drivers/char/agp/parisc-agp.c +++ b/drivers/char/agp/parisc-agp.c | |||
@@ -217,7 +217,7 @@ static const struct agp_bridge_driver parisc_agp_driver = { | |||
217 | .configure = parisc_agp_configure, | 217 | .configure = parisc_agp_configure, |
218 | .fetch_size = parisc_agp_fetch_size, | 218 | .fetch_size = parisc_agp_fetch_size, |
219 | .tlb_flush = parisc_agp_tlbflush, | 219 | .tlb_flush = parisc_agp_tlbflush, |
220 | .mask_memory = parisc_agp_page_mask_memory, | 220 | .mask_memory = parisc_agp_mask_memory, |
221 | .masks = parisc_agp_masks, | 221 | .masks = parisc_agp_masks, |
222 | .agp_enable = parisc_agp_enable, | 222 | .agp_enable = parisc_agp_enable, |
223 | .cache_flush = global_cache_flush, | 223 | .cache_flush = global_cache_flush, |
diff --git a/drivers/char/apm-emulation.c b/drivers/char/apm-emulation.c index aaca40283be9..4f568cb9af3f 100644 --- a/drivers/char/apm-emulation.c +++ b/drivers/char/apm-emulation.c | |||
@@ -393,7 +393,7 @@ static int apm_open(struct inode * inode, struct file * filp) | |||
393 | return as ? 0 : -ENOMEM; | 393 | return as ? 0 : -ENOMEM; |
394 | } | 394 | } |
395 | 395 | ||
396 | static struct file_operations apm_bios_fops = { | 396 | static const struct file_operations apm_bios_fops = { |
397 | .owner = THIS_MODULE, | 397 | .owner = THIS_MODULE, |
398 | .read = apm_read, | 398 | .read = apm_read, |
399 | .poll = apm_poll, | 399 | .poll = apm_poll, |
diff --git a/drivers/char/bfin-otp.c b/drivers/char/bfin-otp.c index e3dd24bff514..836d4f0a876f 100644 --- a/drivers/char/bfin-otp.c +++ b/drivers/char/bfin-otp.c | |||
@@ -217,7 +217,7 @@ static long bfin_otp_ioctl(struct file *filp, unsigned cmd, unsigned long arg) | |||
217 | # define bfin_otp_ioctl NULL | 217 | # define bfin_otp_ioctl NULL |
218 | #endif | 218 | #endif |
219 | 219 | ||
220 | static struct file_operations bfin_otp_fops = { | 220 | static const struct file_operations bfin_otp_fops = { |
221 | .owner = THIS_MODULE, | 221 | .owner = THIS_MODULE, |
222 | .unlocked_ioctl = bfin_otp_ioctl, | 222 | .unlocked_ioctl = bfin_otp_ioctl, |
223 | .read = bfin_otp_read, | 223 | .read = bfin_otp_read, |
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c index df5038bbcbc2..4254457d3911 100644 --- a/drivers/char/cyclades.c +++ b/drivers/char/cyclades.c | |||
@@ -3354,7 +3354,7 @@ static int __init cy_detect_isa(void) | |||
3354 | continue; | 3354 | continue; |
3355 | } | 3355 | } |
3356 | #ifdef MODULE | 3356 | #ifdef MODULE |
3357 | if (isparam && irq[i]) | 3357 | if (isparam && i < NR_CARDS && irq[i]) |
3358 | cy_isa_irq = irq[i]; | 3358 | cy_isa_irq = irq[i]; |
3359 | else | 3359 | else |
3360 | #endif | 3360 | #endif |
diff --git a/drivers/char/dtlk.c b/drivers/char/dtlk.c index 52e06589821d..045c930e6320 100644 --- a/drivers/char/dtlk.c +++ b/drivers/char/dtlk.c | |||
@@ -56,6 +56,7 @@ | |||
56 | #include <linux/errno.h> /* for -EBUSY */ | 56 | #include <linux/errno.h> /* for -EBUSY */ |
57 | #include <linux/ioport.h> /* for request_region */ | 57 | #include <linux/ioport.h> /* for request_region */ |
58 | #include <linux/delay.h> /* for loops_per_jiffy */ | 58 | #include <linux/delay.h> /* for loops_per_jiffy */ |
59 | #include <linux/sched.h> | ||
59 | #include <linux/smp_lock.h> /* cycle_kernel_lock() */ | 60 | #include <linux/smp_lock.h> /* cycle_kernel_lock() */ |
60 | #include <asm/io.h> /* for inb_p, outb_p, inb, outb, etc. */ | 61 | #include <asm/io.h> /* for inb_p, outb_p, inb, outb, etc. */ |
61 | #include <asm/uaccess.h> /* for get_user, etc. */ | 62 | #include <asm/uaccess.h> /* for get_user, etc. */ |
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c index 41fc11dc921c..65545de3dbf4 100644 --- a/drivers/char/ipmi/ipmi_devintf.c +++ b/drivers/char/ipmi/ipmi_devintf.c | |||
@@ -36,6 +36,7 @@ | |||
36 | #include <linux/errno.h> | 36 | #include <linux/errno.h> |
37 | #include <asm/system.h> | 37 | #include <asm/system.h> |
38 | #include <linux/poll.h> | 38 | #include <linux/poll.h> |
39 | #include <linux/sched.h> | ||
39 | #include <linux/spinlock.h> | 40 | #include <linux/spinlock.h> |
40 | #include <linux/slab.h> | 41 | #include <linux/slab.h> |
41 | #include <linux/ipmi.h> | 42 | #include <linux/ipmi.h> |
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c index 09050797c76a..ec5e3f8df648 100644 --- a/drivers/char/ipmi/ipmi_msghandler.c +++ b/drivers/char/ipmi/ipmi_msghandler.c | |||
@@ -35,6 +35,7 @@ | |||
35 | #include <linux/errno.h> | 35 | #include <linux/errno.h> |
36 | #include <asm/system.h> | 36 | #include <asm/system.h> |
37 | #include <linux/poll.h> | 37 | #include <linux/poll.h> |
38 | #include <linux/sched.h> | ||
38 | #include <linux/spinlock.h> | 39 | #include <linux/spinlock.h> |
39 | #include <linux/mutex.h> | 40 | #include <linux/mutex.h> |
40 | #include <linux/slab.h> | 41 | #include <linux/slab.h> |
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c index 5942a9d674c0..452370af95de 100644 --- a/drivers/char/serial167.c +++ b/drivers/char/serial167.c | |||
@@ -220,8 +220,7 @@ static inline int serial_paranoia_check(struct cyclades_port *info, char *name, | |||
220 | return 1; | 220 | return 1; |
221 | } | 221 | } |
222 | 222 | ||
223 | if ((long)info < (long)(&cy_port[0]) | 223 | if (info < &cy_port[0] || info >= &cy_port[NR_PORTS]) { |
224 | || (long)(&cy_port[NR_PORTS]) < (long)info) { | ||
225 | printk("Warning: cyclades_port out of range for (%s) in %s\n", | 224 | printk("Warning: cyclades_port out of range for (%s) in %s\n", |
226 | name, routine); | 225 | name, routine); |
227 | return 1; | 226 | return 1; |
@@ -520,15 +519,13 @@ static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id) | |||
520 | panic("TxInt on debug port!!!"); | 519 | panic("TxInt on debug port!!!"); |
521 | } | 520 | } |
522 | #endif | 521 | #endif |
523 | |||
524 | info = &cy_port[channel]; | ||
525 | |||
526 | /* validate the port number (as configured and open) */ | 522 | /* validate the port number (as configured and open) */ |
527 | if ((channel < 0) || (NR_PORTS <= channel)) { | 523 | if ((channel < 0) || (NR_PORTS <= channel)) { |
528 | base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy); | 524 | base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy); |
529 | base_addr[CyTEOIR] = CyNOTRANS; | 525 | base_addr[CyTEOIR] = CyNOTRANS; |
530 | return IRQ_HANDLED; | 526 | return IRQ_HANDLED; |
531 | } | 527 | } |
528 | info = &cy_port[channel]; | ||
532 | info->last_active = jiffies; | 529 | info->last_active = jiffies; |
533 | if (info->tty == 0) { | 530 | if (info->tty == 0) { |
534 | base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy); | 531 | base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy); |
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c index aafdbaebc16a..feb55075819b 100644 --- a/drivers/char/tty_ldisc.c +++ b/drivers/char/tty_ldisc.c | |||
@@ -518,7 +518,7 @@ static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old) | |||
518 | static int tty_ldisc_halt(struct tty_struct *tty) | 518 | static int tty_ldisc_halt(struct tty_struct *tty) |
519 | { | 519 | { |
520 | clear_bit(TTY_LDISC, &tty->flags); | 520 | clear_bit(TTY_LDISC, &tty->flags); |
521 | return cancel_delayed_work(&tty->buf.work); | 521 | return cancel_delayed_work_sync(&tty->buf.work); |
522 | } | 522 | } |
523 | 523 | ||
524 | /** | 524 | /** |
@@ -756,12 +756,9 @@ void tty_ldisc_hangup(struct tty_struct *tty) | |||
756 | * N_TTY. | 756 | * N_TTY. |
757 | */ | 757 | */ |
758 | if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) { | 758 | if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) { |
759 | /* Make sure the old ldisc is quiescent */ | ||
760 | tty_ldisc_halt(tty); | ||
761 | flush_scheduled_work(); | ||
762 | |||
763 | /* Avoid racing set_ldisc or tty_ldisc_release */ | 759 | /* Avoid racing set_ldisc or tty_ldisc_release */ |
764 | mutex_lock(&tty->ldisc_mutex); | 760 | mutex_lock(&tty->ldisc_mutex); |
761 | tty_ldisc_halt(tty); | ||
765 | if (tty->ldisc) { /* Not yet closed */ | 762 | if (tty->ldisc) { /* Not yet closed */ |
766 | /* Switch back to N_TTY */ | 763 | /* Switch back to N_TTY */ |
767 | tty_ldisc_reinit(tty); | 764 | tty_ldisc_reinit(tty); |
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c index 29c651ab0d78..6b36ee56e6fe 100644 --- a/drivers/char/vt_ioctl.c +++ b/drivers/char/vt_ioctl.c | |||
@@ -981,8 +981,10 @@ int vt_ioctl(struct tty_struct *tty, struct file * file, | |||
981 | goto eperm; | 981 | goto eperm; |
982 | 982 | ||
983 | if (copy_from_user(&vsa, (struct vt_setactivate __user *)arg, | 983 | if (copy_from_user(&vsa, (struct vt_setactivate __user *)arg, |
984 | sizeof(struct vt_setactivate))) | 984 | sizeof(struct vt_setactivate))) { |
985 | return -EFAULT; | 985 | ret = -EFAULT; |
986 | goto out; | ||
987 | } | ||
986 | if (vsa.console == 0 || vsa.console > MAX_NR_CONSOLES) | 988 | if (vsa.console == 0 || vsa.console > MAX_NR_CONSOLES) |
987 | ret = -ENXIO; | 989 | ret = -ENXIO; |
988 | else { | 990 | else { |
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.c b/drivers/char/xilinx_hwicap/xilinx_hwicap.c index f40ab699860f..4846d50199f3 100644 --- a/drivers/char/xilinx_hwicap/xilinx_hwicap.c +++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.c | |||
@@ -559,7 +559,7 @@ static int hwicap_release(struct inode *inode, struct file *file) | |||
559 | return status; | 559 | return status; |
560 | } | 560 | } |
561 | 561 | ||
562 | static struct file_operations hwicap_fops = { | 562 | static const struct file_operations hwicap_fops = { |
563 | .owner = THIS_MODULE, | 563 | .owner = THIS_MODULE, |
564 | .write = hwicap_write, | 564 | .write = hwicap_write, |
565 | .read = hwicap_read, | 565 | .read = hwicap_read, |
diff --git a/drivers/connector/cn_proc.c b/drivers/connector/cn_proc.c index abf4a2529f80..60697909ebdb 100644 --- a/drivers/connector/cn_proc.c +++ b/drivers/connector/cn_proc.c | |||
@@ -227,7 +227,8 @@ static void cn_proc_ack(int err, int rcvd_seq, int rcvd_ack) | |||
227 | * cn_proc_mcast_ctl | 227 | * cn_proc_mcast_ctl |
228 | * @data: message sent from userspace via the connector | 228 | * @data: message sent from userspace via the connector |
229 | */ | 229 | */ |
230 | static void cn_proc_mcast_ctl(struct cn_msg *msg) | 230 | static void cn_proc_mcast_ctl(struct cn_msg *msg, |
231 | struct netlink_skb_parms *nsp) | ||
231 | { | 232 | { |
232 | enum proc_cn_mcast_op *mc_op = NULL; | 233 | enum proc_cn_mcast_op *mc_op = NULL; |
233 | int err = 0; | 234 | int err = 0; |
diff --git a/drivers/connector/cn_queue.c b/drivers/connector/cn_queue.c index 4a1dfe1f4ba9..210338ea222f 100644 --- a/drivers/connector/cn_queue.c +++ b/drivers/connector/cn_queue.c | |||
@@ -78,18 +78,20 @@ void cn_queue_wrapper(struct work_struct *work) | |||
78 | struct cn_callback_entry *cbq = | 78 | struct cn_callback_entry *cbq = |
79 | container_of(work, struct cn_callback_entry, work); | 79 | container_of(work, struct cn_callback_entry, work); |
80 | struct cn_callback_data *d = &cbq->data; | 80 | struct cn_callback_data *d = &cbq->data; |
81 | struct cn_msg *msg = NLMSG_DATA(nlmsg_hdr(d->skb)); | ||
82 | struct netlink_skb_parms *nsp = &NETLINK_CB(d->skb); | ||
81 | 83 | ||
82 | d->callback(d->callback_priv); | 84 | d->callback(msg, nsp); |
83 | 85 | ||
84 | d->destruct_data(d->ddata); | 86 | kfree_skb(d->skb); |
85 | d->ddata = NULL; | 87 | d->skb = NULL; |
86 | 88 | ||
87 | kfree(d->free); | 89 | kfree(d->free); |
88 | } | 90 | } |
89 | 91 | ||
90 | static struct cn_callback_entry * | 92 | static struct cn_callback_entry * |
91 | cn_queue_alloc_callback_entry(char *name, struct cb_id *id, | 93 | cn_queue_alloc_callback_entry(char *name, struct cb_id *id, |
92 | void (*callback)(struct cn_msg *)) | 94 | void (*callback)(struct cn_msg *, struct netlink_skb_parms *)) |
93 | { | 95 | { |
94 | struct cn_callback_entry *cbq; | 96 | struct cn_callback_entry *cbq; |
95 | 97 | ||
@@ -123,7 +125,7 @@ int cn_cb_equal(struct cb_id *i1, struct cb_id *i2) | |||
123 | } | 125 | } |
124 | 126 | ||
125 | int cn_queue_add_callback(struct cn_queue_dev *dev, char *name, struct cb_id *id, | 127 | int cn_queue_add_callback(struct cn_queue_dev *dev, char *name, struct cb_id *id, |
126 | void (*callback)(struct cn_msg *)) | 128 | void (*callback)(struct cn_msg *, struct netlink_skb_parms *)) |
127 | { | 129 | { |
128 | struct cn_callback_entry *cbq, *__cbq; | 130 | struct cn_callback_entry *cbq, *__cbq; |
129 | int found = 0; | 131 | int found = 0; |
diff --git a/drivers/connector/connector.c b/drivers/connector/connector.c index 74f52af79563..f06024668f99 100644 --- a/drivers/connector/connector.c +++ b/drivers/connector/connector.c | |||
@@ -129,21 +129,19 @@ EXPORT_SYMBOL_GPL(cn_netlink_send); | |||
129 | /* | 129 | /* |
130 | * Callback helper - queues work and setup destructor for given data. | 130 | * Callback helper - queues work and setup destructor for given data. |
131 | */ | 131 | */ |
132 | static int cn_call_callback(struct cn_msg *msg, void (*destruct_data)(void *), void *data) | 132 | static int cn_call_callback(struct sk_buff *skb) |
133 | { | 133 | { |
134 | struct cn_callback_entry *__cbq, *__new_cbq; | 134 | struct cn_callback_entry *__cbq, *__new_cbq; |
135 | struct cn_dev *dev = &cdev; | 135 | struct cn_dev *dev = &cdev; |
136 | struct cn_msg *msg = NLMSG_DATA(nlmsg_hdr(skb)); | ||
136 | int err = -ENODEV; | 137 | int err = -ENODEV; |
137 | 138 | ||
138 | spin_lock_bh(&dev->cbdev->queue_lock); | 139 | spin_lock_bh(&dev->cbdev->queue_lock); |
139 | list_for_each_entry(__cbq, &dev->cbdev->queue_list, callback_entry) { | 140 | list_for_each_entry(__cbq, &dev->cbdev->queue_list, callback_entry) { |
140 | if (cn_cb_equal(&__cbq->id.id, &msg->id)) { | 141 | if (cn_cb_equal(&__cbq->id.id, &msg->id)) { |
141 | if (likely(!work_pending(&__cbq->work) && | 142 | if (likely(!work_pending(&__cbq->work) && |
142 | __cbq->data.ddata == NULL)) { | 143 | __cbq->data.skb == NULL)) { |
143 | __cbq->data.callback_priv = msg; | 144 | __cbq->data.skb = skb; |
144 | |||
145 | __cbq->data.ddata = data; | ||
146 | __cbq->data.destruct_data = destruct_data; | ||
147 | 145 | ||
148 | if (queue_cn_work(__cbq, &__cbq->work)) | 146 | if (queue_cn_work(__cbq, &__cbq->work)) |
149 | err = 0; | 147 | err = 0; |
@@ -156,10 +154,8 @@ static int cn_call_callback(struct cn_msg *msg, void (*destruct_data)(void *), v | |||
156 | __new_cbq = kzalloc(sizeof(struct cn_callback_entry), GFP_ATOMIC); | 154 | __new_cbq = kzalloc(sizeof(struct cn_callback_entry), GFP_ATOMIC); |
157 | if (__new_cbq) { | 155 | if (__new_cbq) { |
158 | d = &__new_cbq->data; | 156 | d = &__new_cbq->data; |
159 | d->callback_priv = msg; | 157 | d->skb = skb; |
160 | d->callback = __cbq->data.callback; | 158 | d->callback = __cbq->data.callback; |
161 | d->ddata = data; | ||
162 | d->destruct_data = destruct_data; | ||
163 | d->free = __new_cbq; | 159 | d->free = __new_cbq; |
164 | 160 | ||
165 | __new_cbq->pdev = __cbq->pdev; | 161 | __new_cbq->pdev = __cbq->pdev; |
@@ -191,7 +187,6 @@ static int cn_call_callback(struct cn_msg *msg, void (*destruct_data)(void *), v | |||
191 | */ | 187 | */ |
192 | static void cn_rx_skb(struct sk_buff *__skb) | 188 | static void cn_rx_skb(struct sk_buff *__skb) |
193 | { | 189 | { |
194 | struct cn_msg *msg; | ||
195 | struct nlmsghdr *nlh; | 190 | struct nlmsghdr *nlh; |
196 | int err; | 191 | int err; |
197 | struct sk_buff *skb; | 192 | struct sk_buff *skb; |
@@ -208,8 +203,7 @@ static void cn_rx_skb(struct sk_buff *__skb) | |||
208 | return; | 203 | return; |
209 | } | 204 | } |
210 | 205 | ||
211 | msg = NLMSG_DATA(nlh); | 206 | err = cn_call_callback(skb); |
212 | err = cn_call_callback(msg, (void (*)(void *))kfree_skb, skb); | ||
213 | if (err < 0) | 207 | if (err < 0) |
214 | kfree_skb(skb); | 208 | kfree_skb(skb); |
215 | } | 209 | } |
@@ -270,7 +264,7 @@ static void cn_notify(struct cb_id *id, u32 notify_event) | |||
270 | * May sleep. | 264 | * May sleep. |
271 | */ | 265 | */ |
272 | int cn_add_callback(struct cb_id *id, char *name, | 266 | int cn_add_callback(struct cb_id *id, char *name, |
273 | void (*callback)(struct cn_msg *)) | 267 | void (*callback)(struct cn_msg *, struct netlink_skb_parms *)) |
274 | { | 268 | { |
275 | int err; | 269 | int err; |
276 | struct cn_dev *dev = &cdev; | 270 | struct cn_dev *dev = &cdev; |
@@ -352,7 +346,7 @@ static int cn_ctl_msg_equals(struct cn_ctl_msg *m1, struct cn_ctl_msg *m2) | |||
352 | * | 346 | * |
353 | * Used for notification of a request's processing. | 347 | * Used for notification of a request's processing. |
354 | */ | 348 | */ |
355 | static void cn_callback(struct cn_msg *msg) | 349 | static void cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) |
356 | { | 350 | { |
357 | struct cn_ctl_msg *ctl; | 351 | struct cn_ctl_msg *ctl; |
358 | struct cn_ctl_entry *ent; | 352 | struct cn_ctl_entry *ent; |
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c index 4e551e63b6dc..4f4ac82382f7 100644 --- a/drivers/edac/amd64_edac.c +++ b/drivers/edac/amd64_edac.c | |||
@@ -15,8 +15,8 @@ module_param(ecc_enable_override, int, 0644); | |||
15 | 15 | ||
16 | /* Lookup table for all possible MC control instances */ | 16 | /* Lookup table for all possible MC control instances */ |
17 | struct amd64_pvt; | 17 | struct amd64_pvt; |
18 | static struct mem_ctl_info *mci_lookup[MAX_NUMNODES]; | 18 | static struct mem_ctl_info *mci_lookup[EDAC_MAX_NUMNODES]; |
19 | static struct amd64_pvt *pvt_lookup[MAX_NUMNODES]; | 19 | static struct amd64_pvt *pvt_lookup[EDAC_MAX_NUMNODES]; |
20 | 20 | ||
21 | /* | 21 | /* |
22 | * See F2x80 for K8 and F2x[1,0]80 for Fam10 and later. The table below is only | 22 | * See F2x80 for K8 and F2x[1,0]80 for Fam10 and later. The table below is only |
@@ -189,7 +189,10 @@ static int amd64_get_scrub_rate(struct mem_ctl_info *mci, u32 *bw) | |||
189 | /* Map from a CSROW entry to the mask entry that operates on it */ | 189 | /* Map from a CSROW entry to the mask entry that operates on it */ |
190 | static inline u32 amd64_map_to_dcs_mask(struct amd64_pvt *pvt, int csrow) | 190 | static inline u32 amd64_map_to_dcs_mask(struct amd64_pvt *pvt, int csrow) |
191 | { | 191 | { |
192 | return csrow >> (pvt->num_dcsm >> 3); | 192 | if (boot_cpu_data.x86 == 0xf && pvt->ext_model < OPTERON_CPU_REV_F) |
193 | return csrow; | ||
194 | else | ||
195 | return csrow >> 1; | ||
193 | } | 196 | } |
194 | 197 | ||
195 | /* return the 'base' address the i'th CS entry of the 'dct' DRAM controller */ | 198 | /* return the 'base' address the i'th CS entry of the 'dct' DRAM controller */ |
@@ -279,29 +282,26 @@ static struct mem_ctl_info *find_mc_by_sys_addr(struct mem_ctl_info *mci, | |||
279 | intlv_en = pvt->dram_IntlvEn[0]; | 282 | intlv_en = pvt->dram_IntlvEn[0]; |
280 | 283 | ||
281 | if (intlv_en == 0) { | 284 | if (intlv_en == 0) { |
282 | for (node_id = 0; ; ) { | 285 | for (node_id = 0; node_id < DRAM_REG_COUNT; node_id++) { |
283 | if (amd64_base_limit_match(pvt, sys_addr, node_id)) | 286 | if (amd64_base_limit_match(pvt, sys_addr, node_id)) |
284 | break; | 287 | goto found; |
285 | |||
286 | if (++node_id >= DRAM_REG_COUNT) | ||
287 | goto err_no_match; | ||
288 | } | 288 | } |
289 | goto found; | 289 | goto err_no_match; |
290 | } | 290 | } |
291 | 291 | ||
292 | if (unlikely((intlv_en != (0x01 << 8)) && | 292 | if (unlikely((intlv_en != 0x01) && |
293 | (intlv_en != (0x03 << 8)) && | 293 | (intlv_en != 0x03) && |
294 | (intlv_en != (0x07 << 8)))) { | 294 | (intlv_en != 0x07))) { |
295 | amd64_printk(KERN_WARNING, "junk value of 0x%x extracted from " | 295 | amd64_printk(KERN_WARNING, "junk value of 0x%x extracted from " |
296 | "IntlvEn field of DRAM Base Register for node 0: " | 296 | "IntlvEn field of DRAM Base Register for node 0: " |
297 | "This probably indicates a BIOS bug.\n", intlv_en); | 297 | "this probably indicates a BIOS bug.\n", intlv_en); |
298 | return NULL; | 298 | return NULL; |
299 | } | 299 | } |
300 | 300 | ||
301 | bits = (((u32) sys_addr) >> 12) & intlv_en; | 301 | bits = (((u32) sys_addr) >> 12) & intlv_en; |
302 | 302 | ||
303 | for (node_id = 0; ; ) { | 303 | for (node_id = 0; ; ) { |
304 | if ((pvt->dram_limit[node_id] & intlv_en) == bits) | 304 | if ((pvt->dram_IntlvSel[node_id] & intlv_en) == bits) |
305 | break; /* intlv_sel field matches */ | 305 | break; /* intlv_sel field matches */ |
306 | 306 | ||
307 | if (++node_id >= DRAM_REG_COUNT) | 307 | if (++node_id >= DRAM_REG_COUNT) |
@@ -311,10 +311,10 @@ static struct mem_ctl_info *find_mc_by_sys_addr(struct mem_ctl_info *mci, | |||
311 | /* sanity test for sys_addr */ | 311 | /* sanity test for sys_addr */ |
312 | if (unlikely(!amd64_base_limit_match(pvt, sys_addr, node_id))) { | 312 | if (unlikely(!amd64_base_limit_match(pvt, sys_addr, node_id))) { |
313 | amd64_printk(KERN_WARNING, | 313 | amd64_printk(KERN_WARNING, |
314 | "%s(): sys_addr 0x%lx falls outside base/limit " | 314 | "%s(): sys_addr 0x%llx falls outside base/limit " |
315 | "address range for node %d with node interleaving " | 315 | "address range for node %d with node interleaving " |
316 | "enabled.\n", __func__, (unsigned long)sys_addr, | 316 | "enabled.\n", |
317 | node_id); | 317 | __func__, sys_addr, node_id); |
318 | return NULL; | 318 | return NULL; |
319 | } | 319 | } |
320 | 320 | ||
@@ -377,7 +377,7 @@ static int input_addr_to_csrow(struct mem_ctl_info *mci, u64 input_addr) | |||
377 | * base/mask register pair, test the condition shown near the start of | 377 | * base/mask register pair, test the condition shown near the start of |
378 | * section 3.5.4 (p. 84, BKDG #26094, K8, revA-E). | 378 | * section 3.5.4 (p. 84, BKDG #26094, K8, revA-E). |
379 | */ | 379 | */ |
380 | for (csrow = 0; csrow < CHIPSELECT_COUNT; csrow++) { | 380 | for (csrow = 0; csrow < pvt->cs_count; csrow++) { |
381 | 381 | ||
382 | /* This DRAM chip select is disabled on this node */ | 382 | /* This DRAM chip select is disabled on this node */ |
383 | if ((pvt->dcsb0[csrow] & K8_DCSB_CS_ENABLE) == 0) | 383 | if ((pvt->dcsb0[csrow] & K8_DCSB_CS_ENABLE) == 0) |
@@ -734,7 +734,7 @@ static void find_csrow_limits(struct mem_ctl_info *mci, int csrow, | |||
734 | u64 base, mask; | 734 | u64 base, mask; |
735 | 735 | ||
736 | pvt = mci->pvt_info; | 736 | pvt = mci->pvt_info; |
737 | BUG_ON((csrow < 0) || (csrow >= CHIPSELECT_COUNT)); | 737 | BUG_ON((csrow < 0) || (csrow >= pvt->cs_count)); |
738 | 738 | ||
739 | base = base_from_dct_base(pvt, csrow); | 739 | base = base_from_dct_base(pvt, csrow); |
740 | mask = mask_from_dct_mask(pvt, csrow); | 740 | mask = mask_from_dct_mask(pvt, csrow); |
@@ -962,35 +962,27 @@ err_reg: | |||
962 | */ | 962 | */ |
963 | static void amd64_set_dct_base_and_mask(struct amd64_pvt *pvt) | 963 | static void amd64_set_dct_base_and_mask(struct amd64_pvt *pvt) |
964 | { | 964 | { |
965 | if (pvt->ext_model >= OPTERON_CPU_REV_F) { | 965 | |
966 | if (boot_cpu_data.x86 == 0xf && pvt->ext_model < OPTERON_CPU_REV_F) { | ||
967 | pvt->dcsb_base = REV_E_DCSB_BASE_BITS; | ||
968 | pvt->dcsm_mask = REV_E_DCSM_MASK_BITS; | ||
969 | pvt->dcs_mask_notused = REV_E_DCS_NOTUSED_BITS; | ||
970 | pvt->dcs_shift = REV_E_DCS_SHIFT; | ||
971 | pvt->cs_count = 8; | ||
972 | pvt->num_dcsm = 8; | ||
973 | } else { | ||
966 | pvt->dcsb_base = REV_F_F1Xh_DCSB_BASE_BITS; | 974 | pvt->dcsb_base = REV_F_F1Xh_DCSB_BASE_BITS; |
967 | pvt->dcsm_mask = REV_F_F1Xh_DCSM_MASK_BITS; | 975 | pvt->dcsm_mask = REV_F_F1Xh_DCSM_MASK_BITS; |
968 | pvt->dcs_mask_notused = REV_F_F1Xh_DCS_NOTUSED_BITS; | 976 | pvt->dcs_mask_notused = REV_F_F1Xh_DCS_NOTUSED_BITS; |
969 | pvt->dcs_shift = REV_F_F1Xh_DCS_SHIFT; | 977 | pvt->dcs_shift = REV_F_F1Xh_DCS_SHIFT; |
970 | 978 | ||
971 | switch (boot_cpu_data.x86) { | 979 | if (boot_cpu_data.x86 == 0x11) { |
972 | case 0xf: | 980 | pvt->cs_count = 4; |
973 | pvt->num_dcsm = REV_F_DCSM_COUNT; | 981 | pvt->num_dcsm = 2; |
974 | break; | 982 | } else { |
975 | 983 | pvt->cs_count = 8; | |
976 | case 0x10: | 984 | pvt->num_dcsm = 4; |
977 | pvt->num_dcsm = F10_DCSM_COUNT; | ||
978 | break; | ||
979 | |||
980 | case 0x11: | ||
981 | pvt->num_dcsm = F11_DCSM_COUNT; | ||
982 | break; | ||
983 | |||
984 | default: | ||
985 | amd64_printk(KERN_ERR, "Unsupported family!\n"); | ||
986 | break; | ||
987 | } | 985 | } |
988 | } else { | ||
989 | pvt->dcsb_base = REV_E_DCSB_BASE_BITS; | ||
990 | pvt->dcsm_mask = REV_E_DCSM_MASK_BITS; | ||
991 | pvt->dcs_mask_notused = REV_E_DCS_NOTUSED_BITS; | ||
992 | pvt->dcs_shift = REV_E_DCS_SHIFT; | ||
993 | pvt->num_dcsm = REV_E_DCSM_COUNT; | ||
994 | } | 986 | } |
995 | } | 987 | } |
996 | 988 | ||
@@ -1003,7 +995,7 @@ static void amd64_read_dct_base_mask(struct amd64_pvt *pvt) | |||
1003 | 995 | ||
1004 | amd64_set_dct_base_and_mask(pvt); | 996 | amd64_set_dct_base_and_mask(pvt); |
1005 | 997 | ||
1006 | for (cs = 0; cs < CHIPSELECT_COUNT; cs++) { | 998 | for (cs = 0; cs < pvt->cs_count; cs++) { |
1007 | reg = K8_DCSB0 + (cs * 4); | 999 | reg = K8_DCSB0 + (cs * 4); |
1008 | err = pci_read_config_dword(pvt->dram_f2_ctl, reg, | 1000 | err = pci_read_config_dword(pvt->dram_f2_ctl, reg, |
1009 | &pvt->dcsb0[cs]); | 1001 | &pvt->dcsb0[cs]); |
@@ -1130,7 +1122,7 @@ static void k8_read_dram_base_limit(struct amd64_pvt *pvt, int dram) | |||
1130 | debugf0("Reading K8_DRAM_BASE_LOW failed\n"); | 1122 | debugf0("Reading K8_DRAM_BASE_LOW failed\n"); |
1131 | 1123 | ||
1132 | /* Extract parts into separate data entries */ | 1124 | /* Extract parts into separate data entries */ |
1133 | pvt->dram_base[dram] = ((u64) low & 0xFFFF0000) << 8; | 1125 | pvt->dram_base[dram] = ((u64) low & 0xFFFF0000) << 24; |
1134 | pvt->dram_IntlvEn[dram] = (low >> 8) & 0x7; | 1126 | pvt->dram_IntlvEn[dram] = (low >> 8) & 0x7; |
1135 | pvt->dram_rw_en[dram] = (low & 0x3); | 1127 | pvt->dram_rw_en[dram] = (low & 0x3); |
1136 | 1128 | ||
@@ -1143,7 +1135,7 @@ static void k8_read_dram_base_limit(struct amd64_pvt *pvt, int dram) | |||
1143 | * Extract parts into separate data entries. Limit is the HIGHEST memory | 1135 | * Extract parts into separate data entries. Limit is the HIGHEST memory |
1144 | * location of the region, so lower 24 bits need to be all ones | 1136 | * location of the region, so lower 24 bits need to be all ones |
1145 | */ | 1137 | */ |
1146 | pvt->dram_limit[dram] = (((u64) low & 0xFFFF0000) << 8) | 0x00FFFFFF; | 1138 | pvt->dram_limit[dram] = (((u64) low & 0xFFFF0000) << 24) | 0x00FFFFFF; |
1147 | pvt->dram_IntlvSel[dram] = (low >> 8) & 0x7; | 1139 | pvt->dram_IntlvSel[dram] = (low >> 8) & 0x7; |
1148 | pvt->dram_DstNode[dram] = (low & 0x7); | 1140 | pvt->dram_DstNode[dram] = (low & 0x7); |
1149 | } | 1141 | } |
@@ -1193,7 +1185,7 @@ static void k8_map_sysaddr_to_csrow(struct mem_ctl_info *mci, | |||
1193 | * different from the node that detected the error. | 1185 | * different from the node that detected the error. |
1194 | */ | 1186 | */ |
1195 | src_mci = find_mc_by_sys_addr(mci, SystemAddress); | 1187 | src_mci = find_mc_by_sys_addr(mci, SystemAddress); |
1196 | if (src_mci) { | 1188 | if (!src_mci) { |
1197 | amd64_mc_printk(mci, KERN_ERR, | 1189 | amd64_mc_printk(mci, KERN_ERR, |
1198 | "failed to map error address 0x%lx to a node\n", | 1190 | "failed to map error address 0x%lx to a node\n", |
1199 | (unsigned long)SystemAddress); | 1191 | (unsigned long)SystemAddress); |
@@ -1376,8 +1368,8 @@ static void f10_read_dram_base_limit(struct amd64_pvt *pvt, int dram) | |||
1376 | 1368 | ||
1377 | pvt->dram_IntlvEn[dram] = (low_base >> 8) & 0x7; | 1369 | pvt->dram_IntlvEn[dram] = (low_base >> 8) & 0x7; |
1378 | 1370 | ||
1379 | pvt->dram_base[dram] = (((((u64) high_base & 0x000000FF) << 32) | | 1371 | pvt->dram_base[dram] = (((u64)high_base & 0x000000FF) << 40) | |
1380 | ((u64) low_base & 0xFFFF0000))) << 8; | 1372 | (((u64)low_base & 0xFFFF0000) << 24); |
1381 | 1373 | ||
1382 | low_offset = K8_DRAM_LIMIT_LOW + (dram << 3); | 1374 | low_offset = K8_DRAM_LIMIT_LOW + (dram << 3); |
1383 | high_offset = F10_DRAM_LIMIT_HIGH + (dram << 3); | 1375 | high_offset = F10_DRAM_LIMIT_HIGH + (dram << 3); |
@@ -1398,9 +1390,9 @@ static void f10_read_dram_base_limit(struct amd64_pvt *pvt, int dram) | |||
1398 | * Extract address values and form a LIMIT address. Limit is the HIGHEST | 1390 | * Extract address values and form a LIMIT address. Limit is the HIGHEST |
1399 | * memory location of the region, so low 24 bits need to be all ones. | 1391 | * memory location of the region, so low 24 bits need to be all ones. |
1400 | */ | 1392 | */ |
1401 | low_limit |= 0x0000FFFF; | 1393 | pvt->dram_limit[dram] = (((u64)high_limit & 0x000000FF) << 40) | |
1402 | pvt->dram_limit[dram] = | 1394 | (((u64) low_limit & 0xFFFF0000) << 24) | |
1403 | ((((u64) high_limit << 32) + (u64) low_limit) << 8) | (0xFF); | 1395 | 0x00FFFFFF; |
1404 | } | 1396 | } |
1405 | 1397 | ||
1406 | static void f10_read_dram_ctl_register(struct amd64_pvt *pvt) | 1398 | static void f10_read_dram_ctl_register(struct amd64_pvt *pvt) |
@@ -1566,7 +1558,7 @@ static int f10_lookup_addr_in_dct(u32 in_addr, u32 nid, u32 cs) | |||
1566 | 1558 | ||
1567 | debugf1("InputAddr=0x%x channelselect=%d\n", in_addr, cs); | 1559 | debugf1("InputAddr=0x%x channelselect=%d\n", in_addr, cs); |
1568 | 1560 | ||
1569 | for (csrow = 0; csrow < CHIPSELECT_COUNT; csrow++) { | 1561 | for (csrow = 0; csrow < pvt->cs_count; csrow++) { |
1570 | 1562 | ||
1571 | cs_base = amd64_get_dct_base(pvt, cs, csrow); | 1563 | cs_base = amd64_get_dct_base(pvt, cs, csrow); |
1572 | if (!(cs_base & K8_DCSB_CS_ENABLE)) | 1564 | if (!(cs_base & K8_DCSB_CS_ENABLE)) |
@@ -2497,7 +2489,7 @@ err_reg: | |||
2497 | * NOTE: CPU Revision Dependent code | 2489 | * NOTE: CPU Revision Dependent code |
2498 | * | 2490 | * |
2499 | * Input: | 2491 | * Input: |
2500 | * @csrow_nr ChipSelect Row Number (0..CHIPSELECT_COUNT-1) | 2492 | * @csrow_nr ChipSelect Row Number (0..pvt->cs_count-1) |
2501 | * k8 private pointer to --> | 2493 | * k8 private pointer to --> |
2502 | * DRAM Bank Address mapping register | 2494 | * DRAM Bank Address mapping register |
2503 | * node_id | 2495 | * node_id |
@@ -2577,7 +2569,7 @@ static int amd64_init_csrows(struct mem_ctl_info *mci) | |||
2577 | (pvt->nbcfg & K8_NBCFG_ECC_ENABLE) ? "Enabled" : "Disabled" | 2569 | (pvt->nbcfg & K8_NBCFG_ECC_ENABLE) ? "Enabled" : "Disabled" |
2578 | ); | 2570 | ); |
2579 | 2571 | ||
2580 | for (i = 0; i < CHIPSELECT_COUNT; i++) { | 2572 | for (i = 0; i < pvt->cs_count; i++) { |
2581 | csrow = &mci->csrows[i]; | 2573 | csrow = &mci->csrows[i]; |
2582 | 2574 | ||
2583 | if ((pvt->dcsb0[i] & K8_DCSB_CS_ENABLE) == 0) { | 2575 | if ((pvt->dcsb0[i] & K8_DCSB_CS_ENABLE) == 0) { |
@@ -2988,7 +2980,7 @@ static int amd64_init_2nd_stage(struct amd64_pvt *pvt) | |||
2988 | goto err_exit; | 2980 | goto err_exit; |
2989 | 2981 | ||
2990 | ret = -ENOMEM; | 2982 | ret = -ENOMEM; |
2991 | mci = edac_mc_alloc(0, CHIPSELECT_COUNT, pvt->channel_count, node_id); | 2983 | mci = edac_mc_alloc(0, pvt->cs_count, pvt->channel_count, node_id); |
2992 | if (!mci) | 2984 | if (!mci) |
2993 | goto err_exit; | 2985 | goto err_exit; |
2994 | 2986 | ||
diff --git a/drivers/edac/amd64_edac.h b/drivers/edac/amd64_edac.h index 8ea07e2715dc..c6f359a85207 100644 --- a/drivers/edac/amd64_edac.h +++ b/drivers/edac/amd64_edac.h | |||
@@ -132,6 +132,8 @@ | |||
132 | #define EDAC_AMD64_VERSION " Ver: 3.2.0 " __DATE__ | 132 | #define EDAC_AMD64_VERSION " Ver: 3.2.0 " __DATE__ |
133 | #define EDAC_MOD_STR "amd64_edac" | 133 | #define EDAC_MOD_STR "amd64_edac" |
134 | 134 | ||
135 | #define EDAC_MAX_NUMNODES 8 | ||
136 | |||
135 | /* Extended Model from CPUID, for CPU Revision numbers */ | 137 | /* Extended Model from CPUID, for CPU Revision numbers */ |
136 | #define OPTERON_CPU_LE_REV_C 0 | 138 | #define OPTERON_CPU_LE_REV_C 0 |
137 | #define OPTERON_CPU_REV_D 1 | 139 | #define OPTERON_CPU_REV_D 1 |
@@ -142,7 +144,7 @@ | |||
142 | #define OPTERON_CPU_REV_FA 5 | 144 | #define OPTERON_CPU_REV_FA 5 |
143 | 145 | ||
144 | /* Hardware limit on ChipSelect rows per MC and processors per system */ | 146 | /* Hardware limit on ChipSelect rows per MC and processors per system */ |
145 | #define CHIPSELECT_COUNT 8 | 147 | #define MAX_CS_COUNT 8 |
146 | #define DRAM_REG_COUNT 8 | 148 | #define DRAM_REG_COUNT 8 |
147 | 149 | ||
148 | 150 | ||
@@ -193,7 +195,6 @@ | |||
193 | */ | 195 | */ |
194 | #define REV_E_DCSB_BASE_BITS (0xFFE0FE00ULL) | 196 | #define REV_E_DCSB_BASE_BITS (0xFFE0FE00ULL) |
195 | #define REV_E_DCS_SHIFT 4 | 197 | #define REV_E_DCS_SHIFT 4 |
196 | #define REV_E_DCSM_COUNT 8 | ||
197 | 198 | ||
198 | #define REV_F_F1Xh_DCSB_BASE_BITS (0x1FF83FE0ULL) | 199 | #define REV_F_F1Xh_DCSB_BASE_BITS (0x1FF83FE0ULL) |
199 | #define REV_F_F1Xh_DCS_SHIFT 8 | 200 | #define REV_F_F1Xh_DCS_SHIFT 8 |
@@ -204,9 +205,6 @@ | |||
204 | */ | 205 | */ |
205 | #define REV_F_DCSB_BASE_BITS (0x1FF83FE0ULL) | 206 | #define REV_F_DCSB_BASE_BITS (0x1FF83FE0ULL) |
206 | #define REV_F_DCS_SHIFT 8 | 207 | #define REV_F_DCS_SHIFT 8 |
207 | #define REV_F_DCSM_COUNT 4 | ||
208 | #define F10_DCSM_COUNT 4 | ||
209 | #define F11_DCSM_COUNT 2 | ||
210 | 208 | ||
211 | /* DRAM CS Mask Registers */ | 209 | /* DRAM CS Mask Registers */ |
212 | #define K8_DCSM0 0x60 | 210 | #define K8_DCSM0 0x60 |
@@ -374,13 +372,11 @@ enum { | |||
374 | 372 | ||
375 | #define SET_NB_DRAM_INJECTION_WRITE(word, bits) \ | 373 | #define SET_NB_DRAM_INJECTION_WRITE(word, bits) \ |
376 | (BIT(((word) & 0xF) + 20) | \ | 374 | (BIT(((word) & 0xF) + 20) | \ |
377 | BIT(17) | \ | 375 | BIT(17) | bits) |
378 | ((bits) & 0xF)) | ||
379 | 376 | ||
380 | #define SET_NB_DRAM_INJECTION_READ(word, bits) \ | 377 | #define SET_NB_DRAM_INJECTION_READ(word, bits) \ |
381 | (BIT(((word) & 0xF) + 20) | \ | 378 | (BIT(((word) & 0xF) + 20) | \ |
382 | BIT(16) | \ | 379 | BIT(16) | bits) |
383 | ((bits) & 0xF)) | ||
384 | 380 | ||
385 | #define K8_NBCAP 0xE8 | 381 | #define K8_NBCAP 0xE8 |
386 | #define K8_NBCAP_CORES (BIT(12)|BIT(13)) | 382 | #define K8_NBCAP_CORES (BIT(12)|BIT(13)) |
@@ -445,12 +441,12 @@ struct amd64_pvt { | |||
445 | u32 dbam1; /* DRAM Base Address Mapping reg for DCT1 */ | 441 | u32 dbam1; /* DRAM Base Address Mapping reg for DCT1 */ |
446 | 442 | ||
447 | /* DRAM CS Base Address Registers F2x[1,0][5C:40] */ | 443 | /* DRAM CS Base Address Registers F2x[1,0][5C:40] */ |
448 | u32 dcsb0[CHIPSELECT_COUNT]; | 444 | u32 dcsb0[MAX_CS_COUNT]; |
449 | u32 dcsb1[CHIPSELECT_COUNT]; | 445 | u32 dcsb1[MAX_CS_COUNT]; |
450 | 446 | ||
451 | /* DRAM CS Mask Registers F2x[1,0][6C:60] */ | 447 | /* DRAM CS Mask Registers F2x[1,0][6C:60] */ |
452 | u32 dcsm0[CHIPSELECT_COUNT]; | 448 | u32 dcsm0[MAX_CS_COUNT]; |
453 | u32 dcsm1[CHIPSELECT_COUNT]; | 449 | u32 dcsm1[MAX_CS_COUNT]; |
454 | 450 | ||
455 | /* | 451 | /* |
456 | * Decoded parts of DRAM BASE and LIMIT Registers | 452 | * Decoded parts of DRAM BASE and LIMIT Registers |
@@ -470,6 +466,7 @@ struct amd64_pvt { | |||
470 | */ | 466 | */ |
471 | u32 dcsb_base; /* DCSB base bits */ | 467 | u32 dcsb_base; /* DCSB base bits */ |
472 | u32 dcsm_mask; /* DCSM mask bits */ | 468 | u32 dcsm_mask; /* DCSM mask bits */ |
469 | u32 cs_count; /* num chip selects (== num DCSB registers) */ | ||
473 | u32 num_dcsm; /* Number of DCSM registers */ | 470 | u32 num_dcsm; /* Number of DCSM registers */ |
474 | u32 dcs_mask_notused; /* DCSM notused mask bits */ | 471 | u32 dcs_mask_notused; /* DCSM notused mask bits */ |
475 | u32 dcs_shift; /* DCSB and DCSM shift value */ | 472 | u32 dcs_shift; /* DCSB and DCSM shift value */ |
diff --git a/drivers/edac/amd64_edac_inj.c b/drivers/edac/amd64_edac_inj.c index d3675b76b3a7..29f1f7a612d9 100644 --- a/drivers/edac/amd64_edac_inj.c +++ b/drivers/edac/amd64_edac_inj.c | |||
@@ -1,5 +1,11 @@ | |||
1 | #include "amd64_edac.h" | 1 | #include "amd64_edac.h" |
2 | 2 | ||
3 | static ssize_t amd64_inject_section_show(struct mem_ctl_info *mci, char *buf) | ||
4 | { | ||
5 | struct amd64_pvt *pvt = mci->pvt_info; | ||
6 | return sprintf(buf, "0x%x\n", pvt->injection.section); | ||
7 | } | ||
8 | |||
3 | /* | 9 | /* |
4 | * store error injection section value which refers to one of 4 16-byte sections | 10 | * store error injection section value which refers to one of 4 16-byte sections |
5 | * within a 64-byte cacheline | 11 | * within a 64-byte cacheline |
@@ -15,12 +21,26 @@ static ssize_t amd64_inject_section_store(struct mem_ctl_info *mci, | |||
15 | 21 | ||
16 | ret = strict_strtoul(data, 10, &value); | 22 | ret = strict_strtoul(data, 10, &value); |
17 | if (ret != -EINVAL) { | 23 | if (ret != -EINVAL) { |
24 | |||
25 | if (value > 3) { | ||
26 | amd64_printk(KERN_WARNING, | ||
27 | "%s: invalid section 0x%lx\n", | ||
28 | __func__, value); | ||
29 | return -EINVAL; | ||
30 | } | ||
31 | |||
18 | pvt->injection.section = (u32) value; | 32 | pvt->injection.section = (u32) value; |
19 | return count; | 33 | return count; |
20 | } | 34 | } |
21 | return ret; | 35 | return ret; |
22 | } | 36 | } |
23 | 37 | ||
38 | static ssize_t amd64_inject_word_show(struct mem_ctl_info *mci, char *buf) | ||
39 | { | ||
40 | struct amd64_pvt *pvt = mci->pvt_info; | ||
41 | return sprintf(buf, "0x%x\n", pvt->injection.word); | ||
42 | } | ||
43 | |||
24 | /* | 44 | /* |
25 | * store error injection word value which refers to one of 9 16-bit word of the | 45 | * store error injection word value which refers to one of 9 16-bit word of the |
26 | * 16-byte (128-bit + ECC bits) section | 46 | * 16-byte (128-bit + ECC bits) section |
@@ -37,14 +57,25 @@ static ssize_t amd64_inject_word_store(struct mem_ctl_info *mci, | |||
37 | ret = strict_strtoul(data, 10, &value); | 57 | ret = strict_strtoul(data, 10, &value); |
38 | if (ret != -EINVAL) { | 58 | if (ret != -EINVAL) { |
39 | 59 | ||
40 | value = (value <= 8) ? value : 0; | 60 | if (value > 8) { |
41 | pvt->injection.word = (u32) value; | 61 | amd64_printk(KERN_WARNING, |
62 | "%s: invalid word 0x%lx\n", | ||
63 | __func__, value); | ||
64 | return -EINVAL; | ||
65 | } | ||
42 | 66 | ||
67 | pvt->injection.word = (u32) value; | ||
43 | return count; | 68 | return count; |
44 | } | 69 | } |
45 | return ret; | 70 | return ret; |
46 | } | 71 | } |
47 | 72 | ||
73 | static ssize_t amd64_inject_ecc_vector_show(struct mem_ctl_info *mci, char *buf) | ||
74 | { | ||
75 | struct amd64_pvt *pvt = mci->pvt_info; | ||
76 | return sprintf(buf, "0x%x\n", pvt->injection.bit_map); | ||
77 | } | ||
78 | |||
48 | /* | 79 | /* |
49 | * store 16 bit error injection vector which enables injecting errors to the | 80 | * store 16 bit error injection vector which enables injecting errors to the |
50 | * corresponding bit within the error injection word above. When used during a | 81 | * corresponding bit within the error injection word above. When used during a |
@@ -60,8 +91,14 @@ static ssize_t amd64_inject_ecc_vector_store(struct mem_ctl_info *mci, | |||
60 | ret = strict_strtoul(data, 16, &value); | 91 | ret = strict_strtoul(data, 16, &value); |
61 | if (ret != -EINVAL) { | 92 | if (ret != -EINVAL) { |
62 | 93 | ||
63 | pvt->injection.bit_map = (u32) value & 0xFFFF; | 94 | if (value & 0xFFFF0000) { |
95 | amd64_printk(KERN_WARNING, | ||
96 | "%s: invalid EccVector: 0x%lx\n", | ||
97 | __func__, value); | ||
98 | return -EINVAL; | ||
99 | } | ||
64 | 100 | ||
101 | pvt->injection.bit_map = (u32) value; | ||
65 | return count; | 102 | return count; |
66 | } | 103 | } |
67 | return ret; | 104 | return ret; |
@@ -147,7 +184,7 @@ struct mcidev_sysfs_attribute amd64_inj_attrs[] = { | |||
147 | .name = "inject_section", | 184 | .name = "inject_section", |
148 | .mode = (S_IRUGO | S_IWUSR) | 185 | .mode = (S_IRUGO | S_IWUSR) |
149 | }, | 186 | }, |
150 | .show = NULL, | 187 | .show = amd64_inject_section_show, |
151 | .store = amd64_inject_section_store, | 188 | .store = amd64_inject_section_store, |
152 | }, | 189 | }, |
153 | { | 190 | { |
@@ -155,7 +192,7 @@ struct mcidev_sysfs_attribute amd64_inj_attrs[] = { | |||
155 | .name = "inject_word", | 192 | .name = "inject_word", |
156 | .mode = (S_IRUGO | S_IWUSR) | 193 | .mode = (S_IRUGO | S_IWUSR) |
157 | }, | 194 | }, |
158 | .show = NULL, | 195 | .show = amd64_inject_word_show, |
159 | .store = amd64_inject_word_store, | 196 | .store = amd64_inject_word_store, |
160 | }, | 197 | }, |
161 | { | 198 | { |
@@ -163,7 +200,7 @@ struct mcidev_sysfs_attribute amd64_inj_attrs[] = { | |||
163 | .name = "inject_ecc_vector", | 200 | .name = "inject_ecc_vector", |
164 | .mode = (S_IRUGO | S_IWUSR) | 201 | .mode = (S_IRUGO | S_IWUSR) |
165 | }, | 202 | }, |
166 | .show = NULL, | 203 | .show = amd64_inject_ecc_vector_show, |
167 | .store = amd64_inject_ecc_vector_store, | 204 | .store = amd64_inject_ecc_vector_store, |
168 | }, | 205 | }, |
169 | { | 206 | { |
diff --git a/drivers/firewire/core-cdev.c b/drivers/firewire/core-cdev.c index ced186d7e9a9..5089331544ed 100644 --- a/drivers/firewire/core-cdev.c +++ b/drivers/firewire/core-cdev.c | |||
@@ -33,6 +33,7 @@ | |||
33 | #include <linux/mutex.h> | 33 | #include <linux/mutex.h> |
34 | #include <linux/poll.h> | 34 | #include <linux/poll.h> |
35 | #include <linux/preempt.h> | 35 | #include <linux/preempt.h> |
36 | #include <linux/sched.h> | ||
36 | #include <linux/spinlock.h> | 37 | #include <linux/spinlock.h> |
37 | #include <linux/time.h> | 38 | #include <linux/time.h> |
38 | #include <linux/uaccess.h> | 39 | #include <linux/uaccess.h> |
diff --git a/drivers/firmware/iscsi_ibft.c b/drivers/firmware/iscsi_ibft.c index 420a96e7f2db..051d1ebbd287 100644 --- a/drivers/firmware/iscsi_ibft.c +++ b/drivers/firmware/iscsi_ibft.c | |||
@@ -939,7 +939,7 @@ static int __init ibft_init(void) | |||
939 | 939 | ||
940 | if (ibft_addr) { | 940 | if (ibft_addr) { |
941 | printk(KERN_INFO "iBFT detected at 0x%llx.\n", | 941 | printk(KERN_INFO "iBFT detected at 0x%llx.\n", |
942 | (u64)virt_to_phys((void *)ibft_addr)); | 942 | (u64)isa_virt_to_bus(ibft_addr)); |
943 | 943 | ||
944 | rc = ibft_check_device(); | 944 | rc = ibft_check_device(); |
945 | if (rc) | 945 | if (rc) |
diff --git a/drivers/firmware/iscsi_ibft_find.c b/drivers/firmware/iscsi_ibft_find.c index d53fbbfefa3e..dfb15c06c88f 100644 --- a/drivers/firmware/iscsi_ibft_find.c +++ b/drivers/firmware/iscsi_ibft_find.c | |||
@@ -65,10 +65,10 @@ void __init reserve_ibft_region(void) | |||
65 | * so skip that area */ | 65 | * so skip that area */ |
66 | if (pos == VGA_MEM) | 66 | if (pos == VGA_MEM) |
67 | pos += VGA_SIZE; | 67 | pos += VGA_SIZE; |
68 | virt = phys_to_virt(pos); | 68 | virt = isa_bus_to_virt(pos); |
69 | if (memcmp(virt, IBFT_SIGN, IBFT_SIGN_LEN) == 0) { | 69 | if (memcmp(virt, IBFT_SIGN, IBFT_SIGN_LEN) == 0) { |
70 | unsigned long *addr = | 70 | unsigned long *addr = |
71 | (unsigned long *)phys_to_virt(pos + 4); | 71 | (unsigned long *)isa_bus_to_virt(pos + 4); |
72 | len = *addr; | 72 | len = *addr; |
73 | /* if the length of the table extends past 1M, | 73 | /* if the length of the table extends past 1M, |
74 | * the table cannot be valid. */ | 74 | * the table cannot be valid. */ |
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index bb11a429394a..662ed923d9eb 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c | |||
@@ -1487,7 +1487,7 @@ static int gpiolib_open(struct inode *inode, struct file *file) | |||
1487 | return single_open(file, gpiolib_show, NULL); | 1487 | return single_open(file, gpiolib_show, NULL); |
1488 | } | 1488 | } |
1489 | 1489 | ||
1490 | static struct file_operations gpiolib_operations = { | 1490 | static const struct file_operations gpiolib_operations = { |
1491 | .open = gpiolib_open, | 1491 | .open = gpiolib_open, |
1492 | .read = seq_read, | 1492 | .read = seq_read, |
1493 | .llseek = seq_lseek, | 1493 | .llseek = seq_lseek, |
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c index 8e7b0ebece0c..5cae0b3eee9b 100644 --- a/drivers/gpu/drm/drm_crtc.c +++ b/drivers/gpu/drm/drm_crtc.c | |||
@@ -1556,8 +1556,6 @@ int drm_mode_cursor_ioctl(struct drm_device *dev, | |||
1556 | struct drm_crtc *crtc; | 1556 | struct drm_crtc *crtc; |
1557 | int ret = 0; | 1557 | int ret = 0; |
1558 | 1558 | ||
1559 | DRM_DEBUG_KMS("\n"); | ||
1560 | |||
1561 | if (!req->flags) { | 1559 | if (!req->flags) { |
1562 | DRM_ERROR("no operation set\n"); | 1560 | DRM_ERROR("no operation set\n"); |
1563 | return -EINVAL; | 1561 | return -EINVAL; |
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index 819ddcbfcce5..23dc9c115fd9 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c | |||
@@ -454,6 +454,96 @@ out_free: | |||
454 | } | 454 | } |
455 | EXPORT_SYMBOL(drm_fb_helper_init_crtc_count); | 455 | EXPORT_SYMBOL(drm_fb_helper_init_crtc_count); |
456 | 456 | ||
457 | static void setcolreg(struct drm_crtc *crtc, u16 red, u16 green, | ||
458 | u16 blue, u16 regno, struct fb_info *info) | ||
459 | { | ||
460 | struct drm_fb_helper *fb_helper = info->par; | ||
461 | struct drm_framebuffer *fb = fb_helper->fb; | ||
462 | int pindex; | ||
463 | |||
464 | pindex = regno; | ||
465 | |||
466 | if (fb->bits_per_pixel == 16) { | ||
467 | pindex = regno << 3; | ||
468 | |||
469 | if (fb->depth == 16 && regno > 63) | ||
470 | return; | ||
471 | if (fb->depth == 15 && regno > 31) | ||
472 | return; | ||
473 | |||
474 | if (fb->depth == 16) { | ||
475 | u16 r, g, b; | ||
476 | int i; | ||
477 | if (regno < 32) { | ||
478 | for (i = 0; i < 8; i++) | ||
479 | fb_helper->funcs->gamma_set(crtc, red, | ||
480 | green, blue, pindex + i); | ||
481 | } | ||
482 | |||
483 | fb_helper->funcs->gamma_get(crtc, &r, | ||
484 | &g, &b, | ||
485 | pindex >> 1); | ||
486 | |||
487 | for (i = 0; i < 4; i++) | ||
488 | fb_helper->funcs->gamma_set(crtc, r, | ||
489 | green, b, | ||
490 | (pindex >> 1) + i); | ||
491 | } | ||
492 | } | ||
493 | |||
494 | if (fb->depth != 16) | ||
495 | fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex); | ||
496 | |||
497 | if (regno < 16 && info->fix.visual == FB_VISUAL_DIRECTCOLOR) { | ||
498 | ((u32 *) fb->pseudo_palette)[regno] = | ||
499 | (regno << info->var.red.offset) | | ||
500 | (regno << info->var.green.offset) | | ||
501 | (regno << info->var.blue.offset); | ||
502 | } | ||
503 | } | ||
504 | |||
505 | int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info) | ||
506 | { | ||
507 | struct drm_fb_helper *fb_helper = info->par; | ||
508 | struct drm_device *dev = fb_helper->dev; | ||
509 | u16 *red, *green, *blue, *transp; | ||
510 | struct drm_crtc *crtc; | ||
511 | int i, rc = 0; | ||
512 | int start; | ||
513 | |||
514 | list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { | ||
515 | struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; | ||
516 | for (i = 0; i < fb_helper->crtc_count; i++) { | ||
517 | if (crtc->base.id == fb_helper->crtc_info[i].crtc_id) | ||
518 | break; | ||
519 | } | ||
520 | if (i == fb_helper->crtc_count) | ||
521 | continue; | ||
522 | |||
523 | red = cmap->red; | ||
524 | green = cmap->green; | ||
525 | blue = cmap->blue; | ||
526 | transp = cmap->transp; | ||
527 | start = cmap->start; | ||
528 | |||
529 | for (i = 0; i < cmap->len; i++) { | ||
530 | u16 hred, hgreen, hblue, htransp = 0xffff; | ||
531 | |||
532 | hred = *red++; | ||
533 | hgreen = *green++; | ||
534 | hblue = *blue++; | ||
535 | |||
536 | if (transp) | ||
537 | htransp = *transp++; | ||
538 | |||
539 | setcolreg(crtc, hred, hgreen, hblue, start++, info); | ||
540 | } | ||
541 | crtc_funcs->load_lut(crtc); | ||
542 | } | ||
543 | return rc; | ||
544 | } | ||
545 | EXPORT_SYMBOL(drm_fb_helper_setcmap); | ||
546 | |||
457 | int drm_fb_helper_setcolreg(unsigned regno, | 547 | int drm_fb_helper_setcolreg(unsigned regno, |
458 | unsigned red, | 548 | unsigned red, |
459 | unsigned green, | 549 | unsigned green, |
@@ -466,9 +556,11 @@ int drm_fb_helper_setcolreg(unsigned regno, | |||
466 | struct drm_crtc *crtc; | 556 | struct drm_crtc *crtc; |
467 | int i; | 557 | int i; |
468 | 558 | ||
469 | list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { | 559 | if (regno > 255) |
470 | struct drm_framebuffer *fb = fb_helper->fb; | 560 | return 1; |
471 | 561 | ||
562 | list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { | ||
563 | struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; | ||
472 | for (i = 0; i < fb_helper->crtc_count; i++) { | 564 | for (i = 0; i < fb_helper->crtc_count; i++) { |
473 | if (crtc->base.id == fb_helper->crtc_info[i].crtc_id) | 565 | if (crtc->base.id == fb_helper->crtc_info[i].crtc_id) |
474 | break; | 566 | break; |
@@ -476,35 +568,9 @@ int drm_fb_helper_setcolreg(unsigned regno, | |||
476 | if (i == fb_helper->crtc_count) | 568 | if (i == fb_helper->crtc_count) |
477 | continue; | 569 | continue; |
478 | 570 | ||
479 | if (regno > 255) | ||
480 | return 1; | ||
481 | |||
482 | if (fb->depth == 8) { | ||
483 | fb_helper->funcs->gamma_set(crtc, red, green, blue, regno); | ||
484 | return 0; | ||
485 | } | ||
486 | 571 | ||
487 | if (regno < 16) { | 572 | setcolreg(crtc, red, green, blue, regno, info); |
488 | switch (fb->depth) { | 573 | crtc_funcs->load_lut(crtc); |
489 | case 15: | ||
490 | fb->pseudo_palette[regno] = ((red & 0xf800) >> 1) | | ||
491 | ((green & 0xf800) >> 6) | | ||
492 | ((blue & 0xf800) >> 11); | ||
493 | break; | ||
494 | case 16: | ||
495 | fb->pseudo_palette[regno] = (red & 0xf800) | | ||
496 | ((green & 0xfc00) >> 5) | | ||
497 | ((blue & 0xf800) >> 11); | ||
498 | break; | ||
499 | case 24: | ||
500 | case 32: | ||
501 | fb->pseudo_palette[regno] = | ||
502 | (((red >> 8) & 0xff) << info->var.red.offset) | | ||
503 | (((green >> 8) & 0xff) << info->var.green.offset) | | ||
504 | (((blue >> 8) & 0xff) << info->var.blue.offset); | ||
505 | break; | ||
506 | } | ||
507 | } | ||
508 | } | 574 | } |
509 | return 0; | 575 | return 0; |
510 | } | 576 | } |
@@ -674,6 +740,7 @@ int drm_fb_helper_pan_display(struct fb_var_screeninfo *var, | |||
674 | EXPORT_SYMBOL(drm_fb_helper_pan_display); | 740 | EXPORT_SYMBOL(drm_fb_helper_pan_display); |
675 | 741 | ||
676 | int drm_fb_helper_single_fb_probe(struct drm_device *dev, | 742 | int drm_fb_helper_single_fb_probe(struct drm_device *dev, |
743 | int preferred_bpp, | ||
677 | int (*fb_create)(struct drm_device *dev, | 744 | int (*fb_create)(struct drm_device *dev, |
678 | uint32_t fb_width, | 745 | uint32_t fb_width, |
679 | uint32_t fb_height, | 746 | uint32_t fb_height, |
@@ -696,6 +763,11 @@ int drm_fb_helper_single_fb_probe(struct drm_device *dev, | |||
696 | struct drm_fb_helper *fb_helper; | 763 | struct drm_fb_helper *fb_helper; |
697 | uint32_t surface_depth = 24, surface_bpp = 32; | 764 | uint32_t surface_depth = 24, surface_bpp = 32; |
698 | 765 | ||
766 | /* if driver picks 8 or 16 by default use that | ||
767 | for both depth/bpp */ | ||
768 | if (preferred_bpp != surface_bpp) { | ||
769 | surface_depth = surface_bpp = preferred_bpp; | ||
770 | } | ||
699 | /* first up get a count of crtcs now in use and new min/maxes width/heights */ | 771 | /* first up get a count of crtcs now in use and new min/maxes width/heights */ |
700 | list_for_each_entry(connector, &dev->mode_config.connector_list, head) { | 772 | list_for_each_entry(connector, &dev->mode_config.connector_list, head) { |
701 | struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private; | 773 | struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private; |
@@ -851,10 +923,12 @@ void drm_fb_helper_free(struct drm_fb_helper *helper) | |||
851 | } | 923 | } |
852 | EXPORT_SYMBOL(drm_fb_helper_free); | 924 | EXPORT_SYMBOL(drm_fb_helper_free); |
853 | 925 | ||
854 | void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch) | 926 | void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch, |
927 | uint32_t depth) | ||
855 | { | 928 | { |
856 | info->fix.type = FB_TYPE_PACKED_PIXELS; | 929 | info->fix.type = FB_TYPE_PACKED_PIXELS; |
857 | info->fix.visual = FB_VISUAL_TRUECOLOR; | 930 | info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR : |
931 | FB_VISUAL_DIRECTCOLOR; | ||
858 | info->fix.type_aux = 0; | 932 | info->fix.type_aux = 0; |
859 | info->fix.xpanstep = 1; /* doing it in hw */ | 933 | info->fix.xpanstep = 1; /* doing it in hw */ |
860 | info->fix.ypanstep = 1; /* doing it in hw */ | 934 | info->fix.ypanstep = 1; /* doing it in hw */ |
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 93ff6c03733e..ffa39671751f 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c | |||
@@ -3244,6 +3244,16 @@ void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | |||
3244 | intel_crtc->lut_b[regno] = blue >> 8; | 3244 | intel_crtc->lut_b[regno] = blue >> 8; |
3245 | } | 3245 | } |
3246 | 3246 | ||
3247 | void intel_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
3248 | u16 *blue, int regno) | ||
3249 | { | ||
3250 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); | ||
3251 | |||
3252 | *red = intel_crtc->lut_r[regno] << 8; | ||
3253 | *green = intel_crtc->lut_g[regno] << 8; | ||
3254 | *blue = intel_crtc->lut_b[regno] << 8; | ||
3255 | } | ||
3256 | |||
3247 | static void intel_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, | 3257 | static void intel_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, |
3248 | u16 *blue, uint32_t size) | 3258 | u16 *blue, uint32_t size) |
3249 | { | 3259 | { |
@@ -3835,6 +3845,7 @@ static const struct drm_crtc_helper_funcs intel_helper_funcs = { | |||
3835 | .mode_set_base = intel_pipe_set_base, | 3845 | .mode_set_base = intel_pipe_set_base, |
3836 | .prepare = intel_crtc_prepare, | 3846 | .prepare = intel_crtc_prepare, |
3837 | .commit = intel_crtc_commit, | 3847 | .commit = intel_crtc_commit, |
3848 | .load_lut = intel_crtc_load_lut, | ||
3838 | }; | 3849 | }; |
3839 | 3850 | ||
3840 | static const struct drm_crtc_funcs intel_crtc_funcs = { | 3851 | static const struct drm_crtc_funcs intel_crtc_funcs = { |
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 8aa4b7f30daa..ef61fe9507e2 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h | |||
@@ -175,6 +175,8 @@ extern int intelfb_resize(struct drm_device *dev, struct drm_crtc *crtc); | |||
175 | extern void intelfb_restore(void); | 175 | extern void intelfb_restore(void); |
176 | extern void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | 176 | extern void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, |
177 | u16 blue, int regno); | 177 | u16 blue, int regno); |
178 | extern void intel_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
179 | u16 *blue, int regno); | ||
178 | 180 | ||
179 | extern int intel_framebuffer_create(struct drm_device *dev, | 181 | extern int intel_framebuffer_create(struct drm_device *dev, |
180 | struct drm_mode_fb_cmd *mode_cmd, | 182 | struct drm_mode_fb_cmd *mode_cmd, |
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c index e85d7e9eed7d..2b0fe54cd92c 100644 --- a/drivers/gpu/drm/i915/intel_fb.c +++ b/drivers/gpu/drm/i915/intel_fb.c | |||
@@ -60,10 +60,12 @@ static struct fb_ops intelfb_ops = { | |||
60 | .fb_imageblit = cfb_imageblit, | 60 | .fb_imageblit = cfb_imageblit, |
61 | .fb_pan_display = drm_fb_helper_pan_display, | 61 | .fb_pan_display = drm_fb_helper_pan_display, |
62 | .fb_blank = drm_fb_helper_blank, | 62 | .fb_blank = drm_fb_helper_blank, |
63 | .fb_setcmap = drm_fb_helper_setcmap, | ||
63 | }; | 64 | }; |
64 | 65 | ||
65 | static struct drm_fb_helper_funcs intel_fb_helper_funcs = { | 66 | static struct drm_fb_helper_funcs intel_fb_helper_funcs = { |
66 | .gamma_set = intel_crtc_fb_gamma_set, | 67 | .gamma_set = intel_crtc_fb_gamma_set, |
68 | .gamma_get = intel_crtc_fb_gamma_get, | ||
67 | }; | 69 | }; |
68 | 70 | ||
69 | 71 | ||
@@ -123,6 +125,10 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width, | |||
123 | struct device *device = &dev->pdev->dev; | 125 | struct device *device = &dev->pdev->dev; |
124 | int size, ret, mmio_bar = IS_I9XX(dev) ? 0 : 1; | 126 | int size, ret, mmio_bar = IS_I9XX(dev) ? 0 : 1; |
125 | 127 | ||
128 | /* we don't do packed 24bpp */ | ||
129 | if (surface_bpp == 24) | ||
130 | surface_bpp = 32; | ||
131 | |||
126 | mode_cmd.width = surface_width; | 132 | mode_cmd.width = surface_width; |
127 | mode_cmd.height = surface_height; | 133 | mode_cmd.height = surface_height; |
128 | 134 | ||
@@ -206,7 +212,7 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width, | |||
206 | 212 | ||
207 | // memset(info->screen_base, 0, size); | 213 | // memset(info->screen_base, 0, size); |
208 | 214 | ||
209 | drm_fb_helper_fill_fix(info, fb->pitch); | 215 | drm_fb_helper_fill_fix(info, fb->pitch, fb->depth); |
210 | drm_fb_helper_fill_var(info, fb, fb_width, fb_height); | 216 | drm_fb_helper_fill_var(info, fb, fb_width, fb_height); |
211 | 217 | ||
212 | /* FIXME: we really shouldn't expose mmio space at all */ | 218 | /* FIXME: we really shouldn't expose mmio space at all */ |
@@ -244,7 +250,7 @@ int intelfb_probe(struct drm_device *dev) | |||
244 | int ret; | 250 | int ret; |
245 | 251 | ||
246 | DRM_DEBUG("\n"); | 252 | DRM_DEBUG("\n"); |
247 | ret = drm_fb_helper_single_fb_probe(dev, intelfb_create); | 253 | ret = drm_fb_helper_single_fb_probe(dev, 32, intelfb_create); |
248 | return ret; | 254 | return ret; |
249 | } | 255 | } |
250 | EXPORT_SYMBOL(intelfb_probe); | 256 | EXPORT_SYMBOL(intelfb_probe); |
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c index 6a015929deee..14fa9701aeb3 100644 --- a/drivers/gpu/drm/radeon/atombios_crtc.c +++ b/drivers/gpu/drm/radeon/atombios_crtc.c | |||
@@ -733,6 +733,7 @@ static const struct drm_crtc_helper_funcs atombios_helper_funcs = { | |||
733 | .mode_set_base = atombios_crtc_set_base, | 733 | .mode_set_base = atombios_crtc_set_base, |
734 | .prepare = atombios_crtc_prepare, | 734 | .prepare = atombios_crtc_prepare, |
735 | .commit = atombios_crtc_commit, | 735 | .commit = atombios_crtc_commit, |
736 | .load_lut = radeon_crtc_load_lut, | ||
736 | }; | 737 | }; |
737 | 738 | ||
738 | void radeon_atombios_init_crtc(struct drm_device *dev, | 739 | void radeon_atombios_init_crtc(struct drm_device *dev, |
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c index e6cce24de802..161094c07d94 100644 --- a/drivers/gpu/drm/radeon/r100.c +++ b/drivers/gpu/drm/radeon/r100.c | |||
@@ -32,6 +32,9 @@ | |||
32 | #include "radeon_reg.h" | 32 | #include "radeon_reg.h" |
33 | #include "radeon.h" | 33 | #include "radeon.h" |
34 | #include "r100d.h" | 34 | #include "r100d.h" |
35 | #include "rs100d.h" | ||
36 | #include "rv200d.h" | ||
37 | #include "rv250d.h" | ||
35 | 38 | ||
36 | #include <linux/firmware.h> | 39 | #include <linux/firmware.h> |
37 | #include <linux/platform_device.h> | 40 | #include <linux/platform_device.h> |
@@ -60,18 +63,7 @@ MODULE_FIRMWARE(FIRMWARE_R520); | |||
60 | 63 | ||
61 | /* This files gather functions specifics to: | 64 | /* This files gather functions specifics to: |
62 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 | 65 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 |
63 | * | ||
64 | * Some of these functions might be used by newer ASICs. | ||
65 | */ | 66 | */ |
66 | int r200_init(struct radeon_device *rdev); | ||
67 | void r100_hdp_reset(struct radeon_device *rdev); | ||
68 | void r100_gpu_init(struct radeon_device *rdev); | ||
69 | int r100_gui_wait_for_idle(struct radeon_device *rdev); | ||
70 | int r100_mc_wait_for_idle(struct radeon_device *rdev); | ||
71 | void r100_gpu_wait_for_vsync(struct radeon_device *rdev); | ||
72 | void r100_gpu_wait_for_vsync2(struct radeon_device *rdev); | ||
73 | int r100_debugfs_mc_info_init(struct radeon_device *rdev); | ||
74 | |||
75 | 67 | ||
76 | /* | 68 | /* |
77 | * PCI GART | 69 | * PCI GART |
@@ -152,136 +144,6 @@ void r100_pci_gart_fini(struct radeon_device *rdev) | |||
152 | radeon_gart_fini(rdev); | 144 | radeon_gart_fini(rdev); |
153 | } | 145 | } |
154 | 146 | ||
155 | |||
156 | /* | ||
157 | * MC | ||
158 | */ | ||
159 | void r100_mc_disable_clients(struct radeon_device *rdev) | ||
160 | { | ||
161 | uint32_t ov0_scale_cntl, crtc_ext_cntl, crtc_gen_cntl, crtc2_gen_cntl; | ||
162 | |||
163 | /* FIXME: is this function correct for rs100,rs200,rs300 ? */ | ||
164 | if (r100_gui_wait_for_idle(rdev)) { | ||
165 | printk(KERN_WARNING "Failed to wait GUI idle while " | ||
166 | "programming pipes. Bad things might happen.\n"); | ||
167 | } | ||
168 | |||
169 | /* stop display and memory access */ | ||
170 | ov0_scale_cntl = RREG32(RADEON_OV0_SCALE_CNTL); | ||
171 | WREG32(RADEON_OV0_SCALE_CNTL, ov0_scale_cntl & ~RADEON_SCALER_ENABLE); | ||
172 | crtc_ext_cntl = RREG32(RADEON_CRTC_EXT_CNTL); | ||
173 | WREG32(RADEON_CRTC_EXT_CNTL, crtc_ext_cntl | RADEON_CRTC_DISPLAY_DIS); | ||
174 | crtc_gen_cntl = RREG32(RADEON_CRTC_GEN_CNTL); | ||
175 | |||
176 | r100_gpu_wait_for_vsync(rdev); | ||
177 | |||
178 | WREG32(RADEON_CRTC_GEN_CNTL, | ||
179 | (crtc_gen_cntl & ~(RADEON_CRTC_CUR_EN | RADEON_CRTC_ICON_EN)) | | ||
180 | RADEON_CRTC_DISP_REQ_EN_B | RADEON_CRTC_EXT_DISP_EN); | ||
181 | |||
182 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { | ||
183 | crtc2_gen_cntl = RREG32(RADEON_CRTC2_GEN_CNTL); | ||
184 | |||
185 | r100_gpu_wait_for_vsync2(rdev); | ||
186 | WREG32(RADEON_CRTC2_GEN_CNTL, | ||
187 | (crtc2_gen_cntl & | ||
188 | ~(RADEON_CRTC2_CUR_EN | RADEON_CRTC2_ICON_EN)) | | ||
189 | RADEON_CRTC2_DISP_REQ_EN_B); | ||
190 | } | ||
191 | |||
192 | udelay(500); | ||
193 | } | ||
194 | |||
195 | void r100_mc_setup(struct radeon_device *rdev) | ||
196 | { | ||
197 | uint32_t tmp; | ||
198 | int r; | ||
199 | |||
200 | r = r100_debugfs_mc_info_init(rdev); | ||
201 | if (r) { | ||
202 | DRM_ERROR("Failed to register debugfs file for R100 MC !\n"); | ||
203 | } | ||
204 | /* Write VRAM size in case we are limiting it */ | ||
205 | WREG32(RADEON_CONFIG_MEMSIZE, rdev->mc.real_vram_size); | ||
206 | /* Novell bug 204882 for RN50/M6/M7 with 8/16/32MB VRAM, | ||
207 | * if the aperture is 64MB but we have 32MB VRAM | ||
208 | * we report only 32MB VRAM but we have to set MC_FB_LOCATION | ||
209 | * to 64MB, otherwise the gpu accidentially dies */ | ||
210 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
211 | tmp = REG_SET(RADEON_MC_FB_TOP, tmp >> 16); | ||
212 | tmp |= REG_SET(RADEON_MC_FB_START, rdev->mc.vram_location >> 16); | ||
213 | WREG32(RADEON_MC_FB_LOCATION, tmp); | ||
214 | |||
215 | /* Enable bus mastering */ | ||
216 | tmp = RREG32(RADEON_BUS_CNTL) & ~RADEON_BUS_MASTER_DIS; | ||
217 | WREG32(RADEON_BUS_CNTL, tmp); | ||
218 | |||
219 | if (rdev->flags & RADEON_IS_AGP) { | ||
220 | tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; | ||
221 | tmp = REG_SET(RADEON_MC_AGP_TOP, tmp >> 16); | ||
222 | tmp |= REG_SET(RADEON_MC_AGP_START, rdev->mc.gtt_location >> 16); | ||
223 | WREG32(RADEON_MC_AGP_LOCATION, tmp); | ||
224 | WREG32(RADEON_AGP_BASE, rdev->mc.agp_base); | ||
225 | } else { | ||
226 | WREG32(RADEON_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
227 | WREG32(RADEON_AGP_BASE, 0); | ||
228 | } | ||
229 | |||
230 | tmp = RREG32(RADEON_HOST_PATH_CNTL) & RADEON_HDP_APER_CNTL; | ||
231 | tmp |= (7 << 28); | ||
232 | WREG32(RADEON_HOST_PATH_CNTL, tmp | RADEON_HDP_SOFT_RESET | RADEON_HDP_READ_BUFFER_INVALIDATE); | ||
233 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
234 | WREG32(RADEON_HOST_PATH_CNTL, tmp); | ||
235 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
236 | } | ||
237 | |||
238 | int r100_mc_init(struct radeon_device *rdev) | ||
239 | { | ||
240 | int r; | ||
241 | |||
242 | if (r100_debugfs_rbbm_init(rdev)) { | ||
243 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
244 | } | ||
245 | |||
246 | r100_gpu_init(rdev); | ||
247 | /* Disable gart which also disable out of gart access */ | ||
248 | r100_pci_gart_disable(rdev); | ||
249 | |||
250 | /* Setup GPU memory space */ | ||
251 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
252 | if (rdev->flags & RADEON_IS_AGP) { | ||
253 | r = radeon_agp_init(rdev); | ||
254 | if (r) { | ||
255 | printk(KERN_WARNING "[drm] Disabling AGP\n"); | ||
256 | rdev->flags &= ~RADEON_IS_AGP; | ||
257 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | ||
258 | } else { | ||
259 | rdev->mc.gtt_location = rdev->mc.agp_base; | ||
260 | } | ||
261 | } | ||
262 | r = radeon_mc_setup(rdev); | ||
263 | if (r) { | ||
264 | return r; | ||
265 | } | ||
266 | |||
267 | r100_mc_disable_clients(rdev); | ||
268 | if (r100_mc_wait_for_idle(rdev)) { | ||
269 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
270 | "programming pipes. Bad things might happen.\n"); | ||
271 | } | ||
272 | |||
273 | r100_mc_setup(rdev); | ||
274 | return 0; | ||
275 | } | ||
276 | |||
277 | void r100_mc_fini(struct radeon_device *rdev) | ||
278 | { | ||
279 | } | ||
280 | |||
281 | |||
282 | /* | ||
283 | * Interrupts | ||
284 | */ | ||
285 | int r100_irq_set(struct radeon_device *rdev) | 147 | int r100_irq_set(struct radeon_device *rdev) |
286 | { | 148 | { |
287 | uint32_t tmp = 0; | 149 | uint32_t tmp = 0; |
@@ -358,10 +220,6 @@ u32 r100_get_vblank_counter(struct radeon_device *rdev, int crtc) | |||
358 | return RREG32(RADEON_CRTC2_CRNT_FRAME); | 220 | return RREG32(RADEON_CRTC2_CRNT_FRAME); |
359 | } | 221 | } |
360 | 222 | ||
361 | |||
362 | /* | ||
363 | * Fence emission | ||
364 | */ | ||
365 | void r100_fence_ring_emit(struct radeon_device *rdev, | 223 | void r100_fence_ring_emit(struct radeon_device *rdev, |
366 | struct radeon_fence *fence) | 224 | struct radeon_fence *fence) |
367 | { | 225 | { |
@@ -377,10 +235,6 @@ void r100_fence_ring_emit(struct radeon_device *rdev, | |||
377 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); | 235 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); |
378 | } | 236 | } |
379 | 237 | ||
380 | |||
381 | /* | ||
382 | * Writeback | ||
383 | */ | ||
384 | int r100_wb_init(struct radeon_device *rdev) | 238 | int r100_wb_init(struct radeon_device *rdev) |
385 | { | 239 | { |
386 | int r; | 240 | int r; |
@@ -504,10 +358,6 @@ int r100_copy_blit(struct radeon_device *rdev, | |||
504 | return r; | 358 | return r; |
505 | } | 359 | } |
506 | 360 | ||
507 | |||
508 | /* | ||
509 | * CP | ||
510 | */ | ||
511 | static int r100_cp_wait_for_idle(struct radeon_device *rdev) | 361 | static int r100_cp_wait_for_idle(struct radeon_device *rdev) |
512 | { | 362 | { |
513 | unsigned i; | 363 | unsigned i; |
@@ -612,6 +462,7 @@ static int r100_cp_init_microcode(struct radeon_device *rdev) | |||
612 | } | 462 | } |
613 | return err; | 463 | return err; |
614 | } | 464 | } |
465 | |||
615 | static void r100_cp_load_microcode(struct radeon_device *rdev) | 466 | static void r100_cp_load_microcode(struct radeon_device *rdev) |
616 | { | 467 | { |
617 | const __be32 *fw_data; | 468 | const __be32 *fw_data; |
@@ -978,7 +829,7 @@ int r100_cs_packet_parse_vline(struct radeon_cs_parser *p) | |||
978 | 829 | ||
979 | header = radeon_get_ib_value(p, h_idx); | 830 | header = radeon_get_ib_value(p, h_idx); |
980 | crtc_id = radeon_get_ib_value(p, h_idx + 5); | 831 | crtc_id = radeon_get_ib_value(p, h_idx + 5); |
981 | reg = header >> 2; | 832 | reg = CP_PACKET0_GET_REG(header); |
982 | mutex_lock(&p->rdev->ddev->mode_config.mutex); | 833 | mutex_lock(&p->rdev->ddev->mode_config.mutex); |
983 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); | 834 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); |
984 | if (!obj) { | 835 | if (!obj) { |
@@ -1990,7 +1841,7 @@ void r100_pll_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | |||
1990 | r100_pll_errata_after_data(rdev); | 1841 | r100_pll_errata_after_data(rdev); |
1991 | } | 1842 | } |
1992 | 1843 | ||
1993 | int r100_init(struct radeon_device *rdev) | 1844 | void r100_set_safe_registers(struct radeon_device *rdev) |
1994 | { | 1845 | { |
1995 | if (ASIC_IS_RN50(rdev)) { | 1846 | if (ASIC_IS_RN50(rdev)) { |
1996 | rdev->config.r100.reg_safe_bm = rn50_reg_safe_bm; | 1847 | rdev->config.r100.reg_safe_bm = rn50_reg_safe_bm; |
@@ -1999,9 +1850,8 @@ int r100_init(struct radeon_device *rdev) | |||
1999 | rdev->config.r100.reg_safe_bm = r100_reg_safe_bm; | 1850 | rdev->config.r100.reg_safe_bm = r100_reg_safe_bm; |
2000 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r100_reg_safe_bm); | 1851 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r100_reg_safe_bm); |
2001 | } else { | 1852 | } else { |
2002 | return r200_init(rdev); | 1853 | r200_set_safe_registers(rdev); |
2003 | } | 1854 | } |
2004 | return 0; | ||
2005 | } | 1855 | } |
2006 | 1856 | ||
2007 | /* | 1857 | /* |
@@ -2299,9 +2149,11 @@ void r100_bandwidth_update(struct radeon_device *rdev) | |||
2299 | mode1 = &rdev->mode_info.crtcs[0]->base.mode; | 2149 | mode1 = &rdev->mode_info.crtcs[0]->base.mode; |
2300 | pixel_bytes1 = rdev->mode_info.crtcs[0]->base.fb->bits_per_pixel / 8; | 2150 | pixel_bytes1 = rdev->mode_info.crtcs[0]->base.fb->bits_per_pixel / 8; |
2301 | } | 2151 | } |
2302 | if (rdev->mode_info.crtcs[1]->base.enabled) { | 2152 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { |
2303 | mode2 = &rdev->mode_info.crtcs[1]->base.mode; | 2153 | if (rdev->mode_info.crtcs[1]->base.enabled) { |
2304 | pixel_bytes2 = rdev->mode_info.crtcs[1]->base.fb->bits_per_pixel / 8; | 2154 | mode2 = &rdev->mode_info.crtcs[1]->base.mode; |
2155 | pixel_bytes2 = rdev->mode_info.crtcs[1]->base.fb->bits_per_pixel / 8; | ||
2156 | } | ||
2305 | } | 2157 | } |
2306 | 2158 | ||
2307 | min_mem_eff.full = rfixed_const_8(0); | 2159 | min_mem_eff.full = rfixed_const_8(0); |
@@ -3114,7 +2966,7 @@ void r100_mc_stop(struct radeon_device *rdev, struct r100_mc_save *save) | |||
3114 | WREG32(R_000740_CP_CSQ_CNTL, 0); | 2966 | WREG32(R_000740_CP_CSQ_CNTL, 0); |
3115 | 2967 | ||
3116 | /* Save few CRTC registers */ | 2968 | /* Save few CRTC registers */ |
3117 | save->GENMO_WT = RREG32(R_0003C0_GENMO_WT); | 2969 | save->GENMO_WT = RREG8(R_0003C2_GENMO_WT); |
3118 | save->CRTC_EXT_CNTL = RREG32(R_000054_CRTC_EXT_CNTL); | 2970 | save->CRTC_EXT_CNTL = RREG32(R_000054_CRTC_EXT_CNTL); |
3119 | save->CRTC_GEN_CNTL = RREG32(R_000050_CRTC_GEN_CNTL); | 2971 | save->CRTC_GEN_CNTL = RREG32(R_000050_CRTC_GEN_CNTL); |
3120 | save->CUR_OFFSET = RREG32(R_000260_CUR_OFFSET); | 2972 | save->CUR_OFFSET = RREG32(R_000260_CUR_OFFSET); |
@@ -3124,7 +2976,7 @@ void r100_mc_stop(struct radeon_device *rdev, struct r100_mc_save *save) | |||
3124 | } | 2976 | } |
3125 | 2977 | ||
3126 | /* Disable VGA aperture access */ | 2978 | /* Disable VGA aperture access */ |
3127 | WREG32(R_0003C0_GENMO_WT, C_0003C0_VGA_RAM_EN & save->GENMO_WT); | 2979 | WREG8(R_0003C2_GENMO_WT, C_0003C2_VGA_RAM_EN & save->GENMO_WT); |
3128 | /* Disable cursor, overlay, crtc */ | 2980 | /* Disable cursor, overlay, crtc */ |
3129 | WREG32(R_000260_CUR_OFFSET, save->CUR_OFFSET | S_000260_CUR_LOCK(1)); | 2981 | WREG32(R_000260_CUR_OFFSET, save->CUR_OFFSET | S_000260_CUR_LOCK(1)); |
3130 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL | | 2982 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL | |
@@ -3156,10 +3008,264 @@ void r100_mc_resume(struct radeon_device *rdev, struct r100_mc_save *save) | |||
3156 | rdev->mc.vram_location); | 3008 | rdev->mc.vram_location); |
3157 | } | 3009 | } |
3158 | /* Restore CRTC registers */ | 3010 | /* Restore CRTC registers */ |
3159 | WREG32(R_0003C0_GENMO_WT, save->GENMO_WT); | 3011 | WREG8(R_0003C2_GENMO_WT, save->GENMO_WT); |
3160 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL); | 3012 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL); |
3161 | WREG32(R_000050_CRTC_GEN_CNTL, save->CRTC_GEN_CNTL); | 3013 | WREG32(R_000050_CRTC_GEN_CNTL, save->CRTC_GEN_CNTL); |
3162 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { | 3014 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { |
3163 | WREG32(R_0003F8_CRTC2_GEN_CNTL, save->CRTC2_GEN_CNTL); | 3015 | WREG32(R_0003F8_CRTC2_GEN_CNTL, save->CRTC2_GEN_CNTL); |
3164 | } | 3016 | } |
3165 | } | 3017 | } |
3018 | |||
3019 | void r100_vga_render_disable(struct radeon_device *rdev) | ||
3020 | { | ||
3021 | u32 tmp; | ||
3022 | |||
3023 | tmp = RREG8(R_0003C2_GENMO_WT); | ||
3024 | WREG8(R_0003C2_GENMO_WT, C_0003C2_VGA_RAM_EN & tmp); | ||
3025 | } | ||
3026 | |||
3027 | static void r100_debugfs(struct radeon_device *rdev) | ||
3028 | { | ||
3029 | int r; | ||
3030 | |||
3031 | r = r100_debugfs_mc_info_init(rdev); | ||
3032 | if (r) | ||
3033 | dev_warn(rdev->dev, "Failed to create r100_mc debugfs file.\n"); | ||
3034 | } | ||
3035 | |||
3036 | static void r100_mc_program(struct radeon_device *rdev) | ||
3037 | { | ||
3038 | struct r100_mc_save save; | ||
3039 | |||
3040 | /* Stops all mc clients */ | ||
3041 | r100_mc_stop(rdev, &save); | ||
3042 | if (rdev->flags & RADEON_IS_AGP) { | ||
3043 | WREG32(R_00014C_MC_AGP_LOCATION, | ||
3044 | S_00014C_MC_AGP_START(rdev->mc.gtt_start >> 16) | | ||
3045 | S_00014C_MC_AGP_TOP(rdev->mc.gtt_end >> 16)); | ||
3046 | WREG32(R_000170_AGP_BASE, lower_32_bits(rdev->mc.agp_base)); | ||
3047 | if (rdev->family > CHIP_RV200) | ||
3048 | WREG32(R_00015C_AGP_BASE_2, | ||
3049 | upper_32_bits(rdev->mc.agp_base) & 0xff); | ||
3050 | } else { | ||
3051 | WREG32(R_00014C_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
3052 | WREG32(R_000170_AGP_BASE, 0); | ||
3053 | if (rdev->family > CHIP_RV200) | ||
3054 | WREG32(R_00015C_AGP_BASE_2, 0); | ||
3055 | } | ||
3056 | /* Wait for mc idle */ | ||
3057 | if (r100_mc_wait_for_idle(rdev)) | ||
3058 | dev_warn(rdev->dev, "Wait for MC idle timeout.\n"); | ||
3059 | /* Program MC, should be a 32bits limited address space */ | ||
3060 | WREG32(R_000148_MC_FB_LOCATION, | ||
3061 | S_000148_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
3062 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
3063 | r100_mc_resume(rdev, &save); | ||
3064 | } | ||
3065 | |||
3066 | void r100_clock_startup(struct radeon_device *rdev) | ||
3067 | { | ||
3068 | u32 tmp; | ||
3069 | |||
3070 | if (radeon_dynclks != -1 && radeon_dynclks) | ||
3071 | radeon_legacy_set_clock_gating(rdev, 1); | ||
3072 | /* We need to force on some of the block */ | ||
3073 | tmp = RREG32_PLL(R_00000D_SCLK_CNTL); | ||
3074 | tmp |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); | ||
3075 | if ((rdev->family == CHIP_RV250) || (rdev->family == CHIP_RV280)) | ||
3076 | tmp |= S_00000D_FORCE_DISP1(1) | S_00000D_FORCE_DISP2(1); | ||
3077 | WREG32_PLL(R_00000D_SCLK_CNTL, tmp); | ||
3078 | } | ||
3079 | |||
3080 | static int r100_startup(struct radeon_device *rdev) | ||
3081 | { | ||
3082 | int r; | ||
3083 | |||
3084 | r100_mc_program(rdev); | ||
3085 | /* Resume clock */ | ||
3086 | r100_clock_startup(rdev); | ||
3087 | /* Initialize GPU configuration (# pipes, ...) */ | ||
3088 | r100_gpu_init(rdev); | ||
3089 | /* Initialize GART (initialize after TTM so we can allocate | ||
3090 | * memory through TTM but finalize after TTM) */ | ||
3091 | if (rdev->flags & RADEON_IS_PCI) { | ||
3092 | r = r100_pci_gart_enable(rdev); | ||
3093 | if (r) | ||
3094 | return r; | ||
3095 | } | ||
3096 | /* Enable IRQ */ | ||
3097 | rdev->irq.sw_int = true; | ||
3098 | r100_irq_set(rdev); | ||
3099 | /* 1M ring buffer */ | ||
3100 | r = r100_cp_init(rdev, 1024 * 1024); | ||
3101 | if (r) { | ||
3102 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
3103 | return r; | ||
3104 | } | ||
3105 | r = r100_wb_init(rdev); | ||
3106 | if (r) | ||
3107 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
3108 | r = r100_ib_init(rdev); | ||
3109 | if (r) { | ||
3110 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
3111 | return r; | ||
3112 | } | ||
3113 | return 0; | ||
3114 | } | ||
3115 | |||
3116 | int r100_resume(struct radeon_device *rdev) | ||
3117 | { | ||
3118 | /* Make sur GART are not working */ | ||
3119 | if (rdev->flags & RADEON_IS_PCI) | ||
3120 | r100_pci_gart_disable(rdev); | ||
3121 | /* Resume clock before doing reset */ | ||
3122 | r100_clock_startup(rdev); | ||
3123 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
3124 | if (radeon_gpu_reset(rdev)) { | ||
3125 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
3126 | RREG32(R_000E40_RBBM_STATUS), | ||
3127 | RREG32(R_0007C0_CP_STAT)); | ||
3128 | } | ||
3129 | /* post */ | ||
3130 | radeon_combios_asic_init(rdev->ddev); | ||
3131 | /* Resume clock after posting */ | ||
3132 | r100_clock_startup(rdev); | ||
3133 | return r100_startup(rdev); | ||
3134 | } | ||
3135 | |||
3136 | int r100_suspend(struct radeon_device *rdev) | ||
3137 | { | ||
3138 | r100_cp_disable(rdev); | ||
3139 | r100_wb_disable(rdev); | ||
3140 | r100_irq_disable(rdev); | ||
3141 | if (rdev->flags & RADEON_IS_PCI) | ||
3142 | r100_pci_gart_disable(rdev); | ||
3143 | return 0; | ||
3144 | } | ||
3145 | |||
3146 | void r100_fini(struct radeon_device *rdev) | ||
3147 | { | ||
3148 | r100_suspend(rdev); | ||
3149 | r100_cp_fini(rdev); | ||
3150 | r100_wb_fini(rdev); | ||
3151 | r100_ib_fini(rdev); | ||
3152 | radeon_gem_fini(rdev); | ||
3153 | if (rdev->flags & RADEON_IS_PCI) | ||
3154 | r100_pci_gart_fini(rdev); | ||
3155 | radeon_irq_kms_fini(rdev); | ||
3156 | radeon_fence_driver_fini(rdev); | ||
3157 | radeon_object_fini(rdev); | ||
3158 | radeon_atombios_fini(rdev); | ||
3159 | kfree(rdev->bios); | ||
3160 | rdev->bios = NULL; | ||
3161 | } | ||
3162 | |||
3163 | int r100_mc_init(struct radeon_device *rdev) | ||
3164 | { | ||
3165 | int r; | ||
3166 | u32 tmp; | ||
3167 | |||
3168 | /* Setup GPU memory space */ | ||
3169 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
3170 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
3171 | if (rdev->flags & RADEON_IS_IGP) { | ||
3172 | tmp = G_00015C_MC_FB_START(RREG32(R_00015C_NB_TOM)); | ||
3173 | rdev->mc.vram_location = tmp << 16; | ||
3174 | } | ||
3175 | if (rdev->flags & RADEON_IS_AGP) { | ||
3176 | r = radeon_agp_init(rdev); | ||
3177 | if (r) { | ||
3178 | printk(KERN_WARNING "[drm] Disabling AGP\n"); | ||
3179 | rdev->flags &= ~RADEON_IS_AGP; | ||
3180 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | ||
3181 | } else { | ||
3182 | rdev->mc.gtt_location = rdev->mc.agp_base; | ||
3183 | } | ||
3184 | } | ||
3185 | r = radeon_mc_setup(rdev); | ||
3186 | if (r) | ||
3187 | return r; | ||
3188 | return 0; | ||
3189 | } | ||
3190 | |||
3191 | int r100_init(struct radeon_device *rdev) | ||
3192 | { | ||
3193 | int r; | ||
3194 | |||
3195 | /* Register debugfs file specific to this group of asics */ | ||
3196 | r100_debugfs(rdev); | ||
3197 | /* Disable VGA */ | ||
3198 | r100_vga_render_disable(rdev); | ||
3199 | /* Initialize scratch registers */ | ||
3200 | radeon_scratch_init(rdev); | ||
3201 | /* Initialize surface registers */ | ||
3202 | radeon_surface_init(rdev); | ||
3203 | /* TODO: disable VGA need to use VGA request */ | ||
3204 | /* BIOS*/ | ||
3205 | if (!radeon_get_bios(rdev)) { | ||
3206 | if (ASIC_IS_AVIVO(rdev)) | ||
3207 | return -EINVAL; | ||
3208 | } | ||
3209 | if (rdev->is_atom_bios) { | ||
3210 | dev_err(rdev->dev, "Expecting combios for RS400/RS480 GPU\n"); | ||
3211 | return -EINVAL; | ||
3212 | } else { | ||
3213 | r = radeon_combios_init(rdev); | ||
3214 | if (r) | ||
3215 | return r; | ||
3216 | } | ||
3217 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
3218 | if (radeon_gpu_reset(rdev)) { | ||
3219 | dev_warn(rdev->dev, | ||
3220 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
3221 | RREG32(R_000E40_RBBM_STATUS), | ||
3222 | RREG32(R_0007C0_CP_STAT)); | ||
3223 | } | ||
3224 | /* check if cards are posted or not */ | ||
3225 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
3226 | DRM_INFO("GPU not posted. posting now...\n"); | ||
3227 | radeon_combios_asic_init(rdev->ddev); | ||
3228 | } | ||
3229 | /* Set asic errata */ | ||
3230 | r100_errata(rdev); | ||
3231 | /* Initialize clocks */ | ||
3232 | radeon_get_clock_info(rdev->ddev); | ||
3233 | /* Get vram informations */ | ||
3234 | r100_vram_info(rdev); | ||
3235 | /* Initialize memory controller (also test AGP) */ | ||
3236 | r = r100_mc_init(rdev); | ||
3237 | if (r) | ||
3238 | return r; | ||
3239 | /* Fence driver */ | ||
3240 | r = radeon_fence_driver_init(rdev); | ||
3241 | if (r) | ||
3242 | return r; | ||
3243 | r = radeon_irq_kms_init(rdev); | ||
3244 | if (r) | ||
3245 | return r; | ||
3246 | /* Memory manager */ | ||
3247 | r = radeon_object_init(rdev); | ||
3248 | if (r) | ||
3249 | return r; | ||
3250 | if (rdev->flags & RADEON_IS_PCI) { | ||
3251 | r = r100_pci_gart_init(rdev); | ||
3252 | if (r) | ||
3253 | return r; | ||
3254 | } | ||
3255 | r100_set_safe_registers(rdev); | ||
3256 | rdev->accel_working = true; | ||
3257 | r = r100_startup(rdev); | ||
3258 | if (r) { | ||
3259 | /* Somethings want wront with the accel init stop accel */ | ||
3260 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
3261 | r100_suspend(rdev); | ||
3262 | r100_cp_fini(rdev); | ||
3263 | r100_wb_fini(rdev); | ||
3264 | r100_ib_fini(rdev); | ||
3265 | if (rdev->flags & RADEON_IS_PCI) | ||
3266 | r100_pci_gart_fini(rdev); | ||
3267 | radeon_irq_kms_fini(rdev); | ||
3268 | rdev->accel_working = false; | ||
3269 | } | ||
3270 | return 0; | ||
3271 | } | ||
diff --git a/drivers/gpu/drm/radeon/r100d.h b/drivers/gpu/drm/radeon/r100d.h index c4b257ec920e..df29a630c466 100644 --- a/drivers/gpu/drm/radeon/r100d.h +++ b/drivers/gpu/drm/radeon/r100d.h | |||
@@ -381,6 +381,24 @@ | |||
381 | #define S_000054_VCRTC_IDX_MASTER(x) (((x) & 0x7F) << 24) | 381 | #define S_000054_VCRTC_IDX_MASTER(x) (((x) & 0x7F) << 24) |
382 | #define G_000054_VCRTC_IDX_MASTER(x) (((x) >> 24) & 0x7F) | 382 | #define G_000054_VCRTC_IDX_MASTER(x) (((x) >> 24) & 0x7F) |
383 | #define C_000054_VCRTC_IDX_MASTER 0x80FFFFFF | 383 | #define C_000054_VCRTC_IDX_MASTER 0x80FFFFFF |
384 | #define R_000148_MC_FB_LOCATION 0x000148 | ||
385 | #define S_000148_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
386 | #define G_000148_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
387 | #define C_000148_MC_FB_START 0xFFFF0000 | ||
388 | #define S_000148_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
389 | #define G_000148_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
390 | #define C_000148_MC_FB_TOP 0x0000FFFF | ||
391 | #define R_00014C_MC_AGP_LOCATION 0x00014C | ||
392 | #define S_00014C_MC_AGP_START(x) (((x) & 0xFFFF) << 0) | ||
393 | #define G_00014C_MC_AGP_START(x) (((x) >> 0) & 0xFFFF) | ||
394 | #define C_00014C_MC_AGP_START 0xFFFF0000 | ||
395 | #define S_00014C_MC_AGP_TOP(x) (((x) & 0xFFFF) << 16) | ||
396 | #define G_00014C_MC_AGP_TOP(x) (((x) >> 16) & 0xFFFF) | ||
397 | #define C_00014C_MC_AGP_TOP 0x0000FFFF | ||
398 | #define R_000170_AGP_BASE 0x000170 | ||
399 | #define S_000170_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | ||
400 | #define G_000170_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | ||
401 | #define C_000170_AGP_BASE_ADDR 0x00000000 | ||
384 | #define R_00023C_DISPLAY_BASE_ADDR 0x00023C | 402 | #define R_00023C_DISPLAY_BASE_ADDR 0x00023C |
385 | #define S_00023C_DISPLAY_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | 403 | #define S_00023C_DISPLAY_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) |
386 | #define G_00023C_DISPLAY_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | 404 | #define G_00023C_DISPLAY_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) |
@@ -403,25 +421,25 @@ | |||
403 | #define S_000360_CUR2_LOCK(x) (((x) & 0x1) << 31) | 421 | #define S_000360_CUR2_LOCK(x) (((x) & 0x1) << 31) |
404 | #define G_000360_CUR2_LOCK(x) (((x) >> 31) & 0x1) | 422 | #define G_000360_CUR2_LOCK(x) (((x) >> 31) & 0x1) |
405 | #define C_000360_CUR2_LOCK 0x7FFFFFFF | 423 | #define C_000360_CUR2_LOCK 0x7FFFFFFF |
406 | #define R_0003C0_GENMO_WT 0x0003C0 | 424 | #define R_0003C2_GENMO_WT 0x0003C0 |
407 | #define S_0003C0_GENMO_MONO_ADDRESS_B(x) (((x) & 0x1) << 0) | 425 | #define S_0003C2_GENMO_MONO_ADDRESS_B(x) (((x) & 0x1) << 0) |
408 | #define G_0003C0_GENMO_MONO_ADDRESS_B(x) (((x) >> 0) & 0x1) | 426 | #define G_0003C2_GENMO_MONO_ADDRESS_B(x) (((x) >> 0) & 0x1) |
409 | #define C_0003C0_GENMO_MONO_ADDRESS_B 0xFFFFFFFE | 427 | #define C_0003C2_GENMO_MONO_ADDRESS_B 0xFE |
410 | #define S_0003C0_VGA_RAM_EN(x) (((x) & 0x1) << 1) | 428 | #define S_0003C2_VGA_RAM_EN(x) (((x) & 0x1) << 1) |
411 | #define G_0003C0_VGA_RAM_EN(x) (((x) >> 1) & 0x1) | 429 | #define G_0003C2_VGA_RAM_EN(x) (((x) >> 1) & 0x1) |
412 | #define C_0003C0_VGA_RAM_EN 0xFFFFFFFD | 430 | #define C_0003C2_VGA_RAM_EN 0xFD |
413 | #define S_0003C0_VGA_CKSEL(x) (((x) & 0x3) << 2) | 431 | #define S_0003C2_VGA_CKSEL(x) (((x) & 0x3) << 2) |
414 | #define G_0003C0_VGA_CKSEL(x) (((x) >> 2) & 0x3) | 432 | #define G_0003C2_VGA_CKSEL(x) (((x) >> 2) & 0x3) |
415 | #define C_0003C0_VGA_CKSEL 0xFFFFFFF3 | 433 | #define C_0003C2_VGA_CKSEL 0xF3 |
416 | #define S_0003C0_ODD_EVEN_MD_PGSEL(x) (((x) & 0x1) << 5) | 434 | #define S_0003C2_ODD_EVEN_MD_PGSEL(x) (((x) & 0x1) << 5) |
417 | #define G_0003C0_ODD_EVEN_MD_PGSEL(x) (((x) >> 5) & 0x1) | 435 | #define G_0003C2_ODD_EVEN_MD_PGSEL(x) (((x) >> 5) & 0x1) |
418 | #define C_0003C0_ODD_EVEN_MD_PGSEL 0xFFFFFFDF | 436 | #define C_0003C2_ODD_EVEN_MD_PGSEL 0xDF |
419 | #define S_0003C0_VGA_HSYNC_POL(x) (((x) & 0x1) << 6) | 437 | #define S_0003C2_VGA_HSYNC_POL(x) (((x) & 0x1) << 6) |
420 | #define G_0003C0_VGA_HSYNC_POL(x) (((x) >> 6) & 0x1) | 438 | #define G_0003C2_VGA_HSYNC_POL(x) (((x) >> 6) & 0x1) |
421 | #define C_0003C0_VGA_HSYNC_POL 0xFFFFFFBF | 439 | #define C_0003C2_VGA_HSYNC_POL 0xBF |
422 | #define S_0003C0_VGA_VSYNC_POL(x) (((x) & 0x1) << 7) | 440 | #define S_0003C2_VGA_VSYNC_POL(x) (((x) & 0x1) << 7) |
423 | #define G_0003C0_VGA_VSYNC_POL(x) (((x) >> 7) & 0x1) | 441 | #define G_0003C2_VGA_VSYNC_POL(x) (((x) >> 7) & 0x1) |
424 | #define C_0003C0_VGA_VSYNC_POL 0xFFFFFF7F | 442 | #define C_0003C2_VGA_VSYNC_POL 0x7F |
425 | #define R_0003F8_CRTC2_GEN_CNTL 0x0003F8 | 443 | #define R_0003F8_CRTC2_GEN_CNTL 0x0003F8 |
426 | #define S_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) & 0x1) << 0) | 444 | #define S_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) & 0x1) << 0) |
427 | #define G_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) >> 0) & 0x1) | 445 | #define G_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) >> 0) & 0x1) |
@@ -545,6 +563,46 @@ | |||
545 | #define S_000774_SCRATCH_ADDR(x) (((x) & 0x7FFFFFF) << 5) | 563 | #define S_000774_SCRATCH_ADDR(x) (((x) & 0x7FFFFFF) << 5) |
546 | #define G_000774_SCRATCH_ADDR(x) (((x) >> 5) & 0x7FFFFFF) | 564 | #define G_000774_SCRATCH_ADDR(x) (((x) >> 5) & 0x7FFFFFF) |
547 | #define C_000774_SCRATCH_ADDR 0x0000001F | 565 | #define C_000774_SCRATCH_ADDR 0x0000001F |
566 | #define R_0007C0_CP_STAT 0x0007C0 | ||
567 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
568 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
569 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
570 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
571 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
572 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
573 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
574 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
575 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
576 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
577 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
578 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
579 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
580 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
581 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
582 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
583 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
584 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
585 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
586 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
587 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
588 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
589 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
590 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
591 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
592 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
593 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
594 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
595 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
596 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
597 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
598 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
599 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
600 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
601 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
602 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
603 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
604 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
605 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
548 | #define R_000E40_RBBM_STATUS 0x000E40 | 606 | #define R_000E40_RBBM_STATUS 0x000E40 |
549 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | 607 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) |
550 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | 608 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) |
@@ -604,4 +662,53 @@ | |||
604 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | 662 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) |
605 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | 663 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF |
606 | 664 | ||
665 | |||
666 | #define R_00000D_SCLK_CNTL 0x00000D | ||
667 | #define S_00000D_SCLK_SRC_SEL(x) (((x) & 0x7) << 0) | ||
668 | #define G_00000D_SCLK_SRC_SEL(x) (((x) >> 0) & 0x7) | ||
669 | #define C_00000D_SCLK_SRC_SEL 0xFFFFFFF8 | ||
670 | #define S_00000D_TCLK_SRC_SEL(x) (((x) & 0x7) << 8) | ||
671 | #define G_00000D_TCLK_SRC_SEL(x) (((x) >> 8) & 0x7) | ||
672 | #define C_00000D_TCLK_SRC_SEL 0xFFFFF8FF | ||
673 | #define S_00000D_FORCE_CP(x) (((x) & 0x1) << 16) | ||
674 | #define G_00000D_FORCE_CP(x) (((x) >> 16) & 0x1) | ||
675 | #define C_00000D_FORCE_CP 0xFFFEFFFF | ||
676 | #define S_00000D_FORCE_HDP(x) (((x) & 0x1) << 17) | ||
677 | #define G_00000D_FORCE_HDP(x) (((x) >> 17) & 0x1) | ||
678 | #define C_00000D_FORCE_HDP 0xFFFDFFFF | ||
679 | #define S_00000D_FORCE_DISP(x) (((x) & 0x1) << 18) | ||
680 | #define G_00000D_FORCE_DISP(x) (((x) >> 18) & 0x1) | ||
681 | #define C_00000D_FORCE_DISP 0xFFFBFFFF | ||
682 | #define S_00000D_FORCE_TOP(x) (((x) & 0x1) << 19) | ||
683 | #define G_00000D_FORCE_TOP(x) (((x) >> 19) & 0x1) | ||
684 | #define C_00000D_FORCE_TOP 0xFFF7FFFF | ||
685 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | ||
686 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | ||
687 | #define C_00000D_FORCE_E2 0xFFEFFFFF | ||
688 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | ||
689 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | ||
690 | #define C_00000D_FORCE_SE 0xFFDFFFFF | ||
691 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | ||
692 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | ||
693 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | ||
694 | #define S_00000D_FORCE_VIP(x) (((x) & 0x1) << 23) | ||
695 | #define G_00000D_FORCE_VIP(x) (((x) >> 23) & 0x1) | ||
696 | #define C_00000D_FORCE_VIP 0xFF7FFFFF | ||
697 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | ||
698 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | ||
699 | #define C_00000D_FORCE_RE 0xFEFFFFFF | ||
700 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | ||
701 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | ||
702 | #define C_00000D_FORCE_PB 0xFDFFFFFF | ||
703 | #define S_00000D_FORCE_TAM(x) (((x) & 0x1) << 26) | ||
704 | #define G_00000D_FORCE_TAM(x) (((x) >> 26) & 0x1) | ||
705 | #define C_00000D_FORCE_TAM 0xFBFFFFFF | ||
706 | #define S_00000D_FORCE_TDM(x) (((x) & 0x1) << 27) | ||
707 | #define G_00000D_FORCE_TDM(x) (((x) >> 27) & 0x1) | ||
708 | #define C_00000D_FORCE_TDM 0xF7FFFFFF | ||
709 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | ||
710 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | ||
711 | #define C_00000D_FORCE_RB 0xEFFFFFFF | ||
712 | |||
713 | |||
607 | #endif | 714 | #endif |
diff --git a/drivers/gpu/drm/radeon/r200.c b/drivers/gpu/drm/radeon/r200.c index cf7fea5ff2e5..eb740fc3549f 100644 --- a/drivers/gpu/drm/radeon/r200.c +++ b/drivers/gpu/drm/radeon/r200.c | |||
@@ -447,9 +447,8 @@ int r200_packet0_check(struct radeon_cs_parser *p, | |||
447 | return 0; | 447 | return 0; |
448 | } | 448 | } |
449 | 449 | ||
450 | int r200_init(struct radeon_device *rdev) | 450 | void r200_set_safe_registers(struct radeon_device *rdev) |
451 | { | 451 | { |
452 | rdev->config.r100.reg_safe_bm = r200_reg_safe_bm; | 452 | rdev->config.r100.reg_safe_bm = r200_reg_safe_bm; |
453 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r200_reg_safe_bm); | 453 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r200_reg_safe_bm); |
454 | return 0; | ||
455 | } | 454 | } |
diff --git a/drivers/gpu/drm/radeon/r300.c b/drivers/gpu/drm/radeon/r300.c index 1ebea8cc8c93..e08c4a8974ca 100644 --- a/drivers/gpu/drm/radeon/r300.c +++ b/drivers/gpu/drm/radeon/r300.c | |||
@@ -33,43 +33,16 @@ | |||
33 | #include "radeon_drm.h" | 33 | #include "radeon_drm.h" |
34 | #include "r100_track.h" | 34 | #include "r100_track.h" |
35 | #include "r300d.h" | 35 | #include "r300d.h" |
36 | 36 | #include "rv350d.h" | |
37 | #include "r300_reg_safe.h" | 37 | #include "r300_reg_safe.h" |
38 | 38 | ||
39 | /* r300,r350,rv350,rv370,rv380 depends on : */ | 39 | /* This files gather functions specifics to: r300,r350,rv350,rv370,rv380 */ |
40 | void r100_hdp_reset(struct radeon_device *rdev); | ||
41 | int r100_cp_reset(struct radeon_device *rdev); | ||
42 | int r100_rb2d_reset(struct radeon_device *rdev); | ||
43 | int r100_cp_init(struct radeon_device *rdev, unsigned ring_size); | ||
44 | int r100_pci_gart_enable(struct radeon_device *rdev); | ||
45 | void r100_mc_setup(struct radeon_device *rdev); | ||
46 | void r100_mc_disable_clients(struct radeon_device *rdev); | ||
47 | int r100_gui_wait_for_idle(struct radeon_device *rdev); | ||
48 | int r100_cs_packet_parse(struct radeon_cs_parser *p, | ||
49 | struct radeon_cs_packet *pkt, | ||
50 | unsigned idx); | ||
51 | int r100_cs_packet_parse_vline(struct radeon_cs_parser *p); | ||
52 | int r100_cs_parse_packet0(struct radeon_cs_parser *p, | ||
53 | struct radeon_cs_packet *pkt, | ||
54 | const unsigned *auth, unsigned n, | ||
55 | radeon_packet0_check_t check); | ||
56 | int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p, | ||
57 | struct radeon_cs_packet *pkt, | ||
58 | struct radeon_object *robj); | ||
59 | |||
60 | /* This files gather functions specifics to: | ||
61 | * r300,r350,rv350,rv370,rv380 | ||
62 | * | ||
63 | * Some of these functions might be used by newer ASICs. | ||
64 | */ | ||
65 | void r300_gpu_init(struct radeon_device *rdev); | ||
66 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
67 | int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev); | ||
68 | |||
69 | 40 | ||
70 | /* | 41 | /* |
71 | * rv370,rv380 PCIE GART | 42 | * rv370,rv380 PCIE GART |
72 | */ | 43 | */ |
44 | static int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev); | ||
45 | |||
73 | void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev) | 46 | void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev) |
74 | { | 47 | { |
75 | uint32_t tmp; | 48 | uint32_t tmp; |
@@ -182,59 +155,6 @@ void rv370_pcie_gart_fini(struct radeon_device *rdev) | |||
182 | radeon_gart_fini(rdev); | 155 | radeon_gart_fini(rdev); |
183 | } | 156 | } |
184 | 157 | ||
185 | /* | ||
186 | * MC | ||
187 | */ | ||
188 | int r300_mc_init(struct radeon_device *rdev) | ||
189 | { | ||
190 | int r; | ||
191 | |||
192 | if (r100_debugfs_rbbm_init(rdev)) { | ||
193 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
194 | } | ||
195 | |||
196 | r300_gpu_init(rdev); | ||
197 | r100_pci_gart_disable(rdev); | ||
198 | if (rdev->flags & RADEON_IS_PCIE) { | ||
199 | rv370_pcie_gart_disable(rdev); | ||
200 | } | ||
201 | |||
202 | /* Setup GPU memory space */ | ||
203 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
204 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
205 | if (rdev->flags & RADEON_IS_AGP) { | ||
206 | r = radeon_agp_init(rdev); | ||
207 | if (r) { | ||
208 | printk(KERN_WARNING "[drm] Disabling AGP\n"); | ||
209 | rdev->flags &= ~RADEON_IS_AGP; | ||
210 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | ||
211 | } else { | ||
212 | rdev->mc.gtt_location = rdev->mc.agp_base; | ||
213 | } | ||
214 | } | ||
215 | r = radeon_mc_setup(rdev); | ||
216 | if (r) { | ||
217 | return r; | ||
218 | } | ||
219 | |||
220 | /* Program GPU memory space */ | ||
221 | r100_mc_disable_clients(rdev); | ||
222 | if (r300_mc_wait_for_idle(rdev)) { | ||
223 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
224 | "programming pipes. Bad things might happen.\n"); | ||
225 | } | ||
226 | r100_mc_setup(rdev); | ||
227 | return 0; | ||
228 | } | ||
229 | |||
230 | void r300_mc_fini(struct radeon_device *rdev) | ||
231 | { | ||
232 | } | ||
233 | |||
234 | |||
235 | /* | ||
236 | * Fence emission | ||
237 | */ | ||
238 | void r300_fence_ring_emit(struct radeon_device *rdev, | 158 | void r300_fence_ring_emit(struct radeon_device *rdev, |
239 | struct radeon_fence *fence) | 159 | struct radeon_fence *fence) |
240 | { | 160 | { |
@@ -260,10 +180,6 @@ void r300_fence_ring_emit(struct radeon_device *rdev, | |||
260 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); | 180 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); |
261 | } | 181 | } |
262 | 182 | ||
263 | |||
264 | /* | ||
265 | * Global GPU functions | ||
266 | */ | ||
267 | int r300_copy_dma(struct radeon_device *rdev, | 183 | int r300_copy_dma(struct radeon_device *rdev, |
268 | uint64_t src_offset, | 184 | uint64_t src_offset, |
269 | uint64_t dst_offset, | 185 | uint64_t dst_offset, |
@@ -582,11 +498,6 @@ void r300_vram_info(struct radeon_device *rdev) | |||
582 | r100_vram_init_sizes(rdev); | 498 | r100_vram_init_sizes(rdev); |
583 | } | 499 | } |
584 | 500 | ||
585 | |||
586 | /* | ||
587 | * PCIE Lanes | ||
588 | */ | ||
589 | |||
590 | void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes) | 501 | void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes) |
591 | { | 502 | { |
592 | uint32_t link_width_cntl, mask; | 503 | uint32_t link_width_cntl, mask; |
@@ -646,10 +557,6 @@ void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes) | |||
646 | 557 | ||
647 | } | 558 | } |
648 | 559 | ||
649 | |||
650 | /* | ||
651 | * Debugfs info | ||
652 | */ | ||
653 | #if defined(CONFIG_DEBUG_FS) | 560 | #if defined(CONFIG_DEBUG_FS) |
654 | static int rv370_debugfs_pcie_gart_info(struct seq_file *m, void *data) | 561 | static int rv370_debugfs_pcie_gart_info(struct seq_file *m, void *data) |
655 | { | 562 | { |
@@ -680,7 +587,7 @@ static struct drm_info_list rv370_pcie_gart_info_list[] = { | |||
680 | }; | 587 | }; |
681 | #endif | 588 | #endif |
682 | 589 | ||
683 | int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | 590 | static int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev) |
684 | { | 591 | { |
685 | #if defined(CONFIG_DEBUG_FS) | 592 | #if defined(CONFIG_DEBUG_FS) |
686 | return radeon_debugfs_add_files(rdev, rv370_pcie_gart_info_list, 1); | 593 | return radeon_debugfs_add_files(rdev, rv370_pcie_gart_info_list, 1); |
@@ -689,10 +596,6 @@ int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | |||
689 | #endif | 596 | #endif |
690 | } | 597 | } |
691 | 598 | ||
692 | |||
693 | /* | ||
694 | * CS functions | ||
695 | */ | ||
696 | static int r300_packet0_check(struct radeon_cs_parser *p, | 599 | static int r300_packet0_check(struct radeon_cs_parser *p, |
697 | struct radeon_cs_packet *pkt, | 600 | struct radeon_cs_packet *pkt, |
698 | unsigned idx, unsigned reg) | 601 | unsigned idx, unsigned reg) |
@@ -1226,12 +1129,6 @@ void r300_set_reg_safe(struct radeon_device *rdev) | |||
1226 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(r300_reg_safe_bm); | 1129 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(r300_reg_safe_bm); |
1227 | } | 1130 | } |
1228 | 1131 | ||
1229 | int r300_init(struct radeon_device *rdev) | ||
1230 | { | ||
1231 | r300_set_reg_safe(rdev); | ||
1232 | return 0; | ||
1233 | } | ||
1234 | |||
1235 | void r300_mc_program(struct radeon_device *rdev) | 1132 | void r300_mc_program(struct radeon_device *rdev) |
1236 | { | 1133 | { |
1237 | struct r100_mc_save save; | 1134 | struct r100_mc_save save; |
@@ -1265,3 +1162,198 @@ void r300_mc_program(struct radeon_device *rdev) | |||
1265 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); | 1162 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); |
1266 | r100_mc_resume(rdev, &save); | 1163 | r100_mc_resume(rdev, &save); |
1267 | } | 1164 | } |
1165 | |||
1166 | void r300_clock_startup(struct radeon_device *rdev) | ||
1167 | { | ||
1168 | u32 tmp; | ||
1169 | |||
1170 | if (radeon_dynclks != -1 && radeon_dynclks) | ||
1171 | radeon_legacy_set_clock_gating(rdev, 1); | ||
1172 | /* We need to force on some of the block */ | ||
1173 | tmp = RREG32_PLL(R_00000D_SCLK_CNTL); | ||
1174 | tmp |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); | ||
1175 | if ((rdev->family == CHIP_RV350) || (rdev->family == CHIP_RV380)) | ||
1176 | tmp |= S_00000D_FORCE_VAP(1); | ||
1177 | WREG32_PLL(R_00000D_SCLK_CNTL, tmp); | ||
1178 | } | ||
1179 | |||
1180 | static int r300_startup(struct radeon_device *rdev) | ||
1181 | { | ||
1182 | int r; | ||
1183 | |||
1184 | r300_mc_program(rdev); | ||
1185 | /* Resume clock */ | ||
1186 | r300_clock_startup(rdev); | ||
1187 | /* Initialize GPU configuration (# pipes, ...) */ | ||
1188 | r300_gpu_init(rdev); | ||
1189 | /* Initialize GART (initialize after TTM so we can allocate | ||
1190 | * memory through TTM but finalize after TTM) */ | ||
1191 | if (rdev->flags & RADEON_IS_PCIE) { | ||
1192 | r = rv370_pcie_gart_enable(rdev); | ||
1193 | if (r) | ||
1194 | return r; | ||
1195 | } | ||
1196 | if (rdev->flags & RADEON_IS_PCI) { | ||
1197 | r = r100_pci_gart_enable(rdev); | ||
1198 | if (r) | ||
1199 | return r; | ||
1200 | } | ||
1201 | /* Enable IRQ */ | ||
1202 | rdev->irq.sw_int = true; | ||
1203 | r100_irq_set(rdev); | ||
1204 | /* 1M ring buffer */ | ||
1205 | r = r100_cp_init(rdev, 1024 * 1024); | ||
1206 | if (r) { | ||
1207 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
1208 | return r; | ||
1209 | } | ||
1210 | r = r100_wb_init(rdev); | ||
1211 | if (r) | ||
1212 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
1213 | r = r100_ib_init(rdev); | ||
1214 | if (r) { | ||
1215 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
1216 | return r; | ||
1217 | } | ||
1218 | return 0; | ||
1219 | } | ||
1220 | |||
1221 | int r300_resume(struct radeon_device *rdev) | ||
1222 | { | ||
1223 | /* Make sur GART are not working */ | ||
1224 | if (rdev->flags & RADEON_IS_PCIE) | ||
1225 | rv370_pcie_gart_disable(rdev); | ||
1226 | if (rdev->flags & RADEON_IS_PCI) | ||
1227 | r100_pci_gart_disable(rdev); | ||
1228 | /* Resume clock before doing reset */ | ||
1229 | r300_clock_startup(rdev); | ||
1230 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
1231 | if (radeon_gpu_reset(rdev)) { | ||
1232 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
1233 | RREG32(R_000E40_RBBM_STATUS), | ||
1234 | RREG32(R_0007C0_CP_STAT)); | ||
1235 | } | ||
1236 | /* post */ | ||
1237 | radeon_combios_asic_init(rdev->ddev); | ||
1238 | /* Resume clock after posting */ | ||
1239 | r300_clock_startup(rdev); | ||
1240 | return r300_startup(rdev); | ||
1241 | } | ||
1242 | |||
1243 | int r300_suspend(struct radeon_device *rdev) | ||
1244 | { | ||
1245 | r100_cp_disable(rdev); | ||
1246 | r100_wb_disable(rdev); | ||
1247 | r100_irq_disable(rdev); | ||
1248 | if (rdev->flags & RADEON_IS_PCIE) | ||
1249 | rv370_pcie_gart_disable(rdev); | ||
1250 | if (rdev->flags & RADEON_IS_PCI) | ||
1251 | r100_pci_gart_disable(rdev); | ||
1252 | return 0; | ||
1253 | } | ||
1254 | |||
1255 | void r300_fini(struct radeon_device *rdev) | ||
1256 | { | ||
1257 | r300_suspend(rdev); | ||
1258 | r100_cp_fini(rdev); | ||
1259 | r100_wb_fini(rdev); | ||
1260 | r100_ib_fini(rdev); | ||
1261 | radeon_gem_fini(rdev); | ||
1262 | if (rdev->flags & RADEON_IS_PCIE) | ||
1263 | rv370_pcie_gart_fini(rdev); | ||
1264 | if (rdev->flags & RADEON_IS_PCI) | ||
1265 | r100_pci_gart_fini(rdev); | ||
1266 | radeon_irq_kms_fini(rdev); | ||
1267 | radeon_fence_driver_fini(rdev); | ||
1268 | radeon_object_fini(rdev); | ||
1269 | radeon_atombios_fini(rdev); | ||
1270 | kfree(rdev->bios); | ||
1271 | rdev->bios = NULL; | ||
1272 | } | ||
1273 | |||
1274 | int r300_init(struct radeon_device *rdev) | ||
1275 | { | ||
1276 | int r; | ||
1277 | |||
1278 | /* Disable VGA */ | ||
1279 | r100_vga_render_disable(rdev); | ||
1280 | /* Initialize scratch registers */ | ||
1281 | radeon_scratch_init(rdev); | ||
1282 | /* Initialize surface registers */ | ||
1283 | radeon_surface_init(rdev); | ||
1284 | /* TODO: disable VGA need to use VGA request */ | ||
1285 | /* BIOS*/ | ||
1286 | if (!radeon_get_bios(rdev)) { | ||
1287 | if (ASIC_IS_AVIVO(rdev)) | ||
1288 | return -EINVAL; | ||
1289 | } | ||
1290 | if (rdev->is_atom_bios) { | ||
1291 | dev_err(rdev->dev, "Expecting combios for RS400/RS480 GPU\n"); | ||
1292 | return -EINVAL; | ||
1293 | } else { | ||
1294 | r = radeon_combios_init(rdev); | ||
1295 | if (r) | ||
1296 | return r; | ||
1297 | } | ||
1298 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
1299 | if (radeon_gpu_reset(rdev)) { | ||
1300 | dev_warn(rdev->dev, | ||
1301 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
1302 | RREG32(R_000E40_RBBM_STATUS), | ||
1303 | RREG32(R_0007C0_CP_STAT)); | ||
1304 | } | ||
1305 | /* check if cards are posted or not */ | ||
1306 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
1307 | DRM_INFO("GPU not posted. posting now...\n"); | ||
1308 | radeon_combios_asic_init(rdev->ddev); | ||
1309 | } | ||
1310 | /* Set asic errata */ | ||
1311 | r300_errata(rdev); | ||
1312 | /* Initialize clocks */ | ||
1313 | radeon_get_clock_info(rdev->ddev); | ||
1314 | /* Get vram informations */ | ||
1315 | r300_vram_info(rdev); | ||
1316 | /* Initialize memory controller (also test AGP) */ | ||
1317 | r = r420_mc_init(rdev); | ||
1318 | if (r) | ||
1319 | return r; | ||
1320 | /* Fence driver */ | ||
1321 | r = radeon_fence_driver_init(rdev); | ||
1322 | if (r) | ||
1323 | return r; | ||
1324 | r = radeon_irq_kms_init(rdev); | ||
1325 | if (r) | ||
1326 | return r; | ||
1327 | /* Memory manager */ | ||
1328 | r = radeon_object_init(rdev); | ||
1329 | if (r) | ||
1330 | return r; | ||
1331 | if (rdev->flags & RADEON_IS_PCIE) { | ||
1332 | r = rv370_pcie_gart_init(rdev); | ||
1333 | if (r) | ||
1334 | return r; | ||
1335 | } | ||
1336 | if (rdev->flags & RADEON_IS_PCI) { | ||
1337 | r = r100_pci_gart_init(rdev); | ||
1338 | if (r) | ||
1339 | return r; | ||
1340 | } | ||
1341 | r300_set_reg_safe(rdev); | ||
1342 | rdev->accel_working = true; | ||
1343 | r = r300_startup(rdev); | ||
1344 | if (r) { | ||
1345 | /* Somethings want wront with the accel init stop accel */ | ||
1346 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
1347 | r300_suspend(rdev); | ||
1348 | r100_cp_fini(rdev); | ||
1349 | r100_wb_fini(rdev); | ||
1350 | r100_ib_fini(rdev); | ||
1351 | if (rdev->flags & RADEON_IS_PCIE) | ||
1352 | rv370_pcie_gart_fini(rdev); | ||
1353 | if (rdev->flags & RADEON_IS_PCI) | ||
1354 | r100_pci_gart_fini(rdev); | ||
1355 | radeon_irq_kms_fini(rdev); | ||
1356 | rdev->accel_working = false; | ||
1357 | } | ||
1358 | return 0; | ||
1359 | } | ||
diff --git a/drivers/gpu/drm/radeon/r300d.h b/drivers/gpu/drm/radeon/r300d.h index d4fa3eb1074f..4c73114f0de9 100644 --- a/drivers/gpu/drm/radeon/r300d.h +++ b/drivers/gpu/drm/radeon/r300d.h | |||
@@ -96,6 +96,211 @@ | |||
96 | #define S_000170_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | 96 | #define S_000170_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) |
97 | #define G_000170_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | 97 | #define G_000170_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) |
98 | #define C_000170_AGP_BASE_ADDR 0x00000000 | 98 | #define C_000170_AGP_BASE_ADDR 0x00000000 |
99 | #define R_0007C0_CP_STAT 0x0007C0 | ||
100 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
101 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
102 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
103 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
104 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
105 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
106 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
107 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
108 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
109 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
110 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
111 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
112 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
113 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
114 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
115 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
116 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
117 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
118 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
119 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
120 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
121 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
122 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
123 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
124 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
125 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
126 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
127 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
128 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
129 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
130 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
131 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
132 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
133 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
134 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
135 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
136 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
137 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
138 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
139 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
140 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
141 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
142 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
143 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
144 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
145 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
146 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
147 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
148 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
149 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
150 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
151 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
152 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
153 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
154 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
155 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
156 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
157 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
158 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
159 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
160 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
161 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
162 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
163 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
164 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
165 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
166 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
167 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
168 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
169 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
170 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
171 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
172 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
173 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
174 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
175 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
176 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
177 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
178 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
179 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
180 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
181 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
182 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
183 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
184 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
185 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
186 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
187 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
188 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
189 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
190 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
191 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
192 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
193 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
194 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
195 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
196 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
197 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
198 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
199 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
200 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
201 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
202 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
203 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
204 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
205 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
206 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
207 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
208 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
209 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
210 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
211 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
99 | 212 | ||
100 | 213 | ||
214 | #define R_00000D_SCLK_CNTL 0x00000D | ||
215 | #define S_00000D_SCLK_SRC_SEL(x) (((x) & 0x7) << 0) | ||
216 | #define G_00000D_SCLK_SRC_SEL(x) (((x) >> 0) & 0x7) | ||
217 | #define C_00000D_SCLK_SRC_SEL 0xFFFFFFF8 | ||
218 | #define S_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 3) | ||
219 | #define G_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) >> 3) & 0x1) | ||
220 | #define C_00000D_CP_MAX_DYN_STOP_LAT 0xFFFFFFF7 | ||
221 | #define S_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 4) | ||
222 | #define G_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) >> 4) & 0x1) | ||
223 | #define C_00000D_HDP_MAX_DYN_STOP_LAT 0xFFFFFFEF | ||
224 | #define S_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 5) | ||
225 | #define G_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) >> 5) & 0x1) | ||
226 | #define C_00000D_TV_MAX_DYN_STOP_LAT 0xFFFFFFDF | ||
227 | #define S_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 6) | ||
228 | #define G_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) >> 6) & 0x1) | ||
229 | #define C_00000D_E2_MAX_DYN_STOP_LAT 0xFFFFFFBF | ||
230 | #define S_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 7) | ||
231 | #define G_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) >> 7) & 0x1) | ||
232 | #define C_00000D_SE_MAX_DYN_STOP_LAT 0xFFFFFF7F | ||
233 | #define S_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 8) | ||
234 | #define G_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) >> 8) & 0x1) | ||
235 | #define C_00000D_IDCT_MAX_DYN_STOP_LAT 0xFFFFFEFF | ||
236 | #define S_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 9) | ||
237 | #define G_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) >> 9) & 0x1) | ||
238 | #define C_00000D_VIP_MAX_DYN_STOP_LAT 0xFFFFFDFF | ||
239 | #define S_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 10) | ||
240 | #define G_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) >> 10) & 0x1) | ||
241 | #define C_00000D_RE_MAX_DYN_STOP_LAT 0xFFFFFBFF | ||
242 | #define S_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 11) | ||
243 | #define G_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) >> 11) & 0x1) | ||
244 | #define C_00000D_PB_MAX_DYN_STOP_LAT 0xFFFFF7FF | ||
245 | #define S_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 12) | ||
246 | #define G_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) >> 12) & 0x1) | ||
247 | #define C_00000D_TAM_MAX_DYN_STOP_LAT 0xFFFFEFFF | ||
248 | #define S_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 13) | ||
249 | #define G_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) >> 13) & 0x1) | ||
250 | #define C_00000D_TDM_MAX_DYN_STOP_LAT 0xFFFFDFFF | ||
251 | #define S_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 14) | ||
252 | #define G_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) >> 14) & 0x1) | ||
253 | #define C_00000D_RB_MAX_DYN_STOP_LAT 0xFFFFBFFF | ||
254 | #define S_00000D_FORCE_DISP2(x) (((x) & 0x1) << 15) | ||
255 | #define G_00000D_FORCE_DISP2(x) (((x) >> 15) & 0x1) | ||
256 | #define C_00000D_FORCE_DISP2 0xFFFF7FFF | ||
257 | #define S_00000D_FORCE_CP(x) (((x) & 0x1) << 16) | ||
258 | #define G_00000D_FORCE_CP(x) (((x) >> 16) & 0x1) | ||
259 | #define C_00000D_FORCE_CP 0xFFFEFFFF | ||
260 | #define S_00000D_FORCE_HDP(x) (((x) & 0x1) << 17) | ||
261 | #define G_00000D_FORCE_HDP(x) (((x) >> 17) & 0x1) | ||
262 | #define C_00000D_FORCE_HDP 0xFFFDFFFF | ||
263 | #define S_00000D_FORCE_DISP1(x) (((x) & 0x1) << 18) | ||
264 | #define G_00000D_FORCE_DISP1(x) (((x) >> 18) & 0x1) | ||
265 | #define C_00000D_FORCE_DISP1 0xFFFBFFFF | ||
266 | #define S_00000D_FORCE_TOP(x) (((x) & 0x1) << 19) | ||
267 | #define G_00000D_FORCE_TOP(x) (((x) >> 19) & 0x1) | ||
268 | #define C_00000D_FORCE_TOP 0xFFF7FFFF | ||
269 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | ||
270 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | ||
271 | #define C_00000D_FORCE_E2 0xFFEFFFFF | ||
272 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | ||
273 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | ||
274 | #define C_00000D_FORCE_SE 0xFFDFFFFF | ||
275 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | ||
276 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | ||
277 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | ||
278 | #define S_00000D_FORCE_VIP(x) (((x) & 0x1) << 23) | ||
279 | #define G_00000D_FORCE_VIP(x) (((x) >> 23) & 0x1) | ||
280 | #define C_00000D_FORCE_VIP 0xFF7FFFFF | ||
281 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | ||
282 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | ||
283 | #define C_00000D_FORCE_RE 0xFEFFFFFF | ||
284 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | ||
285 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | ||
286 | #define C_00000D_FORCE_PB 0xFDFFFFFF | ||
287 | #define S_00000D_FORCE_TAM(x) (((x) & 0x1) << 26) | ||
288 | #define G_00000D_FORCE_TAM(x) (((x) >> 26) & 0x1) | ||
289 | #define C_00000D_FORCE_TAM 0xFBFFFFFF | ||
290 | #define S_00000D_FORCE_TDM(x) (((x) & 0x1) << 27) | ||
291 | #define G_00000D_FORCE_TDM(x) (((x) >> 27) & 0x1) | ||
292 | #define C_00000D_FORCE_TDM 0xF7FFFFFF | ||
293 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | ||
294 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | ||
295 | #define C_00000D_FORCE_RB 0xEFFFFFFF | ||
296 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) | ||
297 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) | ||
298 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF | ||
299 | #define S_00000D_FORCE_SUBPIC(x) (((x) & 0x1) << 30) | ||
300 | #define G_00000D_FORCE_SUBPIC(x) (((x) >> 30) & 0x1) | ||
301 | #define C_00000D_FORCE_SUBPIC 0xBFFFFFFF | ||
302 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) | ||
303 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) | ||
304 | #define C_00000D_FORCE_OV0 0x7FFFFFFF | ||
305 | |||
101 | #endif | 306 | #endif |
diff --git a/drivers/gpu/drm/radeon/r420.c b/drivers/gpu/drm/radeon/r420.c index 49a2fdc57d27..5c7fe52de30e 100644 --- a/drivers/gpu/drm/radeon/r420.c +++ b/drivers/gpu/drm/radeon/r420.c | |||
@@ -155,6 +155,9 @@ static void r420_debugfs(struct radeon_device *rdev) | |||
155 | static void r420_clock_resume(struct radeon_device *rdev) | 155 | static void r420_clock_resume(struct radeon_device *rdev) |
156 | { | 156 | { |
157 | u32 sclk_cntl; | 157 | u32 sclk_cntl; |
158 | |||
159 | if (radeon_dynclks != -1 && radeon_dynclks) | ||
160 | radeon_atom_set_clock_gating(rdev, 1); | ||
158 | sclk_cntl = RREG32_PLL(R_00000D_SCLK_CNTL); | 161 | sclk_cntl = RREG32_PLL(R_00000D_SCLK_CNTL); |
159 | sclk_cntl |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); | 162 | sclk_cntl |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); |
160 | if (rdev->family == CHIP_R420) | 163 | if (rdev->family == CHIP_R420) |
@@ -167,6 +170,8 @@ static int r420_startup(struct radeon_device *rdev) | |||
167 | int r; | 170 | int r; |
168 | 171 | ||
169 | r300_mc_program(rdev); | 172 | r300_mc_program(rdev); |
173 | /* Resume clock */ | ||
174 | r420_clock_resume(rdev); | ||
170 | /* Initialize GART (initialize after TTM so we can allocate | 175 | /* Initialize GART (initialize after TTM so we can allocate |
171 | * memory through TTM but finalize after TTM) */ | 176 | * memory through TTM but finalize after TTM) */ |
172 | if (rdev->flags & RADEON_IS_PCIE) { | 177 | if (rdev->flags & RADEON_IS_PCIE) { |
@@ -267,7 +272,6 @@ int r420_init(struct radeon_device *rdev) | |||
267 | { | 272 | { |
268 | int r; | 273 | int r; |
269 | 274 | ||
270 | rdev->new_init_path = true; | ||
271 | /* Initialize scratch registers */ | 275 | /* Initialize scratch registers */ |
272 | radeon_scratch_init(rdev); | 276 | radeon_scratch_init(rdev); |
273 | /* Initialize surface registers */ | 277 | /* Initialize surface registers */ |
diff --git a/drivers/gpu/drm/radeon/r420d.h b/drivers/gpu/drm/radeon/r420d.h index a48a7db1e2aa..fc78d31a0b4a 100644 --- a/drivers/gpu/drm/radeon/r420d.h +++ b/drivers/gpu/drm/radeon/r420d.h | |||
@@ -212,9 +212,9 @@ | |||
212 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | 212 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) |
213 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | 213 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) |
214 | #define C_00000D_FORCE_E2 0xFFEFFFFF | 214 | #define C_00000D_FORCE_E2 0xFFEFFFFF |
215 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | 215 | #define S_00000D_FORCE_VAP(x) (((x) & 0x1) << 21) |
216 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | 216 | #define G_00000D_FORCE_VAP(x) (((x) >> 21) & 0x1) |
217 | #define C_00000D_FORCE_SE 0xFFDFFFFF | 217 | #define C_00000D_FORCE_VAP 0xFFDFFFFF |
218 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | 218 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) |
219 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | 219 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) |
220 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | 220 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF |
@@ -224,24 +224,24 @@ | |||
224 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | 224 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) |
225 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | 225 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) |
226 | #define C_00000D_FORCE_RE 0xFEFFFFFF | 226 | #define C_00000D_FORCE_RE 0xFEFFFFFF |
227 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | 227 | #define S_00000D_FORCE_SR(x) (((x) & 0x1) << 25) |
228 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | 228 | #define G_00000D_FORCE_SR(x) (((x) >> 25) & 0x1) |
229 | #define C_00000D_FORCE_PB 0xFDFFFFFF | 229 | #define C_00000D_FORCE_SR 0xFDFFFFFF |
230 | #define S_00000D_FORCE_PX(x) (((x) & 0x1) << 26) | 230 | #define S_00000D_FORCE_PX(x) (((x) & 0x1) << 26) |
231 | #define G_00000D_FORCE_PX(x) (((x) >> 26) & 0x1) | 231 | #define G_00000D_FORCE_PX(x) (((x) >> 26) & 0x1) |
232 | #define C_00000D_FORCE_PX 0xFBFFFFFF | 232 | #define C_00000D_FORCE_PX 0xFBFFFFFF |
233 | #define S_00000D_FORCE_TX(x) (((x) & 0x1) << 27) | 233 | #define S_00000D_FORCE_TX(x) (((x) & 0x1) << 27) |
234 | #define G_00000D_FORCE_TX(x) (((x) >> 27) & 0x1) | 234 | #define G_00000D_FORCE_TX(x) (((x) >> 27) & 0x1) |
235 | #define C_00000D_FORCE_TX 0xF7FFFFFF | 235 | #define C_00000D_FORCE_TX 0xF7FFFFFF |
236 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | 236 | #define S_00000D_FORCE_US(x) (((x) & 0x1) << 28) |
237 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | 237 | #define G_00000D_FORCE_US(x) (((x) >> 28) & 0x1) |
238 | #define C_00000D_FORCE_RB 0xEFFFFFFF | 238 | #define C_00000D_FORCE_US 0xEFFFFFFF |
239 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) | 239 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) |
240 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) | 240 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) |
241 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF | 241 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF |
242 | #define S_00000D_FORCE_SUBPIC(x) (((x) & 0x1) << 30) | 242 | #define S_00000D_FORCE_SU(x) (((x) & 0x1) << 30) |
243 | #define G_00000D_FORCE_SUBPIC(x) (((x) >> 30) & 0x1) | 243 | #define G_00000D_FORCE_SU(x) (((x) >> 30) & 0x1) |
244 | #define C_00000D_FORCE_SUBPIC 0xBFFFFFFF | 244 | #define C_00000D_FORCE_SU 0xBFFFFFFF |
245 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) | 245 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) |
246 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) | 246 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) |
247 | #define C_00000D_FORCE_OV0 0x7FFFFFFF | 247 | #define C_00000D_FORCE_OV0 0x7FFFFFFF |
diff --git a/drivers/gpu/drm/radeon/r520.c b/drivers/gpu/drm/radeon/r520.c index 0bf13fccdaf2..a555b7b19b48 100644 --- a/drivers/gpu/drm/radeon/r520.c +++ b/drivers/gpu/drm/radeon/r520.c | |||
@@ -186,7 +186,7 @@ static int r520_startup(struct radeon_device *rdev) | |||
186 | } | 186 | } |
187 | /* Enable IRQ */ | 187 | /* Enable IRQ */ |
188 | rdev->irq.sw_int = true; | 188 | rdev->irq.sw_int = true; |
189 | r100_irq_set(rdev); | 189 | rs600_irq_set(rdev); |
190 | /* 1M ring buffer */ | 190 | /* 1M ring buffer */ |
191 | r = r100_cp_init(rdev, 1024 * 1024); | 191 | r = r100_cp_init(rdev, 1024 * 1024); |
192 | if (r) { | 192 | if (r) { |
@@ -228,7 +228,6 @@ int r520_init(struct radeon_device *rdev) | |||
228 | { | 228 | { |
229 | int r; | 229 | int r; |
230 | 230 | ||
231 | rdev->new_init_path = true; | ||
232 | /* Initialize scratch registers */ | 231 | /* Initialize scratch registers */ |
233 | radeon_scratch_init(rdev); | 232 | radeon_scratch_init(rdev); |
234 | /* Initialize surface registers */ | 233 | /* Initialize surface registers */ |
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c index 2e4e60edbff4..609719490ec2 100644 --- a/drivers/gpu/drm/radeon/r600.c +++ b/drivers/gpu/drm/radeon/r600.c | |||
@@ -65,16 +65,11 @@ MODULE_FIRMWARE("radeon/RV710_me.bin"); | |||
65 | 65 | ||
66 | int r600_debugfs_mc_info_init(struct radeon_device *rdev); | 66 | int r600_debugfs_mc_info_init(struct radeon_device *rdev); |
67 | 67 | ||
68 | /* This files gather functions specifics to: | 68 | /* r600,rv610,rv630,rv620,rv635,rv670 */ |
69 | * r600,rv610,rv630,rv620,rv635,rv670 | ||
70 | * | ||
71 | * Some of these functions might be used by newer ASICs. | ||
72 | */ | ||
73 | int r600_mc_wait_for_idle(struct radeon_device *rdev); | 69 | int r600_mc_wait_for_idle(struct radeon_device *rdev); |
74 | void r600_gpu_init(struct radeon_device *rdev); | 70 | void r600_gpu_init(struct radeon_device *rdev); |
75 | void r600_fini(struct radeon_device *rdev); | 71 | void r600_fini(struct radeon_device *rdev); |
76 | 72 | ||
77 | |||
78 | /* | 73 | /* |
79 | * R600 PCIE GART | 74 | * R600 PCIE GART |
80 | */ | 75 | */ |
@@ -168,7 +163,7 @@ int r600_pcie_gart_enable(struct radeon_device *rdev) | |||
168 | WREG32(MC_VM_L1_TLB_MCB_RD_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | 163 | WREG32(MC_VM_L1_TLB_MCB_RD_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); |
169 | WREG32(MC_VM_L1_TLB_MCB_WR_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | 164 | WREG32(MC_VM_L1_TLB_MCB_WR_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); |
170 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); | 165 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); |
171 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, (rdev->mc.gtt_end - 1) >> 12); | 166 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, rdev->mc.gtt_end >> 12); |
172 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); | 167 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); |
173 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | | 168 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | |
174 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); | 169 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); |
@@ -225,6 +220,40 @@ void r600_pcie_gart_fini(struct radeon_device *rdev) | |||
225 | radeon_gart_fini(rdev); | 220 | radeon_gart_fini(rdev); |
226 | } | 221 | } |
227 | 222 | ||
223 | void r600_agp_enable(struct radeon_device *rdev) | ||
224 | { | ||
225 | u32 tmp; | ||
226 | int i; | ||
227 | |||
228 | /* Setup L2 cache */ | ||
229 | WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING | | ||
230 | ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE | | ||
231 | EFFECTIVE_L2_QUEUE_SIZE(7)); | ||
232 | WREG32(VM_L2_CNTL2, 0); | ||
233 | WREG32(VM_L2_CNTL3, BANK_SELECT_0(0) | BANK_SELECT_1(1)); | ||
234 | /* Setup TLB control */ | ||
235 | tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING | | ||
236 | SYSTEM_ACCESS_MODE_NOT_IN_SYS | | ||
237 | EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5) | | ||
238 | ENABLE_WAIT_L2_QUERY; | ||
239 | WREG32(MC_VM_L1_TLB_MCB_RD_SYS_CNTL, tmp); | ||
240 | WREG32(MC_VM_L1_TLB_MCB_WR_SYS_CNTL, tmp); | ||
241 | WREG32(MC_VM_L1_TLB_MCB_RD_HDP_CNTL, tmp | ENABLE_L1_STRICT_ORDERING); | ||
242 | WREG32(MC_VM_L1_TLB_MCB_WR_HDP_CNTL, tmp); | ||
243 | WREG32(MC_VM_L1_TLB_MCD_RD_A_CNTL, tmp); | ||
244 | WREG32(MC_VM_L1_TLB_MCD_WR_A_CNTL, tmp); | ||
245 | WREG32(MC_VM_L1_TLB_MCD_RD_B_CNTL, tmp); | ||
246 | WREG32(MC_VM_L1_TLB_MCD_WR_B_CNTL, tmp); | ||
247 | WREG32(MC_VM_L1_TLB_MCB_RD_GFX_CNTL, tmp); | ||
248 | WREG32(MC_VM_L1_TLB_MCB_WR_GFX_CNTL, tmp); | ||
249 | WREG32(MC_VM_L1_TLB_MCB_RD_PDMA_CNTL, tmp); | ||
250 | WREG32(MC_VM_L1_TLB_MCB_WR_PDMA_CNTL, tmp); | ||
251 | WREG32(MC_VM_L1_TLB_MCB_RD_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | ||
252 | WREG32(MC_VM_L1_TLB_MCB_WR_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | ||
253 | for (i = 0; i < 7; i++) | ||
254 | WREG32(VM_CONTEXT0_CNTL + (i * 4), 0); | ||
255 | } | ||
256 | |||
228 | int r600_mc_wait_for_idle(struct radeon_device *rdev) | 257 | int r600_mc_wait_for_idle(struct radeon_device *rdev) |
229 | { | 258 | { |
230 | unsigned i; | 259 | unsigned i; |
@@ -240,14 +269,9 @@ int r600_mc_wait_for_idle(struct radeon_device *rdev) | |||
240 | return -1; | 269 | return -1; |
241 | } | 270 | } |
242 | 271 | ||
243 | static void r600_mc_resume(struct radeon_device *rdev) | 272 | static void r600_mc_program(struct radeon_device *rdev) |
244 | { | 273 | { |
245 | u32 d1vga_control, d2vga_control; | 274 | struct rv515_mc_save save; |
246 | u32 vga_render_control, vga_hdp_control; | ||
247 | u32 d1crtc_control, d2crtc_control; | ||
248 | u32 new_d1grph_primary, new_d1grph_secondary; | ||
249 | u32 new_d2grph_primary, new_d2grph_secondary; | ||
250 | u64 old_vram_start; | ||
251 | u32 tmp; | 275 | u32 tmp; |
252 | int i, j; | 276 | int i, j; |
253 | 277 | ||
@@ -261,85 +285,51 @@ static void r600_mc_resume(struct radeon_device *rdev) | |||
261 | } | 285 | } |
262 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); | 286 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); |
263 | 287 | ||
264 | d1vga_control = RREG32(D1VGA_CONTROL); | 288 | rv515_mc_stop(rdev, &save); |
265 | d2vga_control = RREG32(D2VGA_CONTROL); | ||
266 | vga_render_control = RREG32(VGA_RENDER_CONTROL); | ||
267 | vga_hdp_control = RREG32(VGA_HDP_CONTROL); | ||
268 | d1crtc_control = RREG32(D1CRTC_CONTROL); | ||
269 | d2crtc_control = RREG32(D2CRTC_CONTROL); | ||
270 | old_vram_start = (u64)(RREG32(MC_VM_FB_LOCATION) & 0xFFFF) << 24; | ||
271 | new_d1grph_primary = RREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS); | ||
272 | new_d1grph_secondary = RREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS); | ||
273 | new_d1grph_primary += rdev->mc.vram_start - old_vram_start; | ||
274 | new_d1grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
275 | new_d2grph_primary = RREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS); | ||
276 | new_d2grph_secondary = RREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS); | ||
277 | new_d2grph_primary += rdev->mc.vram_start - old_vram_start; | ||
278 | new_d2grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
279 | |||
280 | /* Stop all video */ | ||
281 | WREG32(D1VGA_CONTROL, 0); | ||
282 | WREG32(D2VGA_CONTROL, 0); | ||
283 | WREG32(VGA_RENDER_CONTROL, 0); | ||
284 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
285 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
286 | WREG32(D1CRTC_CONTROL, 0); | ||
287 | WREG32(D2CRTC_CONTROL, 0); | ||
288 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
289 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
290 | |||
291 | mdelay(1); | ||
292 | if (r600_mc_wait_for_idle(rdev)) { | 289 | if (r600_mc_wait_for_idle(rdev)) { |
293 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 290 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
294 | } | 291 | } |
295 | 292 | /* Lockout access through VGA aperture (doesn't exist before R600) */ | |
296 | /* Lockout access through VGA aperture*/ | ||
297 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); | 293 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); |
298 | |||
299 | /* Update configuration */ | 294 | /* Update configuration */ |
300 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.vram_start >> 12); | 295 | if (rdev->flags & RADEON_IS_AGP) { |
301 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, (rdev->mc.vram_end - 1) >> 12); | 296 | if (rdev->mc.vram_start < rdev->mc.gtt_start) { |
297 | /* VRAM before AGP */ | ||
298 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
299 | rdev->mc.vram_start >> 12); | ||
300 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
301 | rdev->mc.gtt_end >> 12); | ||
302 | } else { | ||
303 | /* VRAM after AGP */ | ||
304 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
305 | rdev->mc.gtt_start >> 12); | ||
306 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
307 | rdev->mc.vram_end >> 12); | ||
308 | } | ||
309 | } else { | ||
310 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.vram_start >> 12); | ||
311 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, rdev->mc.vram_end >> 12); | ||
312 | } | ||
302 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); | 313 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); |
303 | tmp = (((rdev->mc.vram_end - 1) >> 24) & 0xFFFF) << 16; | 314 | tmp = ((rdev->mc.vram_end >> 24) & 0xFFFF) << 16; |
304 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); | 315 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); |
305 | WREG32(MC_VM_FB_LOCATION, tmp); | 316 | WREG32(MC_VM_FB_LOCATION, tmp); |
306 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); | 317 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); |
307 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); | 318 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); |
308 | WREG32(HDP_NONSURFACE_SIZE, (rdev->mc.mc_vram_size - 1) | 0x3FF); | 319 | WREG32(HDP_NONSURFACE_SIZE, rdev->mc.mc_vram_size | 0x3FF); |
309 | if (rdev->flags & RADEON_IS_AGP) { | 320 | if (rdev->flags & RADEON_IS_AGP) { |
310 | WREG32(MC_VM_AGP_TOP, (rdev->mc.gtt_end - 1) >> 16); | 321 | WREG32(MC_VM_AGP_TOP, rdev->mc.gtt_end >> 22); |
311 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16); | 322 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 22); |
312 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); | 323 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); |
313 | } else { | 324 | } else { |
314 | WREG32(MC_VM_AGP_BASE, 0); | 325 | WREG32(MC_VM_AGP_BASE, 0); |
315 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); | 326 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); |
316 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); | 327 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); |
317 | } | 328 | } |
318 | WREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS, new_d1grph_primary); | ||
319 | WREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS, new_d1grph_secondary); | ||
320 | WREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS, new_d2grph_primary); | ||
321 | WREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS, new_d2grph_secondary); | ||
322 | WREG32(VGA_MEMORY_BASE_ADDRESS, rdev->mc.vram_start); | ||
323 | |||
324 | /* Unlock host access */ | ||
325 | WREG32(VGA_HDP_CONTROL, vga_hdp_control); | ||
326 | |||
327 | mdelay(1); | ||
328 | if (r600_mc_wait_for_idle(rdev)) { | 329 | if (r600_mc_wait_for_idle(rdev)) { |
329 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 330 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
330 | } | 331 | } |
331 | 332 | rv515_mc_resume(rdev, &save); | |
332 | /* Restore video state */ | ||
333 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
334 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
335 | WREG32(D1CRTC_CONTROL, d1crtc_control); | ||
336 | WREG32(D2CRTC_CONTROL, d2crtc_control); | ||
337 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
338 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
339 | WREG32(D1VGA_CONTROL, d1vga_control); | ||
340 | WREG32(D2VGA_CONTROL, d2vga_control); | ||
341 | WREG32(VGA_RENDER_CONTROL, vga_render_control); | ||
342 | |||
343 | /* we need to own VRAM, so turn off the VGA renderer here | 333 | /* we need to own VRAM, so turn off the VGA renderer here |
344 | * to stop it overwriting our objects */ | 334 | * to stop it overwriting our objects */ |
345 | rv515_vga_render_disable(rdev); | 335 | rv515_vga_render_disable(rdev); |
@@ -445,9 +435,9 @@ int r600_mc_init(struct radeon_device *rdev) | |||
445 | } | 435 | } |
446 | } | 436 | } |
447 | rdev->mc.vram_start = rdev->mc.vram_location; | 437 | rdev->mc.vram_start = rdev->mc.vram_location; |
448 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size; | 438 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; |
449 | rdev->mc.gtt_start = rdev->mc.gtt_location; | 439 | rdev->mc.gtt_start = rdev->mc.gtt_location; |
450 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size; | 440 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; |
451 | /* FIXME: we should enforce default clock in case GPU is not in | 441 | /* FIXME: we should enforce default clock in case GPU is not in |
452 | * default setup | 442 | * default setup |
453 | */ | 443 | */ |
@@ -463,6 +453,7 @@ int r600_mc_init(struct radeon_device *rdev) | |||
463 | */ | 453 | */ |
464 | int r600_gpu_soft_reset(struct radeon_device *rdev) | 454 | int r600_gpu_soft_reset(struct radeon_device *rdev) |
465 | { | 455 | { |
456 | struct rv515_mc_save save; | ||
466 | u32 grbm_busy_mask = S_008010_VC_BUSY(1) | S_008010_VGT_BUSY_NO_DMA(1) | | 457 | u32 grbm_busy_mask = S_008010_VC_BUSY(1) | S_008010_VGT_BUSY_NO_DMA(1) | |
467 | S_008010_VGT_BUSY(1) | S_008010_TA03_BUSY(1) | | 458 | S_008010_VGT_BUSY(1) | S_008010_TA03_BUSY(1) | |
468 | S_008010_TC_BUSY(1) | S_008010_SX_BUSY(1) | | 459 | S_008010_TC_BUSY(1) | S_008010_SX_BUSY(1) | |
@@ -480,13 +471,25 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
480 | S_008014_CB0_BUSY(1) | S_008014_CB1_BUSY(1) | | 471 | S_008014_CB0_BUSY(1) | S_008014_CB1_BUSY(1) | |
481 | S_008014_CB2_BUSY(1) | S_008014_CB3_BUSY(1); | 472 | S_008014_CB2_BUSY(1) | S_008014_CB3_BUSY(1); |
482 | u32 srbm_reset = 0; | 473 | u32 srbm_reset = 0; |
474 | u32 tmp; | ||
483 | 475 | ||
476 | dev_info(rdev->dev, "GPU softreset \n"); | ||
477 | dev_info(rdev->dev, " R_008010_GRBM_STATUS=0x%08X\n", | ||
478 | RREG32(R_008010_GRBM_STATUS)); | ||
479 | dev_info(rdev->dev, " R_008014_GRBM_STATUS2=0x%08X\n", | ||
480 | RREG32(R_008014_GRBM_STATUS2)); | ||
481 | dev_info(rdev->dev, " R_000E50_SRBM_STATUS=0x%08X\n", | ||
482 | RREG32(R_000E50_SRBM_STATUS)); | ||
483 | rv515_mc_stop(rdev, &save); | ||
484 | if (r600_mc_wait_for_idle(rdev)) { | ||
485 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); | ||
486 | } | ||
484 | /* Disable CP parsing/prefetching */ | 487 | /* Disable CP parsing/prefetching */ |
485 | WREG32(R_0086D8_CP_ME_CNTL, S_0086D8_CP_ME_HALT(0xff)); | 488 | WREG32(R_0086D8_CP_ME_CNTL, S_0086D8_CP_ME_HALT(0xff)); |
486 | /* Check if any of the rendering block is busy and reset it */ | 489 | /* Check if any of the rendering block is busy and reset it */ |
487 | if ((RREG32(R_008010_GRBM_STATUS) & grbm_busy_mask) || | 490 | if ((RREG32(R_008010_GRBM_STATUS) & grbm_busy_mask) || |
488 | (RREG32(R_008014_GRBM_STATUS2) & grbm2_busy_mask)) { | 491 | (RREG32(R_008014_GRBM_STATUS2) & grbm2_busy_mask)) { |
489 | WREG32(R_008020_GRBM_SOFT_RESET, S_008020_SOFT_RESET_CR(1) | | 492 | tmp = S_008020_SOFT_RESET_CR(1) | |
490 | S_008020_SOFT_RESET_DB(1) | | 493 | S_008020_SOFT_RESET_DB(1) | |
491 | S_008020_SOFT_RESET_CB(1) | | 494 | S_008020_SOFT_RESET_CB(1) | |
492 | S_008020_SOFT_RESET_PA(1) | | 495 | S_008020_SOFT_RESET_PA(1) | |
@@ -498,14 +501,18 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
498 | S_008020_SOFT_RESET_TC(1) | | 501 | S_008020_SOFT_RESET_TC(1) | |
499 | S_008020_SOFT_RESET_TA(1) | | 502 | S_008020_SOFT_RESET_TA(1) | |
500 | S_008020_SOFT_RESET_VC(1) | | 503 | S_008020_SOFT_RESET_VC(1) | |
501 | S_008020_SOFT_RESET_VGT(1)); | 504 | S_008020_SOFT_RESET_VGT(1); |
505 | dev_info(rdev->dev, " R_008020_GRBM_SOFT_RESET=0x%08X\n", tmp); | ||
506 | WREG32(R_008020_GRBM_SOFT_RESET, tmp); | ||
502 | (void)RREG32(R_008020_GRBM_SOFT_RESET); | 507 | (void)RREG32(R_008020_GRBM_SOFT_RESET); |
503 | udelay(50); | 508 | udelay(50); |
504 | WREG32(R_008020_GRBM_SOFT_RESET, 0); | 509 | WREG32(R_008020_GRBM_SOFT_RESET, 0); |
505 | (void)RREG32(R_008020_GRBM_SOFT_RESET); | 510 | (void)RREG32(R_008020_GRBM_SOFT_RESET); |
506 | } | 511 | } |
507 | /* Reset CP (we always reset CP) */ | 512 | /* Reset CP (we always reset CP) */ |
508 | WREG32(R_008020_GRBM_SOFT_RESET, S_008020_SOFT_RESET_CP(1)); | 513 | tmp = S_008020_SOFT_RESET_CP(1); |
514 | dev_info(rdev->dev, "R_008020_GRBM_SOFT_RESET=0x%08X\n", tmp); | ||
515 | WREG32(R_008020_GRBM_SOFT_RESET, tmp); | ||
509 | (void)RREG32(R_008020_GRBM_SOFT_RESET); | 516 | (void)RREG32(R_008020_GRBM_SOFT_RESET); |
510 | udelay(50); | 517 | udelay(50); |
511 | WREG32(R_008020_GRBM_SOFT_RESET, 0); | 518 | WREG32(R_008020_GRBM_SOFT_RESET, 0); |
@@ -533,6 +540,14 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
533 | srbm_reset |= S_000E60_SOFT_RESET_RLC(1); | 540 | srbm_reset |= S_000E60_SOFT_RESET_RLC(1); |
534 | if (G_000E50_SEM_BUSY(RREG32(R_000E50_SRBM_STATUS))) | 541 | if (G_000E50_SEM_BUSY(RREG32(R_000E50_SRBM_STATUS))) |
535 | srbm_reset |= S_000E60_SOFT_RESET_SEM(1); | 542 | srbm_reset |= S_000E60_SOFT_RESET_SEM(1); |
543 | if (G_000E50_BIF_BUSY(RREG32(R_000E50_SRBM_STATUS))) | ||
544 | srbm_reset |= S_000E60_SOFT_RESET_BIF(1); | ||
545 | dev_info(rdev->dev, " R_000E60_SRBM_SOFT_RESET=0x%08X\n", srbm_reset); | ||
546 | WREG32(R_000E60_SRBM_SOFT_RESET, srbm_reset); | ||
547 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | ||
548 | udelay(50); | ||
549 | WREG32(R_000E60_SRBM_SOFT_RESET, 0); | ||
550 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | ||
536 | WREG32(R_000E60_SRBM_SOFT_RESET, srbm_reset); | 551 | WREG32(R_000E60_SRBM_SOFT_RESET, srbm_reset); |
537 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | 552 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); |
538 | udelay(50); | 553 | udelay(50); |
@@ -540,6 +555,17 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
540 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | 555 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); |
541 | /* Wait a little for things to settle down */ | 556 | /* Wait a little for things to settle down */ |
542 | udelay(50); | 557 | udelay(50); |
558 | dev_info(rdev->dev, " R_008010_GRBM_STATUS=0x%08X\n", | ||
559 | RREG32(R_008010_GRBM_STATUS)); | ||
560 | dev_info(rdev->dev, " R_008014_GRBM_STATUS2=0x%08X\n", | ||
561 | RREG32(R_008014_GRBM_STATUS2)); | ||
562 | dev_info(rdev->dev, " R_000E50_SRBM_STATUS=0x%08X\n", | ||
563 | RREG32(R_000E50_SRBM_STATUS)); | ||
564 | /* After reset we need to reinit the asic as GPU often endup in an | ||
565 | * incoherent state. | ||
566 | */ | ||
567 | atom_asic_init(rdev->mode_info.atom_context); | ||
568 | rv515_mc_resume(rdev, &save); | ||
543 | return 0; | 569 | return 0; |
544 | } | 570 | } |
545 | 571 | ||
@@ -1350,32 +1376,47 @@ int r600_ring_test(struct radeon_device *rdev) | |||
1350 | return r; | 1376 | return r; |
1351 | } | 1377 | } |
1352 | 1378 | ||
1353 | /* | 1379 | void r600_wb_disable(struct radeon_device *rdev) |
1354 | * Writeback | 1380 | { |
1355 | */ | 1381 | WREG32(SCRATCH_UMSK, 0); |
1356 | int r600_wb_init(struct radeon_device *rdev) | 1382 | if (rdev->wb.wb_obj) { |
1383 | radeon_object_kunmap(rdev->wb.wb_obj); | ||
1384 | radeon_object_unpin(rdev->wb.wb_obj); | ||
1385 | } | ||
1386 | } | ||
1387 | |||
1388 | void r600_wb_fini(struct radeon_device *rdev) | ||
1389 | { | ||
1390 | r600_wb_disable(rdev); | ||
1391 | if (rdev->wb.wb_obj) { | ||
1392 | radeon_object_unref(&rdev->wb.wb_obj); | ||
1393 | rdev->wb.wb = NULL; | ||
1394 | rdev->wb.wb_obj = NULL; | ||
1395 | } | ||
1396 | } | ||
1397 | |||
1398 | int r600_wb_enable(struct radeon_device *rdev) | ||
1357 | { | 1399 | { |
1358 | int r; | 1400 | int r; |
1359 | 1401 | ||
1360 | if (rdev->wb.wb_obj == NULL) { | 1402 | if (rdev->wb.wb_obj == NULL) { |
1361 | r = radeon_object_create(rdev, NULL, 4096, | 1403 | r = radeon_object_create(rdev, NULL, 4096, true, |
1362 | true, | 1404 | RADEON_GEM_DOMAIN_GTT, false, &rdev->wb.wb_obj); |
1363 | RADEON_GEM_DOMAIN_GTT, | ||
1364 | false, &rdev->wb.wb_obj); | ||
1365 | if (r) { | 1405 | if (r) { |
1366 | DRM_ERROR("radeon: failed to create WB buffer (%d).\n", r); | 1406 | dev_warn(rdev->dev, "failed to create WB buffer (%d).\n", r); |
1367 | return r; | 1407 | return r; |
1368 | } | 1408 | } |
1369 | r = radeon_object_pin(rdev->wb.wb_obj, | 1409 | r = radeon_object_pin(rdev->wb.wb_obj, RADEON_GEM_DOMAIN_GTT, |
1370 | RADEON_GEM_DOMAIN_GTT, | 1410 | &rdev->wb.gpu_addr); |
1371 | &rdev->wb.gpu_addr); | ||
1372 | if (r) { | 1411 | if (r) { |
1373 | DRM_ERROR("radeon: failed to pin WB buffer (%d).\n", r); | 1412 | dev_warn(rdev->dev, "failed to pin WB buffer (%d).\n", r); |
1413 | r600_wb_fini(rdev); | ||
1374 | return r; | 1414 | return r; |
1375 | } | 1415 | } |
1376 | r = radeon_object_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb); | 1416 | r = radeon_object_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb); |
1377 | if (r) { | 1417 | if (r) { |
1378 | DRM_ERROR("radeon: failed to map WB buffer (%d).\n", r); | 1418 | dev_warn(rdev->dev, "failed to map WB buffer (%d).\n", r); |
1419 | r600_wb_fini(rdev); | ||
1379 | return r; | 1420 | return r; |
1380 | } | 1421 | } |
1381 | } | 1422 | } |
@@ -1386,21 +1427,6 @@ int r600_wb_init(struct radeon_device *rdev) | |||
1386 | return 0; | 1427 | return 0; |
1387 | } | 1428 | } |
1388 | 1429 | ||
1389 | void r600_wb_fini(struct radeon_device *rdev) | ||
1390 | { | ||
1391 | if (rdev->wb.wb_obj) { | ||
1392 | radeon_object_kunmap(rdev->wb.wb_obj); | ||
1393 | radeon_object_unpin(rdev->wb.wb_obj); | ||
1394 | radeon_object_unref(&rdev->wb.wb_obj); | ||
1395 | rdev->wb.wb = NULL; | ||
1396 | rdev->wb.wb_obj = NULL; | ||
1397 | } | ||
1398 | } | ||
1399 | |||
1400 | |||
1401 | /* | ||
1402 | * CS | ||
1403 | */ | ||
1404 | void r600_fence_ring_emit(struct radeon_device *rdev, | 1430 | void r600_fence_ring_emit(struct radeon_device *rdev, |
1405 | struct radeon_fence *fence) | 1431 | struct radeon_fence *fence) |
1406 | { | 1432 | { |
@@ -1477,11 +1503,14 @@ int r600_startup(struct radeon_device *rdev) | |||
1477 | { | 1503 | { |
1478 | int r; | 1504 | int r; |
1479 | 1505 | ||
1480 | r600_gpu_reset(rdev); | 1506 | r600_mc_program(rdev); |
1481 | r600_mc_resume(rdev); | 1507 | if (rdev->flags & RADEON_IS_AGP) { |
1482 | r = r600_pcie_gart_enable(rdev); | 1508 | r600_agp_enable(rdev); |
1483 | if (r) | 1509 | } else { |
1484 | return r; | 1510 | r = r600_pcie_gart_enable(rdev); |
1511 | if (r) | ||
1512 | return r; | ||
1513 | } | ||
1485 | r600_gpu_init(rdev); | 1514 | r600_gpu_init(rdev); |
1486 | 1515 | ||
1487 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, | 1516 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, |
@@ -1500,9 +1529,8 @@ int r600_startup(struct radeon_device *rdev) | |||
1500 | r = r600_cp_resume(rdev); | 1529 | r = r600_cp_resume(rdev); |
1501 | if (r) | 1530 | if (r) |
1502 | return r; | 1531 | return r; |
1503 | r = r600_wb_init(rdev); | 1532 | /* write back buffer are not vital so don't worry about failure */ |
1504 | if (r) | 1533 | r600_wb_enable(rdev); |
1505 | return r; | ||
1506 | return 0; | 1534 | return 0; |
1507 | } | 1535 | } |
1508 | 1536 | ||
@@ -1524,15 +1552,12 @@ int r600_resume(struct radeon_device *rdev) | |||
1524 | { | 1552 | { |
1525 | int r; | 1553 | int r; |
1526 | 1554 | ||
1527 | if (radeon_gpu_reset(rdev)) { | 1555 | /* Do not reset GPU before posting, on r600 hw unlike on r500 hw, |
1528 | /* FIXME: what do we want to do here ? */ | 1556 | * posting will perform necessary task to bring back GPU into good |
1529 | } | 1557 | * shape. |
1558 | */ | ||
1530 | /* post card */ | 1559 | /* post card */ |
1531 | if (rdev->is_atom_bios) { | 1560 | atom_asic_init(rdev->mode_info.atom_context); |
1532 | atom_asic_init(rdev->mode_info.atom_context); | ||
1533 | } else { | ||
1534 | radeon_combios_asic_init(rdev->ddev); | ||
1535 | } | ||
1536 | /* Initialize clocks */ | 1561 | /* Initialize clocks */ |
1537 | r = radeon_clocks_init(rdev); | 1562 | r = radeon_clocks_init(rdev); |
1538 | if (r) { | 1563 | if (r) { |
@@ -1545,7 +1570,7 @@ int r600_resume(struct radeon_device *rdev) | |||
1545 | return r; | 1570 | return r; |
1546 | } | 1571 | } |
1547 | 1572 | ||
1548 | r = radeon_ib_test(rdev); | 1573 | r = r600_ib_test(rdev); |
1549 | if (r) { | 1574 | if (r) { |
1550 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 1575 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
1551 | return r; | 1576 | return r; |
@@ -1553,13 +1578,12 @@ int r600_resume(struct radeon_device *rdev) | |||
1553 | return r; | 1578 | return r; |
1554 | } | 1579 | } |
1555 | 1580 | ||
1556 | |||
1557 | int r600_suspend(struct radeon_device *rdev) | 1581 | int r600_suspend(struct radeon_device *rdev) |
1558 | { | 1582 | { |
1559 | /* FIXME: we should wait for ring to be empty */ | 1583 | /* FIXME: we should wait for ring to be empty */ |
1560 | r600_cp_stop(rdev); | 1584 | r600_cp_stop(rdev); |
1561 | rdev->cp.ready = false; | 1585 | rdev->cp.ready = false; |
1562 | 1586 | r600_wb_disable(rdev); | |
1563 | r600_pcie_gart_disable(rdev); | 1587 | r600_pcie_gart_disable(rdev); |
1564 | /* unpin shaders bo */ | 1588 | /* unpin shaders bo */ |
1565 | radeon_object_unpin(rdev->r600_blit.shader_obj); | 1589 | radeon_object_unpin(rdev->r600_blit.shader_obj); |
@@ -1576,7 +1600,6 @@ int r600_init(struct radeon_device *rdev) | |||
1576 | { | 1600 | { |
1577 | int r; | 1601 | int r; |
1578 | 1602 | ||
1579 | rdev->new_init_path = true; | ||
1580 | r = radeon_dummy_page_init(rdev); | 1603 | r = radeon_dummy_page_init(rdev); |
1581 | if (r) | 1604 | if (r) |
1582 | return r; | 1605 | return r; |
@@ -1593,8 +1616,10 @@ int r600_init(struct radeon_device *rdev) | |||
1593 | return -EINVAL; | 1616 | return -EINVAL; |
1594 | } | 1617 | } |
1595 | /* Must be an ATOMBIOS */ | 1618 | /* Must be an ATOMBIOS */ |
1596 | if (!rdev->is_atom_bios) | 1619 | if (!rdev->is_atom_bios) { |
1620 | dev_err(rdev->dev, "Expecting atombios for R600 GPU\n"); | ||
1597 | return -EINVAL; | 1621 | return -EINVAL; |
1622 | } | ||
1598 | r = radeon_atombios_init(rdev); | 1623 | r = radeon_atombios_init(rdev); |
1599 | if (r) | 1624 | if (r) |
1600 | return r; | 1625 | return r; |
@@ -1616,15 +1641,8 @@ int r600_init(struct radeon_device *rdev) | |||
1616 | if (r) | 1641 | if (r) |
1617 | return r; | 1642 | return r; |
1618 | r = r600_mc_init(rdev); | 1643 | r = r600_mc_init(rdev); |
1619 | if (r) { | 1644 | if (r) |
1620 | if (rdev->flags & RADEON_IS_AGP) { | ||
1621 | /* Retry with disabling AGP */ | ||
1622 | r600_fini(rdev); | ||
1623 | rdev->flags &= ~RADEON_IS_AGP; | ||
1624 | return r600_init(rdev); | ||
1625 | } | ||
1626 | return r; | 1645 | return r; |
1627 | } | ||
1628 | /* Memory manager */ | 1646 | /* Memory manager */ |
1629 | r = radeon_object_init(rdev); | 1647 | r = radeon_object_init(rdev); |
1630 | if (r) | 1648 | if (r) |
@@ -1653,12 +1671,10 @@ int r600_init(struct radeon_device *rdev) | |||
1653 | 1671 | ||
1654 | r = r600_startup(rdev); | 1672 | r = r600_startup(rdev); |
1655 | if (r) { | 1673 | if (r) { |
1656 | if (rdev->flags & RADEON_IS_AGP) { | 1674 | r600_suspend(rdev); |
1657 | /* Retry with disabling AGP */ | 1675 | r600_wb_fini(rdev); |
1658 | r600_fini(rdev); | 1676 | radeon_ring_fini(rdev); |
1659 | rdev->flags &= ~RADEON_IS_AGP; | 1677 | r600_pcie_gart_fini(rdev); |
1660 | return r600_init(rdev); | ||
1661 | } | ||
1662 | rdev->accel_working = false; | 1678 | rdev->accel_working = false; |
1663 | } | 1679 | } |
1664 | if (rdev->accel_working) { | 1680 | if (rdev->accel_working) { |
@@ -1667,7 +1683,7 @@ int r600_init(struct radeon_device *rdev) | |||
1667 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); | 1683 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); |
1668 | rdev->accel_working = false; | 1684 | rdev->accel_working = false; |
1669 | } | 1685 | } |
1670 | r = radeon_ib_test(rdev); | 1686 | r = r600_ib_test(rdev); |
1671 | if (r) { | 1687 | if (r) { |
1672 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 1688 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
1673 | rdev->accel_working = false; | 1689 | rdev->accel_working = false; |
@@ -1683,19 +1699,15 @@ void r600_fini(struct radeon_device *rdev) | |||
1683 | 1699 | ||
1684 | r600_blit_fini(rdev); | 1700 | r600_blit_fini(rdev); |
1685 | radeon_ring_fini(rdev); | 1701 | radeon_ring_fini(rdev); |
1702 | r600_wb_fini(rdev); | ||
1686 | r600_pcie_gart_fini(rdev); | 1703 | r600_pcie_gart_fini(rdev); |
1687 | radeon_gem_fini(rdev); | 1704 | radeon_gem_fini(rdev); |
1688 | radeon_fence_driver_fini(rdev); | 1705 | radeon_fence_driver_fini(rdev); |
1689 | radeon_clocks_fini(rdev); | 1706 | radeon_clocks_fini(rdev); |
1690 | #if __OS_HAS_AGP | ||
1691 | if (rdev->flags & RADEON_IS_AGP) | 1707 | if (rdev->flags & RADEON_IS_AGP) |
1692 | radeon_agp_fini(rdev); | 1708 | radeon_agp_fini(rdev); |
1693 | #endif | ||
1694 | radeon_object_fini(rdev); | 1709 | radeon_object_fini(rdev); |
1695 | if (rdev->is_atom_bios) | 1710 | radeon_atombios_fini(rdev); |
1696 | radeon_atombios_fini(rdev); | ||
1697 | else | ||
1698 | radeon_combios_fini(rdev); | ||
1699 | kfree(rdev->bios); | 1711 | kfree(rdev->bios); |
1700 | rdev->bios = NULL; | 1712 | rdev->bios = NULL; |
1701 | radeon_dummy_page_fini(rdev); | 1713 | radeon_dummy_page_fini(rdev); |
diff --git a/drivers/gpu/drm/radeon/r600_blit.c b/drivers/gpu/drm/radeon/r600_blit.c index d988eece0187..dec501081608 100644 --- a/drivers/gpu/drm/radeon/r600_blit.c +++ b/drivers/gpu/drm/radeon/r600_blit.c | |||
@@ -582,8 +582,6 @@ r600_blit_copy(struct drm_device *dev, | |||
582 | u64 vb_addr; | 582 | u64 vb_addr; |
583 | u32 *vb; | 583 | u32 *vb; |
584 | 584 | ||
585 | vb = r600_nomm_get_vb_ptr(dev); | ||
586 | |||
587 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { | 585 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { |
588 | max_bytes = 8192; | 586 | max_bytes = 8192; |
589 | 587 | ||
@@ -619,8 +617,8 @@ r600_blit_copy(struct drm_device *dev, | |||
619 | if (!dev_priv->blit_vb) | 617 | if (!dev_priv->blit_vb) |
620 | return; | 618 | return; |
621 | set_shaders(dev); | 619 | set_shaders(dev); |
622 | vb = r600_nomm_get_vb_ptr(dev); | ||
623 | } | 620 | } |
621 | vb = r600_nomm_get_vb_ptr(dev); | ||
624 | 622 | ||
625 | vb[0] = i2f(dst_x); | 623 | vb[0] = i2f(dst_x); |
626 | vb[1] = 0; | 624 | vb[1] = 0; |
@@ -708,8 +706,8 @@ r600_blit_copy(struct drm_device *dev, | |||
708 | return; | 706 | return; |
709 | 707 | ||
710 | set_shaders(dev); | 708 | set_shaders(dev); |
711 | vb = r600_nomm_get_vb_ptr(dev); | ||
712 | } | 709 | } |
710 | vb = r600_nomm_get_vb_ptr(dev); | ||
713 | 711 | ||
714 | vb[0] = i2f(dst_x / 4); | 712 | vb[0] = i2f(dst_x / 4); |
715 | vb[1] = 0; | 713 | vb[1] = 0; |
@@ -777,8 +775,6 @@ r600_blit_swap(struct drm_device *dev, | |||
777 | u64 vb_addr; | 775 | u64 vb_addr; |
778 | u32 *vb; | 776 | u32 *vb; |
779 | 777 | ||
780 | vb = r600_nomm_get_vb_ptr(dev); | ||
781 | |||
782 | if ((dev_priv->blit_vb->used + 48) > dev_priv->blit_vb->total) { | 778 | if ((dev_priv->blit_vb->used + 48) > dev_priv->blit_vb->total) { |
783 | 779 | ||
784 | r600_nomm_put_vb(dev); | 780 | r600_nomm_put_vb(dev); |
@@ -787,8 +783,8 @@ r600_blit_swap(struct drm_device *dev, | |||
787 | return; | 783 | return; |
788 | 784 | ||
789 | set_shaders(dev); | 785 | set_shaders(dev); |
790 | vb = r600_nomm_get_vb_ptr(dev); | ||
791 | } | 786 | } |
787 | vb = r600_nomm_get_vb_ptr(dev); | ||
792 | 788 | ||
793 | if (cpp == 4) { | 789 | if (cpp == 4) { |
794 | cb_format = COLOR_8_8_8_8; | 790 | cb_format = COLOR_8_8_8_8; |
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c index acae33e2ad51..93108bb31d1d 100644 --- a/drivers/gpu/drm/radeon/r600_blit_kms.c +++ b/drivers/gpu/drm/radeon/r600_blit_kms.c | |||
@@ -610,7 +610,6 @@ void r600_kms_blit_copy(struct radeon_device *rdev, | |||
610 | 610 | ||
611 | DRM_DEBUG("emitting copy %16llx %16llx %d %d\n", src_gpu_addr, dst_gpu_addr, | 611 | DRM_DEBUG("emitting copy %16llx %16llx %d %d\n", src_gpu_addr, dst_gpu_addr, |
612 | size_bytes, rdev->r600_blit.vb_used); | 612 | size_bytes, rdev->r600_blit.vb_used); |
613 | vb = (u32 *)(rdev->r600_blit.vb_ib->ptr + rdev->r600_blit.vb_used); | ||
614 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { | 613 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { |
615 | max_bytes = 8192; | 614 | max_bytes = 8192; |
616 | 615 | ||
@@ -653,6 +652,7 @@ void r600_kms_blit_copy(struct radeon_device *rdev, | |||
653 | vb = r600_nomm_get_vb_ptr(dev); | 652 | vb = r600_nomm_get_vb_ptr(dev); |
654 | #endif | 653 | #endif |
655 | } | 654 | } |
655 | vb = (u32 *)(rdev->r600_blit.vb_ib->ptr + rdev->r600_blit.vb_used); | ||
656 | 656 | ||
657 | vb[0] = i2f(dst_x); | 657 | vb[0] = i2f(dst_x); |
658 | vb[1] = 0; | 658 | vb[1] = 0; |
@@ -747,6 +747,7 @@ void r600_kms_blit_copy(struct radeon_device *rdev, | |||
747 | vb = r600_nomm_get_vb_ptr(dev); | 747 | vb = r600_nomm_get_vb_ptr(dev); |
748 | } | 748 | } |
749 | #endif | 749 | #endif |
750 | vb = (u32 *)(rdev->r600_blit.vb_ib->ptr + rdev->r600_blit.vb_used); | ||
750 | 751 | ||
751 | vb[0] = i2f(dst_x / 4); | 752 | vb[0] = i2f(dst_x / 4); |
752 | vb[1] = 0; | 753 | vb[1] = 0; |
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c index d28970db6a2d..17e42195c632 100644 --- a/drivers/gpu/drm/radeon/r600_cs.c +++ b/drivers/gpu/drm/radeon/r600_cs.c | |||
@@ -252,7 +252,7 @@ static int r600_cs_packet_parse_vline(struct radeon_cs_parser *p) | |||
252 | 252 | ||
253 | header = radeon_get_ib_value(p, h_idx); | 253 | header = radeon_get_ib_value(p, h_idx); |
254 | crtc_id = radeon_get_ib_value(p, h_idx + 2 + 7 + 1); | 254 | crtc_id = radeon_get_ib_value(p, h_idx + 2 + 7 + 1); |
255 | reg = header >> 2; | 255 | reg = CP_PACKET0_GET_REG(header); |
256 | mutex_lock(&p->rdev->ddev->mode_config.mutex); | 256 | mutex_lock(&p->rdev->ddev->mode_config.mutex); |
257 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); | 257 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); |
258 | if (!obj) { | 258 | if (!obj) { |
diff --git a/drivers/gpu/drm/radeon/r600d.h b/drivers/gpu/drm/radeon/r600d.h index 4a9028a85c9b..9b64d47f1f82 100644 --- a/drivers/gpu/drm/radeon/r600d.h +++ b/drivers/gpu/drm/radeon/r600d.h | |||
@@ -643,6 +643,7 @@ | |||
643 | #define G_000E50_MCDW_BUSY(x) (((x) >> 13) & 1) | 643 | #define G_000E50_MCDW_BUSY(x) (((x) >> 13) & 1) |
644 | #define G_000E50_SEM_BUSY(x) (((x) >> 14) & 1) | 644 | #define G_000E50_SEM_BUSY(x) (((x) >> 14) & 1) |
645 | #define G_000E50_RLC_BUSY(x) (((x) >> 15) & 1) | 645 | #define G_000E50_RLC_BUSY(x) (((x) >> 15) & 1) |
646 | #define G_000E50_BIF_BUSY(x) (((x) >> 29) & 1) | ||
646 | #define R_000E60_SRBM_SOFT_RESET 0x0E60 | 647 | #define R_000E60_SRBM_SOFT_RESET 0x0E60 |
647 | #define S_000E60_SOFT_RESET_BIF(x) (((x) & 1) << 1) | 648 | #define S_000E60_SOFT_RESET_BIF(x) (((x) & 1) << 1) |
648 | #define S_000E60_SOFT_RESET_CG(x) (((x) & 1) << 2) | 649 | #define S_000E60_SOFT_RESET_CG(x) (((x) & 1) << 2) |
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h index 950b346e343f..5ab35b81c86b 100644 --- a/drivers/gpu/drm/radeon/radeon.h +++ b/drivers/gpu/drm/radeon/radeon.h | |||
@@ -590,18 +590,8 @@ struct radeon_asic { | |||
590 | void (*fini)(struct radeon_device *rdev); | 590 | void (*fini)(struct radeon_device *rdev); |
591 | int (*resume)(struct radeon_device *rdev); | 591 | int (*resume)(struct radeon_device *rdev); |
592 | int (*suspend)(struct radeon_device *rdev); | 592 | int (*suspend)(struct radeon_device *rdev); |
593 | void (*errata)(struct radeon_device *rdev); | ||
594 | void (*vram_info)(struct radeon_device *rdev); | ||
595 | void (*vga_set_state)(struct radeon_device *rdev, bool state); | 593 | void (*vga_set_state)(struct radeon_device *rdev, bool state); |
596 | int (*gpu_reset)(struct radeon_device *rdev); | 594 | int (*gpu_reset)(struct radeon_device *rdev); |
597 | int (*mc_init)(struct radeon_device *rdev); | ||
598 | void (*mc_fini)(struct radeon_device *rdev); | ||
599 | int (*wb_init)(struct radeon_device *rdev); | ||
600 | void (*wb_fini)(struct radeon_device *rdev); | ||
601 | int (*gart_init)(struct radeon_device *rdev); | ||
602 | void (*gart_fini)(struct radeon_device *rdev); | ||
603 | int (*gart_enable)(struct radeon_device *rdev); | ||
604 | void (*gart_disable)(struct radeon_device *rdev); | ||
605 | void (*gart_tlb_flush)(struct radeon_device *rdev); | 595 | void (*gart_tlb_flush)(struct radeon_device *rdev); |
606 | int (*gart_set_page)(struct radeon_device *rdev, int i, uint64_t addr); | 596 | int (*gart_set_page)(struct radeon_device *rdev, int i, uint64_t addr); |
607 | int (*cp_init)(struct radeon_device *rdev, unsigned ring_size); | 597 | int (*cp_init)(struct radeon_device *rdev, unsigned ring_size); |
@@ -611,7 +601,6 @@ struct radeon_asic { | |||
611 | void (*ring_start)(struct radeon_device *rdev); | 601 | void (*ring_start)(struct radeon_device *rdev); |
612 | int (*ring_test)(struct radeon_device *rdev); | 602 | int (*ring_test)(struct radeon_device *rdev); |
613 | void (*ring_ib_execute)(struct radeon_device *rdev, struct radeon_ib *ib); | 603 | void (*ring_ib_execute)(struct radeon_device *rdev, struct radeon_ib *ib); |
614 | int (*ib_test)(struct radeon_device *rdev); | ||
615 | int (*irq_set)(struct radeon_device *rdev); | 604 | int (*irq_set)(struct radeon_device *rdev); |
616 | int (*irq_process)(struct radeon_device *rdev); | 605 | int (*irq_process)(struct radeon_device *rdev); |
617 | u32 (*get_vblank_counter)(struct radeon_device *rdev, int crtc); | 606 | u32 (*get_vblank_counter)(struct radeon_device *rdev, int crtc); |
@@ -789,7 +778,6 @@ struct radeon_device { | |||
789 | bool shutdown; | 778 | bool shutdown; |
790 | bool suspend; | 779 | bool suspend; |
791 | bool need_dma32; | 780 | bool need_dma32; |
792 | bool new_init_path; | ||
793 | bool accel_working; | 781 | bool accel_working; |
794 | struct radeon_surface_reg surface_regs[RADEON_GEM_MAX_SURFACES]; | 782 | struct radeon_surface_reg surface_regs[RADEON_GEM_MAX_SURFACES]; |
795 | const struct firmware *me_fw; /* all family ME firmware */ | 783 | const struct firmware *me_fw; /* all family ME firmware */ |
@@ -949,28 +937,14 @@ static inline void radeon_ring_write(struct radeon_device *rdev, uint32_t v) | |||
949 | #define radeon_resume(rdev) (rdev)->asic->resume((rdev)) | 937 | #define radeon_resume(rdev) (rdev)->asic->resume((rdev)) |
950 | #define radeon_suspend(rdev) (rdev)->asic->suspend((rdev)) | 938 | #define radeon_suspend(rdev) (rdev)->asic->suspend((rdev)) |
951 | #define radeon_cs_parse(p) rdev->asic->cs_parse((p)) | 939 | #define radeon_cs_parse(p) rdev->asic->cs_parse((p)) |
952 | #define radeon_errata(rdev) (rdev)->asic->errata((rdev)) | ||
953 | #define radeon_vram_info(rdev) (rdev)->asic->vram_info((rdev)) | ||
954 | #define radeon_vga_set_state(rdev, state) (rdev)->asic->vga_set_state((rdev), (state)) | 940 | #define radeon_vga_set_state(rdev, state) (rdev)->asic->vga_set_state((rdev), (state)) |
955 | #define radeon_gpu_reset(rdev) (rdev)->asic->gpu_reset((rdev)) | 941 | #define radeon_gpu_reset(rdev) (rdev)->asic->gpu_reset((rdev)) |
956 | #define radeon_mc_init(rdev) (rdev)->asic->mc_init((rdev)) | ||
957 | #define radeon_mc_fini(rdev) (rdev)->asic->mc_fini((rdev)) | ||
958 | #define radeon_wb_init(rdev) (rdev)->asic->wb_init((rdev)) | ||
959 | #define radeon_wb_fini(rdev) (rdev)->asic->wb_fini((rdev)) | ||
960 | #define radeon_gpu_gart_init(rdev) (rdev)->asic->gart_init((rdev)) | ||
961 | #define radeon_gpu_gart_fini(rdev) (rdev)->asic->gart_fini((rdev)) | ||
962 | #define radeon_gart_enable(rdev) (rdev)->asic->gart_enable((rdev)) | ||
963 | #define radeon_gart_disable(rdev) (rdev)->asic->gart_disable((rdev)) | ||
964 | #define radeon_gart_tlb_flush(rdev) (rdev)->asic->gart_tlb_flush((rdev)) | 942 | #define radeon_gart_tlb_flush(rdev) (rdev)->asic->gart_tlb_flush((rdev)) |
965 | #define radeon_gart_set_page(rdev, i, p) (rdev)->asic->gart_set_page((rdev), (i), (p)) | 943 | #define radeon_gart_set_page(rdev, i, p) (rdev)->asic->gart_set_page((rdev), (i), (p)) |
966 | #define radeon_cp_init(rdev,rsize) (rdev)->asic->cp_init((rdev), (rsize)) | ||
967 | #define radeon_cp_fini(rdev) (rdev)->asic->cp_fini((rdev)) | ||
968 | #define radeon_cp_disable(rdev) (rdev)->asic->cp_disable((rdev)) | ||
969 | #define radeon_cp_commit(rdev) (rdev)->asic->cp_commit((rdev)) | 944 | #define radeon_cp_commit(rdev) (rdev)->asic->cp_commit((rdev)) |
970 | #define radeon_ring_start(rdev) (rdev)->asic->ring_start((rdev)) | 945 | #define radeon_ring_start(rdev) (rdev)->asic->ring_start((rdev)) |
971 | #define radeon_ring_test(rdev) (rdev)->asic->ring_test((rdev)) | 946 | #define radeon_ring_test(rdev) (rdev)->asic->ring_test((rdev)) |
972 | #define radeon_ring_ib_execute(rdev, ib) (rdev)->asic->ring_ib_execute((rdev), (ib)) | 947 | #define radeon_ring_ib_execute(rdev, ib) (rdev)->asic->ring_ib_execute((rdev), (ib)) |
973 | #define radeon_ib_test(rdev) (rdev)->asic->ib_test((rdev)) | ||
974 | #define radeon_irq_set(rdev) (rdev)->asic->irq_set((rdev)) | 948 | #define radeon_irq_set(rdev) (rdev)->asic->irq_set((rdev)) |
975 | #define radeon_irq_process(rdev) (rdev)->asic->irq_process((rdev)) | 949 | #define radeon_irq_process(rdev) (rdev)->asic->irq_process((rdev)) |
976 | #define radeon_get_vblank_counter(rdev, crtc) (rdev)->asic->get_vblank_counter((rdev), (crtc)) | 950 | #define radeon_get_vblank_counter(rdev, crtc) (rdev)->asic->get_vblank_counter((rdev), (crtc)) |
@@ -996,6 +970,7 @@ extern void radeon_clocks_fini(struct radeon_device *rdev); | |||
996 | extern void radeon_scratch_init(struct radeon_device *rdev); | 970 | extern void radeon_scratch_init(struct radeon_device *rdev); |
997 | extern void radeon_surface_init(struct radeon_device *rdev); | 971 | extern void radeon_surface_init(struct radeon_device *rdev); |
998 | extern int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data); | 972 | extern int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data); |
973 | extern void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable); | ||
999 | extern void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); | 974 | extern void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); |
1000 | 975 | ||
1001 | /* r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 */ | 976 | /* r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 */ |
@@ -1031,11 +1006,27 @@ extern int r100_wb_init(struct radeon_device *rdev); | |||
1031 | extern void r100_hdp_reset(struct radeon_device *rdev); | 1006 | extern void r100_hdp_reset(struct radeon_device *rdev); |
1032 | extern int r100_rb2d_reset(struct radeon_device *rdev); | 1007 | extern int r100_rb2d_reset(struct radeon_device *rdev); |
1033 | extern int r100_cp_reset(struct radeon_device *rdev); | 1008 | extern int r100_cp_reset(struct radeon_device *rdev); |
1009 | extern void r100_vga_render_disable(struct radeon_device *rdev); | ||
1010 | extern int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p, | ||
1011 | struct radeon_cs_packet *pkt, | ||
1012 | struct radeon_object *robj); | ||
1013 | extern int r100_cs_parse_packet0(struct radeon_cs_parser *p, | ||
1014 | struct radeon_cs_packet *pkt, | ||
1015 | const unsigned *auth, unsigned n, | ||
1016 | radeon_packet0_check_t check); | ||
1017 | extern int r100_cs_packet_parse(struct radeon_cs_parser *p, | ||
1018 | struct radeon_cs_packet *pkt, | ||
1019 | unsigned idx); | ||
1020 | |||
1021 | /* rv200,rv250,rv280 */ | ||
1022 | extern void r200_set_safe_registers(struct radeon_device *rdev); | ||
1034 | 1023 | ||
1035 | /* r300,r350,rv350,rv370,rv380 */ | 1024 | /* r300,r350,rv350,rv370,rv380 */ |
1036 | extern void r300_set_reg_safe(struct radeon_device *rdev); | 1025 | extern void r300_set_reg_safe(struct radeon_device *rdev); |
1037 | extern void r300_mc_program(struct radeon_device *rdev); | 1026 | extern void r300_mc_program(struct radeon_device *rdev); |
1038 | extern void r300_vram_info(struct radeon_device *rdev); | 1027 | extern void r300_vram_info(struct radeon_device *rdev); |
1028 | extern void r300_clock_startup(struct radeon_device *rdev); | ||
1029 | extern int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
1039 | extern int rv370_pcie_gart_init(struct radeon_device *rdev); | 1030 | extern int rv370_pcie_gart_init(struct radeon_device *rdev); |
1040 | extern void rv370_pcie_gart_fini(struct radeon_device *rdev); | 1031 | extern void rv370_pcie_gart_fini(struct radeon_device *rdev); |
1041 | extern int rv370_pcie_gart_enable(struct radeon_device *rdev); | 1032 | extern int rv370_pcie_gart_enable(struct radeon_device *rdev); |
@@ -1066,6 +1057,18 @@ extern void rv515_clock_startup(struct radeon_device *rdev); | |||
1066 | extern void rv515_debugfs(struct radeon_device *rdev); | 1057 | extern void rv515_debugfs(struct radeon_device *rdev); |
1067 | extern int rv515_suspend(struct radeon_device *rdev); | 1058 | extern int rv515_suspend(struct radeon_device *rdev); |
1068 | 1059 | ||
1060 | /* rs400 */ | ||
1061 | extern int rs400_gart_init(struct radeon_device *rdev); | ||
1062 | extern int rs400_gart_enable(struct radeon_device *rdev); | ||
1063 | extern void rs400_gart_adjust_size(struct radeon_device *rdev); | ||
1064 | extern void rs400_gart_disable(struct radeon_device *rdev); | ||
1065 | extern void rs400_gart_fini(struct radeon_device *rdev); | ||
1066 | |||
1067 | /* rs600 */ | ||
1068 | extern void rs600_set_safe_registers(struct radeon_device *rdev); | ||
1069 | extern int rs600_irq_set(struct radeon_device *rdev); | ||
1070 | extern void rs600_irq_disable(struct radeon_device *rdev); | ||
1071 | |||
1069 | /* rs690, rs740 */ | 1072 | /* rs690, rs740 */ |
1070 | extern void rs690_line_buffer_adjust(struct radeon_device *rdev, | 1073 | extern void rs690_line_buffer_adjust(struct radeon_device *rdev, |
1071 | struct drm_display_mode *mode1, | 1074 | struct drm_display_mode *mode1, |
@@ -1083,8 +1086,9 @@ extern int r600_pcie_gart_init(struct radeon_device *rdev); | |||
1083 | extern void r600_pcie_gart_tlb_flush(struct radeon_device *rdev); | 1086 | extern void r600_pcie_gart_tlb_flush(struct radeon_device *rdev); |
1084 | extern int r600_ib_test(struct radeon_device *rdev); | 1087 | extern int r600_ib_test(struct radeon_device *rdev); |
1085 | extern int r600_ring_test(struct radeon_device *rdev); | 1088 | extern int r600_ring_test(struct radeon_device *rdev); |
1086 | extern int r600_wb_init(struct radeon_device *rdev); | ||
1087 | extern void r600_wb_fini(struct radeon_device *rdev); | 1089 | extern void r600_wb_fini(struct radeon_device *rdev); |
1090 | extern int r600_wb_enable(struct radeon_device *rdev); | ||
1091 | extern void r600_wb_disable(struct radeon_device *rdev); | ||
1088 | extern void r600_scratch_init(struct radeon_device *rdev); | 1092 | extern void r600_scratch_init(struct radeon_device *rdev); |
1089 | extern int r600_blit_init(struct radeon_device *rdev); | 1093 | extern int r600_blit_init(struct radeon_device *rdev); |
1090 | extern void r600_blit_fini(struct radeon_device *rdev); | 1094 | extern void r600_blit_fini(struct radeon_device *rdev); |
diff --git a/drivers/gpu/drm/radeon/radeon_asic.h b/drivers/gpu/drm/radeon/radeon_asic.h index c8a4e7b5663d..c3532c7a6f3f 100644 --- a/drivers/gpu/drm/radeon/radeon_asic.h +++ b/drivers/gpu/drm/radeon/radeon_asic.h | |||
@@ -41,28 +41,17 @@ void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); | |||
41 | /* | 41 | /* |
42 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 | 42 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 |
43 | */ | 43 | */ |
44 | int r100_init(struct radeon_device *rdev); | 44 | extern int r100_init(struct radeon_device *rdev); |
45 | int r200_init(struct radeon_device *rdev); | 45 | extern void r100_fini(struct radeon_device *rdev); |
46 | extern int r100_suspend(struct radeon_device *rdev); | ||
47 | extern int r100_resume(struct radeon_device *rdev); | ||
46 | uint32_t r100_mm_rreg(struct radeon_device *rdev, uint32_t reg); | 48 | uint32_t r100_mm_rreg(struct radeon_device *rdev, uint32_t reg); |
47 | void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 49 | void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
48 | void r100_errata(struct radeon_device *rdev); | ||
49 | void r100_vram_info(struct radeon_device *rdev); | ||
50 | void r100_vga_set_state(struct radeon_device *rdev, bool state); | 50 | void r100_vga_set_state(struct radeon_device *rdev, bool state); |
51 | int r100_gpu_reset(struct radeon_device *rdev); | 51 | int r100_gpu_reset(struct radeon_device *rdev); |
52 | int r100_mc_init(struct radeon_device *rdev); | ||
53 | void r100_mc_fini(struct radeon_device *rdev); | ||
54 | u32 r100_get_vblank_counter(struct radeon_device *rdev, int crtc); | 52 | u32 r100_get_vblank_counter(struct radeon_device *rdev, int crtc); |
55 | int r100_wb_init(struct radeon_device *rdev); | ||
56 | void r100_wb_fini(struct radeon_device *rdev); | ||
57 | int r100_pci_gart_init(struct radeon_device *rdev); | ||
58 | void r100_pci_gart_fini(struct radeon_device *rdev); | ||
59 | int r100_pci_gart_enable(struct radeon_device *rdev); | ||
60 | void r100_pci_gart_disable(struct radeon_device *rdev); | ||
61 | void r100_pci_gart_tlb_flush(struct radeon_device *rdev); | 53 | void r100_pci_gart_tlb_flush(struct radeon_device *rdev); |
62 | int r100_pci_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 54 | int r100_pci_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
63 | int r100_cp_init(struct radeon_device *rdev, unsigned ring_size); | ||
64 | void r100_cp_fini(struct radeon_device *rdev); | ||
65 | void r100_cp_disable(struct radeon_device *rdev); | ||
66 | void r100_cp_commit(struct radeon_device *rdev); | 55 | void r100_cp_commit(struct radeon_device *rdev); |
67 | void r100_ring_start(struct radeon_device *rdev); | 56 | void r100_ring_start(struct radeon_device *rdev); |
68 | int r100_irq_set(struct radeon_device *rdev); | 57 | int r100_irq_set(struct radeon_device *rdev); |
@@ -83,33 +72,21 @@ int r100_set_surface_reg(struct radeon_device *rdev, int reg, | |||
83 | int r100_clear_surface_reg(struct radeon_device *rdev, int reg); | 72 | int r100_clear_surface_reg(struct radeon_device *rdev, int reg); |
84 | void r100_bandwidth_update(struct radeon_device *rdev); | 73 | void r100_bandwidth_update(struct radeon_device *rdev); |
85 | void r100_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); | 74 | void r100_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); |
86 | int r100_ib_test(struct radeon_device *rdev); | ||
87 | int r100_ring_test(struct radeon_device *rdev); | 75 | int r100_ring_test(struct radeon_device *rdev); |
88 | 76 | ||
89 | static struct radeon_asic r100_asic = { | 77 | static struct radeon_asic r100_asic = { |
90 | .init = &r100_init, | 78 | .init = &r100_init, |
91 | .errata = &r100_errata, | 79 | .fini = &r100_fini, |
92 | .vram_info = &r100_vram_info, | 80 | .suspend = &r100_suspend, |
81 | .resume = &r100_resume, | ||
93 | .vga_set_state = &r100_vga_set_state, | 82 | .vga_set_state = &r100_vga_set_state, |
94 | .gpu_reset = &r100_gpu_reset, | 83 | .gpu_reset = &r100_gpu_reset, |
95 | .mc_init = &r100_mc_init, | ||
96 | .mc_fini = &r100_mc_fini, | ||
97 | .wb_init = &r100_wb_init, | ||
98 | .wb_fini = &r100_wb_fini, | ||
99 | .gart_init = &r100_pci_gart_init, | ||
100 | .gart_fini = &r100_pci_gart_fini, | ||
101 | .gart_enable = &r100_pci_gart_enable, | ||
102 | .gart_disable = &r100_pci_gart_disable, | ||
103 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, | 84 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, |
104 | .gart_set_page = &r100_pci_gart_set_page, | 85 | .gart_set_page = &r100_pci_gart_set_page, |
105 | .cp_init = &r100_cp_init, | ||
106 | .cp_fini = &r100_cp_fini, | ||
107 | .cp_disable = &r100_cp_disable, | ||
108 | .cp_commit = &r100_cp_commit, | 86 | .cp_commit = &r100_cp_commit, |
109 | .ring_start = &r100_ring_start, | 87 | .ring_start = &r100_ring_start, |
110 | .ring_test = &r100_ring_test, | 88 | .ring_test = &r100_ring_test, |
111 | .ring_ib_execute = &r100_ring_ib_execute, | 89 | .ring_ib_execute = &r100_ring_ib_execute, |
112 | .ib_test = &r100_ib_test, | ||
113 | .irq_set = &r100_irq_set, | 90 | .irq_set = &r100_irq_set, |
114 | .irq_process = &r100_irq_process, | 91 | .irq_process = &r100_irq_process, |
115 | .get_vblank_counter = &r100_get_vblank_counter, | 92 | .get_vblank_counter = &r100_get_vblank_counter, |
@@ -131,55 +108,38 @@ static struct radeon_asic r100_asic = { | |||
131 | /* | 108 | /* |
132 | * r300,r350,rv350,rv380 | 109 | * r300,r350,rv350,rv380 |
133 | */ | 110 | */ |
134 | int r300_init(struct radeon_device *rdev); | 111 | extern int r300_init(struct radeon_device *rdev); |
135 | void r300_errata(struct radeon_device *rdev); | 112 | extern void r300_fini(struct radeon_device *rdev); |
136 | void r300_vram_info(struct radeon_device *rdev); | 113 | extern int r300_suspend(struct radeon_device *rdev); |
137 | int r300_gpu_reset(struct radeon_device *rdev); | 114 | extern int r300_resume(struct radeon_device *rdev); |
138 | int r300_mc_init(struct radeon_device *rdev); | 115 | extern int r300_gpu_reset(struct radeon_device *rdev); |
139 | void r300_mc_fini(struct radeon_device *rdev); | 116 | extern void r300_ring_start(struct radeon_device *rdev); |
140 | void r300_ring_start(struct radeon_device *rdev); | 117 | extern void r300_fence_ring_emit(struct radeon_device *rdev, |
141 | void r300_fence_ring_emit(struct radeon_device *rdev, | 118 | struct radeon_fence *fence); |
142 | struct radeon_fence *fence); | 119 | extern int r300_cs_parse(struct radeon_cs_parser *p); |
143 | int r300_cs_parse(struct radeon_cs_parser *p); | 120 | extern void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev); |
144 | int rv370_pcie_gart_init(struct radeon_device *rdev); | 121 | extern int rv370_pcie_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
145 | void rv370_pcie_gart_fini(struct radeon_device *rdev); | 122 | extern uint32_t rv370_pcie_rreg(struct radeon_device *rdev, uint32_t reg); |
146 | int rv370_pcie_gart_enable(struct radeon_device *rdev); | 123 | extern void rv370_pcie_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
147 | void rv370_pcie_gart_disable(struct radeon_device *rdev); | 124 | extern void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes); |
148 | void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev); | 125 | extern int r300_copy_dma(struct radeon_device *rdev, |
149 | int rv370_pcie_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 126 | uint64_t src_offset, |
150 | uint32_t rv370_pcie_rreg(struct radeon_device *rdev, uint32_t reg); | 127 | uint64_t dst_offset, |
151 | void rv370_pcie_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 128 | unsigned num_pages, |
152 | void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes); | 129 | struct radeon_fence *fence); |
153 | int r300_copy_dma(struct radeon_device *rdev, | ||
154 | uint64_t src_offset, | ||
155 | uint64_t dst_offset, | ||
156 | unsigned num_pages, | ||
157 | struct radeon_fence *fence); | ||
158 | |||
159 | static struct radeon_asic r300_asic = { | 130 | static struct radeon_asic r300_asic = { |
160 | .init = &r300_init, | 131 | .init = &r300_init, |
161 | .errata = &r300_errata, | 132 | .fini = &r300_fini, |
162 | .vram_info = &r300_vram_info, | 133 | .suspend = &r300_suspend, |
134 | .resume = &r300_resume, | ||
163 | .vga_set_state = &r100_vga_set_state, | 135 | .vga_set_state = &r100_vga_set_state, |
164 | .gpu_reset = &r300_gpu_reset, | 136 | .gpu_reset = &r300_gpu_reset, |
165 | .mc_init = &r300_mc_init, | ||
166 | .mc_fini = &r300_mc_fini, | ||
167 | .wb_init = &r100_wb_init, | ||
168 | .wb_fini = &r100_wb_fini, | ||
169 | .gart_init = &r100_pci_gart_init, | ||
170 | .gart_fini = &r100_pci_gart_fini, | ||
171 | .gart_enable = &r100_pci_gart_enable, | ||
172 | .gart_disable = &r100_pci_gart_disable, | ||
173 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, | 137 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, |
174 | .gart_set_page = &r100_pci_gart_set_page, | 138 | .gart_set_page = &r100_pci_gart_set_page, |
175 | .cp_init = &r100_cp_init, | ||
176 | .cp_fini = &r100_cp_fini, | ||
177 | .cp_disable = &r100_cp_disable, | ||
178 | .cp_commit = &r100_cp_commit, | 139 | .cp_commit = &r100_cp_commit, |
179 | .ring_start = &r300_ring_start, | 140 | .ring_start = &r300_ring_start, |
180 | .ring_test = &r100_ring_test, | 141 | .ring_test = &r100_ring_test, |
181 | .ring_ib_execute = &r100_ring_ib_execute, | 142 | .ring_ib_execute = &r100_ring_ib_execute, |
182 | .ib_test = &r100_ib_test, | ||
183 | .irq_set = &r100_irq_set, | 143 | .irq_set = &r100_irq_set, |
184 | .irq_process = &r100_irq_process, | 144 | .irq_process = &r100_irq_process, |
185 | .get_vblank_counter = &r100_get_vblank_counter, | 145 | .get_vblank_counter = &r100_get_vblank_counter, |
@@ -209,26 +169,14 @@ static struct radeon_asic r420_asic = { | |||
209 | .fini = &r420_fini, | 169 | .fini = &r420_fini, |
210 | .suspend = &r420_suspend, | 170 | .suspend = &r420_suspend, |
211 | .resume = &r420_resume, | 171 | .resume = &r420_resume, |
212 | .errata = NULL, | ||
213 | .vram_info = NULL, | ||
214 | .vga_set_state = &r100_vga_set_state, | 172 | .vga_set_state = &r100_vga_set_state, |
215 | .gpu_reset = &r300_gpu_reset, | 173 | .gpu_reset = &r300_gpu_reset, |
216 | .mc_init = NULL, | ||
217 | .mc_fini = NULL, | ||
218 | .wb_init = NULL, | ||
219 | .wb_fini = NULL, | ||
220 | .gart_enable = NULL, | ||
221 | .gart_disable = NULL, | ||
222 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, | 174 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, |
223 | .gart_set_page = &rv370_pcie_gart_set_page, | 175 | .gart_set_page = &rv370_pcie_gart_set_page, |
224 | .cp_init = NULL, | ||
225 | .cp_fini = NULL, | ||
226 | .cp_disable = NULL, | ||
227 | .cp_commit = &r100_cp_commit, | 176 | .cp_commit = &r100_cp_commit, |
228 | .ring_start = &r300_ring_start, | 177 | .ring_start = &r300_ring_start, |
229 | .ring_test = &r100_ring_test, | 178 | .ring_test = &r100_ring_test, |
230 | .ring_ib_execute = &r100_ring_ib_execute, | 179 | .ring_ib_execute = &r100_ring_ib_execute, |
231 | .ib_test = NULL, | ||
232 | .irq_set = &r100_irq_set, | 180 | .irq_set = &r100_irq_set, |
233 | .irq_process = &r100_irq_process, | 181 | .irq_process = &r100_irq_process, |
234 | .get_vblank_counter = &r100_get_vblank_counter, | 182 | .get_vblank_counter = &r100_get_vblank_counter, |
@@ -250,42 +198,27 @@ static struct radeon_asic r420_asic = { | |||
250 | /* | 198 | /* |
251 | * rs400,rs480 | 199 | * rs400,rs480 |
252 | */ | 200 | */ |
253 | void rs400_errata(struct radeon_device *rdev); | 201 | extern int rs400_init(struct radeon_device *rdev); |
254 | void rs400_vram_info(struct radeon_device *rdev); | 202 | extern void rs400_fini(struct radeon_device *rdev); |
255 | int rs400_mc_init(struct radeon_device *rdev); | 203 | extern int rs400_suspend(struct radeon_device *rdev); |
256 | void rs400_mc_fini(struct radeon_device *rdev); | 204 | extern int rs400_resume(struct radeon_device *rdev); |
257 | int rs400_gart_init(struct radeon_device *rdev); | ||
258 | void rs400_gart_fini(struct radeon_device *rdev); | ||
259 | int rs400_gart_enable(struct radeon_device *rdev); | ||
260 | void rs400_gart_disable(struct radeon_device *rdev); | ||
261 | void rs400_gart_tlb_flush(struct radeon_device *rdev); | 205 | void rs400_gart_tlb_flush(struct radeon_device *rdev); |
262 | int rs400_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 206 | int rs400_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
263 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg); | 207 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg); |
264 | void rs400_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 208 | void rs400_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
265 | static struct radeon_asic rs400_asic = { | 209 | static struct radeon_asic rs400_asic = { |
266 | .init = &r300_init, | 210 | .init = &rs400_init, |
267 | .errata = &rs400_errata, | 211 | .fini = &rs400_fini, |
268 | .vram_info = &rs400_vram_info, | 212 | .suspend = &rs400_suspend, |
213 | .resume = &rs400_resume, | ||
269 | .vga_set_state = &r100_vga_set_state, | 214 | .vga_set_state = &r100_vga_set_state, |
270 | .gpu_reset = &r300_gpu_reset, | 215 | .gpu_reset = &r300_gpu_reset, |
271 | .mc_init = &rs400_mc_init, | ||
272 | .mc_fini = &rs400_mc_fini, | ||
273 | .wb_init = &r100_wb_init, | ||
274 | .wb_fini = &r100_wb_fini, | ||
275 | .gart_init = &rs400_gart_init, | ||
276 | .gart_fini = &rs400_gart_fini, | ||
277 | .gart_enable = &rs400_gart_enable, | ||
278 | .gart_disable = &rs400_gart_disable, | ||
279 | .gart_tlb_flush = &rs400_gart_tlb_flush, | 216 | .gart_tlb_flush = &rs400_gart_tlb_flush, |
280 | .gart_set_page = &rs400_gart_set_page, | 217 | .gart_set_page = &rs400_gart_set_page, |
281 | .cp_init = &r100_cp_init, | ||
282 | .cp_fini = &r100_cp_fini, | ||
283 | .cp_disable = &r100_cp_disable, | ||
284 | .cp_commit = &r100_cp_commit, | 218 | .cp_commit = &r100_cp_commit, |
285 | .ring_start = &r300_ring_start, | 219 | .ring_start = &r300_ring_start, |
286 | .ring_test = &r100_ring_test, | 220 | .ring_test = &r100_ring_test, |
287 | .ring_ib_execute = &r100_ring_ib_execute, | 221 | .ring_ib_execute = &r100_ring_ib_execute, |
288 | .ib_test = &r100_ib_test, | ||
289 | .irq_set = &r100_irq_set, | 222 | .irq_set = &r100_irq_set, |
290 | .irq_process = &r100_irq_process, | 223 | .irq_process = &r100_irq_process, |
291 | .get_vblank_counter = &r100_get_vblank_counter, | 224 | .get_vblank_counter = &r100_get_vblank_counter, |
@@ -307,18 +240,13 @@ static struct radeon_asic rs400_asic = { | |||
307 | /* | 240 | /* |
308 | * rs600. | 241 | * rs600. |
309 | */ | 242 | */ |
310 | int rs600_init(struct radeon_device *rdev); | 243 | extern int rs600_init(struct radeon_device *rdev); |
311 | void rs600_errata(struct radeon_device *rdev); | 244 | extern void rs600_fini(struct radeon_device *rdev); |
312 | void rs600_vram_info(struct radeon_device *rdev); | 245 | extern int rs600_suspend(struct radeon_device *rdev); |
313 | int rs600_mc_init(struct radeon_device *rdev); | 246 | extern int rs600_resume(struct radeon_device *rdev); |
314 | void rs600_mc_fini(struct radeon_device *rdev); | ||
315 | int rs600_irq_set(struct radeon_device *rdev); | 247 | int rs600_irq_set(struct radeon_device *rdev); |
316 | int rs600_irq_process(struct radeon_device *rdev); | 248 | int rs600_irq_process(struct radeon_device *rdev); |
317 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc); | 249 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc); |
318 | int rs600_gart_init(struct radeon_device *rdev); | ||
319 | void rs600_gart_fini(struct radeon_device *rdev); | ||
320 | int rs600_gart_enable(struct radeon_device *rdev); | ||
321 | void rs600_gart_disable(struct radeon_device *rdev); | ||
322 | void rs600_gart_tlb_flush(struct radeon_device *rdev); | 250 | void rs600_gart_tlb_flush(struct radeon_device *rdev); |
323 | int rs600_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 251 | int rs600_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
324 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg); | 252 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg); |
@@ -326,28 +254,17 @@ void rs600_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | |||
326 | void rs600_bandwidth_update(struct radeon_device *rdev); | 254 | void rs600_bandwidth_update(struct radeon_device *rdev); |
327 | static struct radeon_asic rs600_asic = { | 255 | static struct radeon_asic rs600_asic = { |
328 | .init = &rs600_init, | 256 | .init = &rs600_init, |
329 | .errata = &rs600_errata, | 257 | .fini = &rs600_fini, |
330 | .vram_info = &rs600_vram_info, | 258 | .suspend = &rs600_suspend, |
259 | .resume = &rs600_resume, | ||
331 | .vga_set_state = &r100_vga_set_state, | 260 | .vga_set_state = &r100_vga_set_state, |
332 | .gpu_reset = &r300_gpu_reset, | 261 | .gpu_reset = &r300_gpu_reset, |
333 | .mc_init = &rs600_mc_init, | ||
334 | .mc_fini = &rs600_mc_fini, | ||
335 | .wb_init = &r100_wb_init, | ||
336 | .wb_fini = &r100_wb_fini, | ||
337 | .gart_init = &rs600_gart_init, | ||
338 | .gart_fini = &rs600_gart_fini, | ||
339 | .gart_enable = &rs600_gart_enable, | ||
340 | .gart_disable = &rs600_gart_disable, | ||
341 | .gart_tlb_flush = &rs600_gart_tlb_flush, | 262 | .gart_tlb_flush = &rs600_gart_tlb_flush, |
342 | .gart_set_page = &rs600_gart_set_page, | 263 | .gart_set_page = &rs600_gart_set_page, |
343 | .cp_init = &r100_cp_init, | ||
344 | .cp_fini = &r100_cp_fini, | ||
345 | .cp_disable = &r100_cp_disable, | ||
346 | .cp_commit = &r100_cp_commit, | 264 | .cp_commit = &r100_cp_commit, |
347 | .ring_start = &r300_ring_start, | 265 | .ring_start = &r300_ring_start, |
348 | .ring_test = &r100_ring_test, | 266 | .ring_test = &r100_ring_test, |
349 | .ring_ib_execute = &r100_ring_ib_execute, | 267 | .ring_ib_execute = &r100_ring_ib_execute, |
350 | .ib_test = &r100_ib_test, | ||
351 | .irq_set = &rs600_irq_set, | 268 | .irq_set = &rs600_irq_set, |
352 | .irq_process = &rs600_irq_process, | 269 | .irq_process = &rs600_irq_process, |
353 | .get_vblank_counter = &rs600_get_vblank_counter, | 270 | .get_vblank_counter = &rs600_get_vblank_counter, |
@@ -367,37 +284,26 @@ static struct radeon_asic rs600_asic = { | |||
367 | /* | 284 | /* |
368 | * rs690,rs740 | 285 | * rs690,rs740 |
369 | */ | 286 | */ |
370 | void rs690_errata(struct radeon_device *rdev); | 287 | int rs690_init(struct radeon_device *rdev); |
371 | void rs690_vram_info(struct radeon_device *rdev); | 288 | void rs690_fini(struct radeon_device *rdev); |
372 | int rs690_mc_init(struct radeon_device *rdev); | 289 | int rs690_resume(struct radeon_device *rdev); |
373 | void rs690_mc_fini(struct radeon_device *rdev); | 290 | int rs690_suspend(struct radeon_device *rdev); |
374 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg); | 291 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg); |
375 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 292 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
376 | void rs690_bandwidth_update(struct radeon_device *rdev); | 293 | void rs690_bandwidth_update(struct radeon_device *rdev); |
377 | static struct radeon_asic rs690_asic = { | 294 | static struct radeon_asic rs690_asic = { |
378 | .init = &rs600_init, | 295 | .init = &rs690_init, |
379 | .errata = &rs690_errata, | 296 | .fini = &rs690_fini, |
380 | .vram_info = &rs690_vram_info, | 297 | .suspend = &rs690_suspend, |
298 | .resume = &rs690_resume, | ||
381 | .vga_set_state = &r100_vga_set_state, | 299 | .vga_set_state = &r100_vga_set_state, |
382 | .gpu_reset = &r300_gpu_reset, | 300 | .gpu_reset = &r300_gpu_reset, |
383 | .mc_init = &rs690_mc_init, | ||
384 | .mc_fini = &rs690_mc_fini, | ||
385 | .wb_init = &r100_wb_init, | ||
386 | .wb_fini = &r100_wb_fini, | ||
387 | .gart_init = &rs400_gart_init, | ||
388 | .gart_fini = &rs400_gart_fini, | ||
389 | .gart_enable = &rs400_gart_enable, | ||
390 | .gart_disable = &rs400_gart_disable, | ||
391 | .gart_tlb_flush = &rs400_gart_tlb_flush, | 301 | .gart_tlb_flush = &rs400_gart_tlb_flush, |
392 | .gart_set_page = &rs400_gart_set_page, | 302 | .gart_set_page = &rs400_gart_set_page, |
393 | .cp_init = &r100_cp_init, | ||
394 | .cp_fini = &r100_cp_fini, | ||
395 | .cp_disable = &r100_cp_disable, | ||
396 | .cp_commit = &r100_cp_commit, | 303 | .cp_commit = &r100_cp_commit, |
397 | .ring_start = &r300_ring_start, | 304 | .ring_start = &r300_ring_start, |
398 | .ring_test = &r100_ring_test, | 305 | .ring_test = &r100_ring_test, |
399 | .ring_ib_execute = &r100_ring_ib_execute, | 306 | .ring_ib_execute = &r100_ring_ib_execute, |
400 | .ib_test = &r100_ib_test, | ||
401 | .irq_set = &rs600_irq_set, | 307 | .irq_set = &rs600_irq_set, |
402 | .irq_process = &rs600_irq_process, | 308 | .irq_process = &rs600_irq_process, |
403 | .get_vblank_counter = &rs600_get_vblank_counter, | 309 | .get_vblank_counter = &rs600_get_vblank_counter, |
@@ -435,28 +341,14 @@ static struct radeon_asic rv515_asic = { | |||
435 | .fini = &rv515_fini, | 341 | .fini = &rv515_fini, |
436 | .suspend = &rv515_suspend, | 342 | .suspend = &rv515_suspend, |
437 | .resume = &rv515_resume, | 343 | .resume = &rv515_resume, |
438 | .errata = NULL, | ||
439 | .vram_info = NULL, | ||
440 | .vga_set_state = &r100_vga_set_state, | 344 | .vga_set_state = &r100_vga_set_state, |
441 | .gpu_reset = &rv515_gpu_reset, | 345 | .gpu_reset = &rv515_gpu_reset, |
442 | .mc_init = NULL, | ||
443 | .mc_fini = NULL, | ||
444 | .wb_init = NULL, | ||
445 | .wb_fini = NULL, | ||
446 | .gart_init = &rv370_pcie_gart_init, | ||
447 | .gart_fini = &rv370_pcie_gart_fini, | ||
448 | .gart_enable = NULL, | ||
449 | .gart_disable = NULL, | ||
450 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, | 346 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, |
451 | .gart_set_page = &rv370_pcie_gart_set_page, | 347 | .gart_set_page = &rv370_pcie_gart_set_page, |
452 | .cp_init = NULL, | ||
453 | .cp_fini = NULL, | ||
454 | .cp_disable = NULL, | ||
455 | .cp_commit = &r100_cp_commit, | 348 | .cp_commit = &r100_cp_commit, |
456 | .ring_start = &rv515_ring_start, | 349 | .ring_start = &rv515_ring_start, |
457 | .ring_test = &r100_ring_test, | 350 | .ring_test = &r100_ring_test, |
458 | .ring_ib_execute = &r100_ring_ib_execute, | 351 | .ring_ib_execute = &r100_ring_ib_execute, |
459 | .ib_test = NULL, | ||
460 | .irq_set = &rs600_irq_set, | 352 | .irq_set = &rs600_irq_set, |
461 | .irq_process = &rs600_irq_process, | 353 | .irq_process = &rs600_irq_process, |
462 | .get_vblank_counter = &rs600_get_vblank_counter, | 354 | .get_vblank_counter = &rs600_get_vblank_counter, |
@@ -485,28 +377,14 @@ static struct radeon_asic r520_asic = { | |||
485 | .fini = &rv515_fini, | 377 | .fini = &rv515_fini, |
486 | .suspend = &rv515_suspend, | 378 | .suspend = &rv515_suspend, |
487 | .resume = &r520_resume, | 379 | .resume = &r520_resume, |
488 | .errata = NULL, | ||
489 | .vram_info = NULL, | ||
490 | .vga_set_state = &r100_vga_set_state, | 380 | .vga_set_state = &r100_vga_set_state, |
491 | .gpu_reset = &rv515_gpu_reset, | 381 | .gpu_reset = &rv515_gpu_reset, |
492 | .mc_init = NULL, | ||
493 | .mc_fini = NULL, | ||
494 | .wb_init = NULL, | ||
495 | .wb_fini = NULL, | ||
496 | .gart_init = NULL, | ||
497 | .gart_fini = NULL, | ||
498 | .gart_enable = NULL, | ||
499 | .gart_disable = NULL, | ||
500 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, | 382 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, |
501 | .gart_set_page = &rv370_pcie_gart_set_page, | 383 | .gart_set_page = &rv370_pcie_gart_set_page, |
502 | .cp_init = NULL, | ||
503 | .cp_fini = NULL, | ||
504 | .cp_disable = NULL, | ||
505 | .cp_commit = &r100_cp_commit, | 384 | .cp_commit = &r100_cp_commit, |
506 | .ring_start = &rv515_ring_start, | 385 | .ring_start = &rv515_ring_start, |
507 | .ring_test = &r100_ring_test, | 386 | .ring_test = &r100_ring_test, |
508 | .ring_ib_execute = &r100_ring_ib_execute, | 387 | .ring_ib_execute = &r100_ring_ib_execute, |
509 | .ib_test = NULL, | ||
510 | .irq_set = &rs600_irq_set, | 388 | .irq_set = &rs600_irq_set, |
511 | .irq_process = &rs600_irq_process, | 389 | .irq_process = &rs600_irq_process, |
512 | .get_vblank_counter = &rs600_get_vblank_counter, | 390 | .get_vblank_counter = &rs600_get_vblank_counter, |
@@ -554,37 +432,23 @@ int r600_set_surface_reg(struct radeon_device *rdev, int reg, | |||
554 | uint32_t offset, uint32_t obj_size); | 432 | uint32_t offset, uint32_t obj_size); |
555 | int r600_clear_surface_reg(struct radeon_device *rdev, int reg); | 433 | int r600_clear_surface_reg(struct radeon_device *rdev, int reg); |
556 | void r600_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); | 434 | void r600_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); |
557 | int r600_ib_test(struct radeon_device *rdev); | ||
558 | int r600_ring_test(struct radeon_device *rdev); | 435 | int r600_ring_test(struct radeon_device *rdev); |
559 | int r600_copy_blit(struct radeon_device *rdev, | 436 | int r600_copy_blit(struct radeon_device *rdev, |
560 | uint64_t src_offset, uint64_t dst_offset, | 437 | uint64_t src_offset, uint64_t dst_offset, |
561 | unsigned num_pages, struct radeon_fence *fence); | 438 | unsigned num_pages, struct radeon_fence *fence); |
562 | 439 | ||
563 | static struct radeon_asic r600_asic = { | 440 | static struct radeon_asic r600_asic = { |
564 | .errata = NULL, | ||
565 | .init = &r600_init, | 441 | .init = &r600_init, |
566 | .fini = &r600_fini, | 442 | .fini = &r600_fini, |
567 | .suspend = &r600_suspend, | 443 | .suspend = &r600_suspend, |
568 | .resume = &r600_resume, | 444 | .resume = &r600_resume, |
569 | .cp_commit = &r600_cp_commit, | 445 | .cp_commit = &r600_cp_commit, |
570 | .vram_info = NULL, | ||
571 | .vga_set_state = &r600_vga_set_state, | 446 | .vga_set_state = &r600_vga_set_state, |
572 | .gpu_reset = &r600_gpu_reset, | 447 | .gpu_reset = &r600_gpu_reset, |
573 | .mc_init = NULL, | ||
574 | .mc_fini = NULL, | ||
575 | .wb_init = &r600_wb_init, | ||
576 | .wb_fini = &r600_wb_fini, | ||
577 | .gart_enable = NULL, | ||
578 | .gart_disable = NULL, | ||
579 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, | 448 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, |
580 | .gart_set_page = &rs600_gart_set_page, | 449 | .gart_set_page = &rs600_gart_set_page, |
581 | .cp_init = NULL, | ||
582 | .cp_fini = NULL, | ||
583 | .cp_disable = NULL, | ||
584 | .ring_start = NULL, | ||
585 | .ring_test = &r600_ring_test, | 450 | .ring_test = &r600_ring_test, |
586 | .ring_ib_execute = &r600_ring_ib_execute, | 451 | .ring_ib_execute = &r600_ring_ib_execute, |
587 | .ib_test = &r600_ib_test, | ||
588 | .irq_set = &r600_irq_set, | 452 | .irq_set = &r600_irq_set, |
589 | .irq_process = &r600_irq_process, | 453 | .irq_process = &r600_irq_process, |
590 | .fence_ring_emit = &r600_fence_ring_emit, | 454 | .fence_ring_emit = &r600_fence_ring_emit, |
@@ -611,30 +475,17 @@ int rv770_resume(struct radeon_device *rdev); | |||
611 | int rv770_gpu_reset(struct radeon_device *rdev); | 475 | int rv770_gpu_reset(struct radeon_device *rdev); |
612 | 476 | ||
613 | static struct radeon_asic rv770_asic = { | 477 | static struct radeon_asic rv770_asic = { |
614 | .errata = NULL, | ||
615 | .init = &rv770_init, | 478 | .init = &rv770_init, |
616 | .fini = &rv770_fini, | 479 | .fini = &rv770_fini, |
617 | .suspend = &rv770_suspend, | 480 | .suspend = &rv770_suspend, |
618 | .resume = &rv770_resume, | 481 | .resume = &rv770_resume, |
619 | .cp_commit = &r600_cp_commit, | 482 | .cp_commit = &r600_cp_commit, |
620 | .vram_info = NULL, | ||
621 | .gpu_reset = &rv770_gpu_reset, | 483 | .gpu_reset = &rv770_gpu_reset, |
622 | .vga_set_state = &r600_vga_set_state, | 484 | .vga_set_state = &r600_vga_set_state, |
623 | .mc_init = NULL, | ||
624 | .mc_fini = NULL, | ||
625 | .wb_init = &r600_wb_init, | ||
626 | .wb_fini = &r600_wb_fini, | ||
627 | .gart_enable = NULL, | ||
628 | .gart_disable = NULL, | ||
629 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, | 485 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, |
630 | .gart_set_page = &rs600_gart_set_page, | 486 | .gart_set_page = &rs600_gart_set_page, |
631 | .cp_init = NULL, | ||
632 | .cp_fini = NULL, | ||
633 | .cp_disable = NULL, | ||
634 | .ring_start = NULL, | ||
635 | .ring_test = &r600_ring_test, | 487 | .ring_test = &r600_ring_test, |
636 | .ring_ib_execute = &r600_ring_ib_execute, | 488 | .ring_ib_execute = &r600_ring_ib_execute, |
637 | .ib_test = &r600_ib_test, | ||
638 | .irq_set = &r600_irq_set, | 489 | .irq_set = &r600_irq_set, |
639 | .irq_process = &r600_irq_process, | 490 | .irq_process = &r600_irq_process, |
640 | .fence_ring_emit = &r600_fence_ring_emit, | 491 | .fence_ring_emit = &r600_fence_ring_emit, |
diff --git a/drivers/gpu/drm/radeon/radeon_bios.c b/drivers/gpu/drm/radeon/radeon_bios.c index 96e37a6e7ce4..34a9b9119518 100644 --- a/drivers/gpu/drm/radeon/radeon_bios.c +++ b/drivers/gpu/drm/radeon/radeon_bios.c | |||
@@ -33,12 +33,50 @@ | |||
33 | /* | 33 | /* |
34 | * BIOS. | 34 | * BIOS. |
35 | */ | 35 | */ |
36 | |||
37 | /* If you boot an IGP board with a discrete card as the primary, | ||
38 | * the IGP rom is not accessible via the rom bar as the IGP rom is | ||
39 | * part of the system bios. On boot, the system bios puts a | ||
40 | * copy of the igp rom at the start of vram if a discrete card is | ||
41 | * present. | ||
42 | */ | ||
43 | static bool igp_read_bios_from_vram(struct radeon_device *rdev) | ||
44 | { | ||
45 | uint8_t __iomem *bios; | ||
46 | resource_size_t vram_base; | ||
47 | resource_size_t size = 256 * 1024; /* ??? */ | ||
48 | |||
49 | rdev->bios = NULL; | ||
50 | vram_base = drm_get_resource_start(rdev->ddev, 0); | ||
51 | bios = ioremap(vram_base, size); | ||
52 | if (!bios) { | ||
53 | DRM_ERROR("Unable to mmap vram\n"); | ||
54 | return false; | ||
55 | } | ||
56 | |||
57 | if (size == 0 || bios[0] != 0x55 || bios[1] != 0xaa) { | ||
58 | iounmap(bios); | ||
59 | DRM_ERROR("bad rom signature\n"); | ||
60 | return false; | ||
61 | } | ||
62 | rdev->bios = kmalloc(size, GFP_KERNEL); | ||
63 | if (rdev->bios == NULL) { | ||
64 | iounmap(bios); | ||
65 | DRM_ERROR("kmalloc failed\n"); | ||
66 | return false; | ||
67 | } | ||
68 | memcpy(rdev->bios, bios, size); | ||
69 | iounmap(bios); | ||
70 | return true; | ||
71 | } | ||
72 | |||
36 | static bool radeon_read_bios(struct radeon_device *rdev) | 73 | static bool radeon_read_bios(struct radeon_device *rdev) |
37 | { | 74 | { |
38 | uint8_t __iomem *bios; | 75 | uint8_t __iomem *bios; |
39 | size_t size; | 76 | size_t size; |
40 | 77 | ||
41 | rdev->bios = NULL; | 78 | rdev->bios = NULL; |
79 | /* XXX: some cards may return 0 for rom size? ddx has a workaround */ | ||
42 | bios = pci_map_rom(rdev->pdev, &size); | 80 | bios = pci_map_rom(rdev->pdev, &size); |
43 | if (!bios) { | 81 | if (!bios) { |
44 | return false; | 82 | return false; |
@@ -341,7 +379,9 @@ static bool legacy_read_disabled_bios(struct radeon_device *rdev) | |||
341 | 379 | ||
342 | static bool radeon_read_disabled_bios(struct radeon_device *rdev) | 380 | static bool radeon_read_disabled_bios(struct radeon_device *rdev) |
343 | { | 381 | { |
344 | if (rdev->family >= CHIP_RV770) | 382 | if (rdev->flags & RADEON_IS_IGP) |
383 | return igp_read_bios_from_vram(rdev); | ||
384 | else if (rdev->family >= CHIP_RV770) | ||
345 | return r700_read_disabled_bios(rdev); | 385 | return r700_read_disabled_bios(rdev); |
346 | else if (rdev->family >= CHIP_R600) | 386 | else if (rdev->family >= CHIP_R600) |
347 | return r600_read_disabled_bios(rdev); | 387 | return r600_read_disabled_bios(rdev); |
@@ -356,7 +396,12 @@ bool radeon_get_bios(struct radeon_device *rdev) | |||
356 | bool r; | 396 | bool r; |
357 | uint16_t tmp; | 397 | uint16_t tmp; |
358 | 398 | ||
359 | r = radeon_read_bios(rdev); | 399 | if (rdev->flags & RADEON_IS_IGP) { |
400 | r = igp_read_bios_from_vram(rdev); | ||
401 | if (r == false) | ||
402 | r = radeon_read_bios(rdev); | ||
403 | } else | ||
404 | r = radeon_read_bios(rdev); | ||
360 | if (r == false) { | 405 | if (r == false) { |
361 | r = radeon_read_disabled_bios(rdev); | 406 | r = radeon_read_disabled_bios(rdev); |
362 | } | 407 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c index 152eef13197a..f5c32a766b10 100644 --- a/drivers/gpu/drm/radeon/radeon_clocks.c +++ b/drivers/gpu/drm/radeon/radeon_clocks.c | |||
@@ -411,7 +411,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
411 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 411 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
412 | R300_PIXCLK_TVO_ALWAYS_ONb | | 412 | R300_PIXCLK_TVO_ALWAYS_ONb | |
413 | R300_P2G2CLK_ALWAYS_ONb | | 413 | R300_P2G2CLK_ALWAYS_ONb | |
414 | R300_P2G2CLK_ALWAYS_ONb); | 414 | R300_P2G2CLK_DAC_ALWAYS_ONb); |
415 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 415 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
416 | } else if (rdev->family >= CHIP_RV350) { | 416 | } else if (rdev->family >= CHIP_RV350) { |
417 | tmp = RREG32_PLL(R300_SCLK_CNTL2); | 417 | tmp = RREG32_PLL(R300_SCLK_CNTL2); |
@@ -464,7 +464,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
464 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 464 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
465 | R300_PIXCLK_TVO_ALWAYS_ONb | | 465 | R300_PIXCLK_TVO_ALWAYS_ONb | |
466 | R300_P2G2CLK_ALWAYS_ONb | | 466 | R300_P2G2CLK_ALWAYS_ONb | |
467 | R300_P2G2CLK_ALWAYS_ONb); | 467 | R300_P2G2CLK_DAC_ALWAYS_ONb); |
468 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 468 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
469 | 469 | ||
470 | tmp = RREG32_PLL(RADEON_MCLK_MISC); | 470 | tmp = RREG32_PLL(RADEON_MCLK_MISC); |
@@ -654,7 +654,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
654 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 654 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
655 | R300_PIXCLK_TVO_ALWAYS_ONb | | 655 | R300_PIXCLK_TVO_ALWAYS_ONb | |
656 | R300_P2G2CLK_ALWAYS_ONb | | 656 | R300_P2G2CLK_ALWAYS_ONb | |
657 | R300_P2G2CLK_ALWAYS_ONb | | 657 | R300_P2G2CLK_DAC_ALWAYS_ONb | |
658 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); | 658 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); |
659 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 659 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
660 | } else if (rdev->family >= CHIP_RV350) { | 660 | } else if (rdev->family >= CHIP_RV350) { |
@@ -705,7 +705,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
705 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 705 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
706 | R300_PIXCLK_TVO_ALWAYS_ONb | | 706 | R300_PIXCLK_TVO_ALWAYS_ONb | |
707 | R300_P2G2CLK_ALWAYS_ONb | | 707 | R300_P2G2CLK_ALWAYS_ONb | |
708 | R300_P2G2CLK_ALWAYS_ONb | | 708 | R300_P2G2CLK_DAC_ALWAYS_ONb | |
709 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); | 709 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); |
710 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 710 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
711 | } else { | 711 | } else { |
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c index ec835d56d30a..3d667031de6e 100644 --- a/drivers/gpu/drm/radeon/radeon_device.c +++ b/drivers/gpu/drm/radeon/radeon_device.c | |||
@@ -322,10 +322,6 @@ int radeon_asic_init(struct radeon_device *rdev) | |||
322 | case CHIP_RV380: | 322 | case CHIP_RV380: |
323 | rdev->asic = &r300_asic; | 323 | rdev->asic = &r300_asic; |
324 | if (rdev->flags & RADEON_IS_PCIE) { | 324 | if (rdev->flags & RADEON_IS_PCIE) { |
325 | rdev->asic->gart_init = &rv370_pcie_gart_init; | ||
326 | rdev->asic->gart_fini = &rv370_pcie_gart_fini; | ||
327 | rdev->asic->gart_enable = &rv370_pcie_gart_enable; | ||
328 | rdev->asic->gart_disable = &rv370_pcie_gart_disable; | ||
329 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; | 325 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; |
330 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; | 326 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; |
331 | } | 327 | } |
@@ -485,7 +481,6 @@ void radeon_combios_fini(struct radeon_device *rdev) | |||
485 | static unsigned int radeon_vga_set_decode(void *cookie, bool state) | 481 | static unsigned int radeon_vga_set_decode(void *cookie, bool state) |
486 | { | 482 | { |
487 | struct radeon_device *rdev = cookie; | 483 | struct radeon_device *rdev = cookie; |
488 | |||
489 | radeon_vga_set_state(rdev, state); | 484 | radeon_vga_set_state(rdev, state); |
490 | if (state) | 485 | if (state) |
491 | return VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM | | 486 | return VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM | |
@@ -493,6 +488,29 @@ static unsigned int radeon_vga_set_decode(void *cookie, bool state) | |||
493 | else | 488 | else |
494 | return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM; | 489 | return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM; |
495 | } | 490 | } |
491 | |||
492 | void radeon_agp_disable(struct radeon_device *rdev) | ||
493 | { | ||
494 | rdev->flags &= ~RADEON_IS_AGP; | ||
495 | if (rdev->family >= CHIP_R600) { | ||
496 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
497 | rdev->flags |= RADEON_IS_PCIE; | ||
498 | } else if (rdev->family >= CHIP_RV515 || | ||
499 | rdev->family == CHIP_RV380 || | ||
500 | rdev->family == CHIP_RV410 || | ||
501 | rdev->family == CHIP_R423) { | ||
502 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
503 | rdev->flags |= RADEON_IS_PCIE; | ||
504 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; | ||
505 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; | ||
506 | } else { | ||
507 | DRM_INFO("Forcing AGP to PCI mode\n"); | ||
508 | rdev->flags |= RADEON_IS_PCI; | ||
509 | rdev->asic->gart_tlb_flush = &r100_pci_gart_tlb_flush; | ||
510 | rdev->asic->gart_set_page = &r100_pci_gart_set_page; | ||
511 | } | ||
512 | } | ||
513 | |||
496 | /* | 514 | /* |
497 | * Radeon device. | 515 | * Radeon device. |
498 | */ | 516 | */ |
@@ -531,32 +549,7 @@ int radeon_device_init(struct radeon_device *rdev, | |||
531 | } | 549 | } |
532 | 550 | ||
533 | if (radeon_agpmode == -1) { | 551 | if (radeon_agpmode == -1) { |
534 | rdev->flags &= ~RADEON_IS_AGP; | 552 | radeon_agp_disable(rdev); |
535 | if (rdev->family >= CHIP_R600) { | ||
536 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
537 | rdev->flags |= RADEON_IS_PCIE; | ||
538 | } else if (rdev->family >= CHIP_RV515 || | ||
539 | rdev->family == CHIP_RV380 || | ||
540 | rdev->family == CHIP_RV410 || | ||
541 | rdev->family == CHIP_R423) { | ||
542 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
543 | rdev->flags |= RADEON_IS_PCIE; | ||
544 | rdev->asic->gart_init = &rv370_pcie_gart_init; | ||
545 | rdev->asic->gart_fini = &rv370_pcie_gart_fini; | ||
546 | rdev->asic->gart_enable = &rv370_pcie_gart_enable; | ||
547 | rdev->asic->gart_disable = &rv370_pcie_gart_disable; | ||
548 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; | ||
549 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; | ||
550 | } else { | ||
551 | DRM_INFO("Forcing AGP to PCI mode\n"); | ||
552 | rdev->flags |= RADEON_IS_PCI; | ||
553 | rdev->asic->gart_init = &r100_pci_gart_init; | ||
554 | rdev->asic->gart_fini = &r100_pci_gart_fini; | ||
555 | rdev->asic->gart_enable = &r100_pci_gart_enable; | ||
556 | rdev->asic->gart_disable = &r100_pci_gart_disable; | ||
557 | rdev->asic->gart_tlb_flush = &r100_pci_gart_tlb_flush; | ||
558 | rdev->asic->gart_set_page = &r100_pci_gart_set_page; | ||
559 | } | ||
560 | } | 553 | } |
561 | 554 | ||
562 | /* set DMA mask + need_dma32 flags. | 555 | /* set DMA mask + need_dma32 flags. |
@@ -588,111 +581,27 @@ int radeon_device_init(struct radeon_device *rdev, | |||
588 | DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)rdev->rmmio_base); | 581 | DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)rdev->rmmio_base); |
589 | DRM_INFO("register mmio size: %u\n", (unsigned)rdev->rmmio_size); | 582 | DRM_INFO("register mmio size: %u\n", (unsigned)rdev->rmmio_size); |
590 | 583 | ||
591 | rdev->new_init_path = false; | ||
592 | r = radeon_init(rdev); | ||
593 | if (r) { | ||
594 | return r; | ||
595 | } | ||
596 | |||
597 | /* if we have > 1 VGA cards, then disable the radeon VGA resources */ | 584 | /* if we have > 1 VGA cards, then disable the radeon VGA resources */ |
598 | r = vga_client_register(rdev->pdev, rdev, NULL, radeon_vga_set_decode); | 585 | r = vga_client_register(rdev->pdev, rdev, NULL, radeon_vga_set_decode); |
599 | if (r) { | 586 | if (r) { |
600 | return -EINVAL; | 587 | return -EINVAL; |
601 | } | 588 | } |
602 | 589 | ||
603 | if (!rdev->new_init_path) { | 590 | r = radeon_init(rdev); |
604 | /* Setup errata flags */ | 591 | if (r) |
605 | radeon_errata(rdev); | 592 | return r; |
606 | /* Initialize scratch registers */ | ||
607 | radeon_scratch_init(rdev); | ||
608 | /* Initialize surface registers */ | ||
609 | radeon_surface_init(rdev); | ||
610 | |||
611 | /* BIOS*/ | ||
612 | if (!radeon_get_bios(rdev)) { | ||
613 | if (ASIC_IS_AVIVO(rdev)) | ||
614 | return -EINVAL; | ||
615 | } | ||
616 | if (rdev->is_atom_bios) { | ||
617 | r = radeon_atombios_init(rdev); | ||
618 | if (r) { | ||
619 | return r; | ||
620 | } | ||
621 | } else { | ||
622 | r = radeon_combios_init(rdev); | ||
623 | if (r) { | ||
624 | return r; | ||
625 | } | ||
626 | } | ||
627 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
628 | if (radeon_gpu_reset(rdev)) { | ||
629 | /* FIXME: what do we want to do here ? */ | ||
630 | } | ||
631 | /* check if cards are posted or not */ | ||
632 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
633 | DRM_INFO("GPU not posted. posting now...\n"); | ||
634 | if (rdev->is_atom_bios) { | ||
635 | atom_asic_init(rdev->mode_info.atom_context); | ||
636 | } else { | ||
637 | radeon_combios_asic_init(rdev->ddev); | ||
638 | } | ||
639 | } | ||
640 | /* Get clock & vram information */ | ||
641 | radeon_get_clock_info(rdev->ddev); | ||
642 | radeon_vram_info(rdev); | ||
643 | /* Initialize clocks */ | ||
644 | r = radeon_clocks_init(rdev); | ||
645 | if (r) { | ||
646 | return r; | ||
647 | } | ||
648 | 593 | ||
649 | /* Initialize memory controller (also test AGP) */ | 594 | if (rdev->flags & RADEON_IS_AGP && !rdev->accel_working) { |
650 | r = radeon_mc_init(rdev); | 595 | /* Acceleration not working on AGP card try again |
651 | if (r) { | 596 | * with fallback to PCI or PCIE GART |
652 | return r; | 597 | */ |
653 | } | 598 | radeon_gpu_reset(rdev); |
654 | /* Fence driver */ | 599 | radeon_fini(rdev); |
655 | r = radeon_fence_driver_init(rdev); | 600 | radeon_agp_disable(rdev); |
656 | if (r) { | 601 | r = radeon_init(rdev); |
657 | return r; | ||
658 | } | ||
659 | r = radeon_irq_kms_init(rdev); | ||
660 | if (r) { | ||
661 | return r; | ||
662 | } | ||
663 | /* Memory manager */ | ||
664 | r = radeon_object_init(rdev); | ||
665 | if (r) { | ||
666 | return r; | ||
667 | } | ||
668 | r = radeon_gpu_gart_init(rdev); | ||
669 | if (r) | 602 | if (r) |
670 | return r; | 603 | return r; |
671 | /* Initialize GART (initialize after TTM so we can allocate | ||
672 | * memory through TTM but finalize after TTM) */ | ||
673 | r = radeon_gart_enable(rdev); | ||
674 | if (r) | ||
675 | return 0; | ||
676 | r = radeon_gem_init(rdev); | ||
677 | if (r) | ||
678 | return 0; | ||
679 | |||
680 | /* 1M ring buffer */ | ||
681 | r = radeon_cp_init(rdev, 1024 * 1024); | ||
682 | if (r) | ||
683 | return 0; | ||
684 | r = radeon_wb_init(rdev); | ||
685 | if (r) | ||
686 | DRM_ERROR("radeon: failled initializing WB (%d).\n", r); | ||
687 | r = radeon_ib_pool_init(rdev); | ||
688 | if (r) | ||
689 | return 0; | ||
690 | r = radeon_ib_test(rdev); | ||
691 | if (r) | ||
692 | return 0; | ||
693 | rdev->accel_working = true; | ||
694 | } | 604 | } |
695 | DRM_INFO("radeon: kernel modesetting successfully initialized.\n"); | ||
696 | if (radeon_testing) { | 605 | if (radeon_testing) { |
697 | radeon_test_moves(rdev); | 606 | radeon_test_moves(rdev); |
698 | } | 607 | } |
@@ -706,32 +615,8 @@ void radeon_device_fini(struct radeon_device *rdev) | |||
706 | { | 615 | { |
707 | DRM_INFO("radeon: finishing device.\n"); | 616 | DRM_INFO("radeon: finishing device.\n"); |
708 | rdev->shutdown = true; | 617 | rdev->shutdown = true; |
709 | /* Order matter so becarefull if you rearrange anythings */ | 618 | radeon_fini(rdev); |
710 | if (!rdev->new_init_path) { | 619 | vga_client_register(rdev->pdev, NULL, NULL, NULL); |
711 | radeon_ib_pool_fini(rdev); | ||
712 | radeon_cp_fini(rdev); | ||
713 | radeon_wb_fini(rdev); | ||
714 | radeon_gpu_gart_fini(rdev); | ||
715 | radeon_gem_fini(rdev); | ||
716 | radeon_mc_fini(rdev); | ||
717 | #if __OS_HAS_AGP | ||
718 | radeon_agp_fini(rdev); | ||
719 | #endif | ||
720 | radeon_irq_kms_fini(rdev); | ||
721 | vga_client_register(rdev->pdev, NULL, NULL, NULL); | ||
722 | radeon_fence_driver_fini(rdev); | ||
723 | radeon_clocks_fini(rdev); | ||
724 | radeon_object_fini(rdev); | ||
725 | if (rdev->is_atom_bios) { | ||
726 | radeon_atombios_fini(rdev); | ||
727 | } else { | ||
728 | radeon_combios_fini(rdev); | ||
729 | } | ||
730 | kfree(rdev->bios); | ||
731 | rdev->bios = NULL; | ||
732 | } else { | ||
733 | radeon_fini(rdev); | ||
734 | } | ||
735 | iounmap(rdev->rmmio); | 620 | iounmap(rdev->rmmio); |
736 | rdev->rmmio = NULL; | 621 | rdev->rmmio = NULL; |
737 | } | 622 | } |
@@ -771,14 +656,7 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state) | |||
771 | 656 | ||
772 | radeon_save_bios_scratch_regs(rdev); | 657 | radeon_save_bios_scratch_regs(rdev); |
773 | 658 | ||
774 | if (!rdev->new_init_path) { | 659 | radeon_suspend(rdev); |
775 | radeon_cp_disable(rdev); | ||
776 | radeon_gart_disable(rdev); | ||
777 | rdev->irq.sw_int = false; | ||
778 | radeon_irq_set(rdev); | ||
779 | } else { | ||
780 | radeon_suspend(rdev); | ||
781 | } | ||
782 | /* evict remaining vram memory */ | 660 | /* evict remaining vram memory */ |
783 | radeon_object_evict_vram(rdev); | 661 | radeon_object_evict_vram(rdev); |
784 | 662 | ||
@@ -797,7 +675,6 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state) | |||
797 | int radeon_resume_kms(struct drm_device *dev) | 675 | int radeon_resume_kms(struct drm_device *dev) |
798 | { | 676 | { |
799 | struct radeon_device *rdev = dev->dev_private; | 677 | struct radeon_device *rdev = dev->dev_private; |
800 | int r; | ||
801 | 678 | ||
802 | acquire_console_sem(); | 679 | acquire_console_sem(); |
803 | pci_set_power_state(dev->pdev, PCI_D0); | 680 | pci_set_power_state(dev->pdev, PCI_D0); |
@@ -807,43 +684,7 @@ int radeon_resume_kms(struct drm_device *dev) | |||
807 | return -1; | 684 | return -1; |
808 | } | 685 | } |
809 | pci_set_master(dev->pdev); | 686 | pci_set_master(dev->pdev); |
810 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | 687 | radeon_resume(rdev); |
811 | if (!rdev->new_init_path) { | ||
812 | if (radeon_gpu_reset(rdev)) { | ||
813 | /* FIXME: what do we want to do here ? */ | ||
814 | } | ||
815 | /* post card */ | ||
816 | if (rdev->is_atom_bios) { | ||
817 | atom_asic_init(rdev->mode_info.atom_context); | ||
818 | } else { | ||
819 | radeon_combios_asic_init(rdev->ddev); | ||
820 | } | ||
821 | /* Initialize clocks */ | ||
822 | r = radeon_clocks_init(rdev); | ||
823 | if (r) { | ||
824 | release_console_sem(); | ||
825 | return r; | ||
826 | } | ||
827 | /* Enable IRQ */ | ||
828 | rdev->irq.sw_int = true; | ||
829 | radeon_irq_set(rdev); | ||
830 | /* Initialize GPU Memory Controller */ | ||
831 | r = radeon_mc_init(rdev); | ||
832 | if (r) { | ||
833 | goto out; | ||
834 | } | ||
835 | r = radeon_gart_enable(rdev); | ||
836 | if (r) { | ||
837 | goto out; | ||
838 | } | ||
839 | r = radeon_cp_init(rdev, rdev->cp.ring_size); | ||
840 | if (r) { | ||
841 | goto out; | ||
842 | } | ||
843 | } else { | ||
844 | radeon_resume(rdev); | ||
845 | } | ||
846 | out: | ||
847 | radeon_restore_bios_scratch_regs(rdev); | 688 | radeon_restore_bios_scratch_regs(rdev); |
848 | fb_set_suspend(rdev->fbdev_info, 0); | 689 | fb_set_suspend(rdev->fbdev_info, 0); |
849 | release_console_sem(); | 690 | release_console_sem(); |
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c index 5d8141b13765..3655d91993a6 100644 --- a/drivers/gpu/drm/radeon/radeon_display.c +++ b/drivers/gpu/drm/radeon/radeon_display.c | |||
@@ -106,24 +106,33 @@ void radeon_crtc_load_lut(struct drm_crtc *crtc) | |||
106 | legacy_crtc_load_lut(crtc); | 106 | legacy_crtc_load_lut(crtc); |
107 | } | 107 | } |
108 | 108 | ||
109 | /** Sets the color ramps on behalf of RandR */ | 109 | /** Sets the color ramps on behalf of fbcon */ |
110 | void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | 110 | void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, |
111 | u16 blue, int regno) | 111 | u16 blue, int regno) |
112 | { | 112 | { |
113 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); | 113 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); |
114 | 114 | ||
115 | if (regno == 0) | ||
116 | DRM_DEBUG("gamma set %d\n", radeon_crtc->crtc_id); | ||
117 | radeon_crtc->lut_r[regno] = red >> 6; | 115 | radeon_crtc->lut_r[regno] = red >> 6; |
118 | radeon_crtc->lut_g[regno] = green >> 6; | 116 | radeon_crtc->lut_g[regno] = green >> 6; |
119 | radeon_crtc->lut_b[regno] = blue >> 6; | 117 | radeon_crtc->lut_b[regno] = blue >> 6; |
120 | } | 118 | } |
121 | 119 | ||
120 | /** Gets the color ramps on behalf of fbcon */ | ||
121 | void radeon_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
122 | u16 *blue, int regno) | ||
123 | { | ||
124 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); | ||
125 | |||
126 | *red = radeon_crtc->lut_r[regno] << 6; | ||
127 | *green = radeon_crtc->lut_g[regno] << 6; | ||
128 | *blue = radeon_crtc->lut_b[regno] << 6; | ||
129 | } | ||
130 | |||
122 | static void radeon_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, | 131 | static void radeon_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, |
123 | u16 *blue, uint32_t size) | 132 | u16 *blue, uint32_t size) |
124 | { | 133 | { |
125 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); | 134 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); |
126 | int i, j; | 135 | int i; |
127 | 136 | ||
128 | if (size != 256) { | 137 | if (size != 256) { |
129 | return; | 138 | return; |
@@ -132,23 +141,11 @@ static void radeon_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, | |||
132 | return; | 141 | return; |
133 | } | 142 | } |
134 | 143 | ||
135 | if (crtc->fb->depth == 16) { | 144 | /* userspace palettes are always correct as is */ |
136 | for (i = 0; i < 64; i++) { | 145 | for (i = 0; i < 256; i++) { |
137 | if (i <= 31) { | 146 | radeon_crtc->lut_r[i] = red[i] >> 6; |
138 | for (j = 0; j < 8; j++) { | 147 | radeon_crtc->lut_g[i] = green[i] >> 6; |
139 | radeon_crtc->lut_r[i * 8 + j] = red[i] >> 6; | 148 | radeon_crtc->lut_b[i] = blue[i] >> 6; |
140 | radeon_crtc->lut_b[i * 8 + j] = blue[i] >> 6; | ||
141 | } | ||
142 | } | ||
143 | for (j = 0; j < 4; j++) | ||
144 | radeon_crtc->lut_g[i * 4 + j] = green[i] >> 6; | ||
145 | } | ||
146 | } else { | ||
147 | for (i = 0; i < 256; i++) { | ||
148 | radeon_crtc->lut_r[i] = red[i] >> 6; | ||
149 | radeon_crtc->lut_g[i] = green[i] >> 6; | ||
150 | radeon_crtc->lut_b[i] = blue[i] >> 6; | ||
151 | } | ||
152 | } | 149 | } |
153 | 150 | ||
154 | radeon_crtc_load_lut(crtc); | 151 | radeon_crtc_load_lut(crtc); |
@@ -724,7 +721,11 @@ int radeon_modeset_init(struct radeon_device *rdev) | |||
724 | if (ret) { | 721 | if (ret) { |
725 | return ret; | 722 | return ret; |
726 | } | 723 | } |
727 | /* allocate crtcs - TODO single crtc */ | 724 | |
725 | if (rdev->flags & RADEON_SINGLE_CRTC) | ||
726 | num_crtc = 1; | ||
727 | |||
728 | /* allocate crtcs */ | ||
728 | for (i = 0; i < num_crtc; i++) { | 729 | for (i = 0; i < num_crtc; i++) { |
729 | radeon_crtc_init(rdev->ddev, i); | 730 | radeon_crtc_init(rdev->ddev, i); |
730 | } | 731 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c index 621646752cd2..a65ab1a0dad2 100644 --- a/drivers/gpu/drm/radeon/radeon_encoders.c +++ b/drivers/gpu/drm/radeon/radeon_encoders.c | |||
@@ -1345,6 +1345,7 @@ radeon_atombios_set_dig_info(struct radeon_encoder *radeon_encoder) | |||
1345 | void | 1345 | void |
1346 | radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t supported_device) | 1346 | radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t supported_device) |
1347 | { | 1347 | { |
1348 | struct radeon_device *rdev = dev->dev_private; | ||
1348 | struct drm_encoder *encoder; | 1349 | struct drm_encoder *encoder; |
1349 | struct radeon_encoder *radeon_encoder; | 1350 | struct radeon_encoder *radeon_encoder; |
1350 | 1351 | ||
@@ -1364,7 +1365,10 @@ radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t su | |||
1364 | return; | 1365 | return; |
1365 | 1366 | ||
1366 | encoder = &radeon_encoder->base; | 1367 | encoder = &radeon_encoder->base; |
1367 | encoder->possible_crtcs = 0x3; | 1368 | if (rdev->flags & RADEON_SINGLE_CRTC) |
1369 | encoder->possible_crtcs = 0x1; | ||
1370 | else | ||
1371 | encoder->possible_crtcs = 0x3; | ||
1368 | encoder->possible_clones = 0; | 1372 | encoder->possible_clones = 0; |
1369 | 1373 | ||
1370 | radeon_encoder->enc_priv = NULL; | 1374 | radeon_encoder->enc_priv = NULL; |
diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c index 1ba704eedefb..b38c4c8e2c61 100644 --- a/drivers/gpu/drm/radeon/radeon_fb.c +++ b/drivers/gpu/drm/radeon/radeon_fb.c | |||
@@ -55,6 +55,7 @@ static struct fb_ops radeonfb_ops = { | |||
55 | .fb_imageblit = cfb_imageblit, | 55 | .fb_imageblit = cfb_imageblit, |
56 | .fb_pan_display = drm_fb_helper_pan_display, | 56 | .fb_pan_display = drm_fb_helper_pan_display, |
57 | .fb_blank = drm_fb_helper_blank, | 57 | .fb_blank = drm_fb_helper_blank, |
58 | .fb_setcmap = drm_fb_helper_setcmap, | ||
58 | }; | 59 | }; |
59 | 60 | ||
60 | /** | 61 | /** |
@@ -123,6 +124,7 @@ static int radeon_align_pitch(struct radeon_device *rdev, int width, int bpp, bo | |||
123 | 124 | ||
124 | static struct drm_fb_helper_funcs radeon_fb_helper_funcs = { | 125 | static struct drm_fb_helper_funcs radeon_fb_helper_funcs = { |
125 | .gamma_set = radeon_crtc_fb_gamma_set, | 126 | .gamma_set = radeon_crtc_fb_gamma_set, |
127 | .gamma_get = radeon_crtc_fb_gamma_get, | ||
126 | }; | 128 | }; |
127 | 129 | ||
128 | int radeonfb_create(struct drm_device *dev, | 130 | int radeonfb_create(struct drm_device *dev, |
@@ -146,9 +148,15 @@ int radeonfb_create(struct drm_device *dev, | |||
146 | unsigned long tmp; | 148 | unsigned long tmp; |
147 | bool fb_tiled = false; /* useful for testing */ | 149 | bool fb_tiled = false; /* useful for testing */ |
148 | u32 tiling_flags = 0; | 150 | u32 tiling_flags = 0; |
151 | int crtc_count; | ||
149 | 152 | ||
150 | mode_cmd.width = surface_width; | 153 | mode_cmd.width = surface_width; |
151 | mode_cmd.height = surface_height; | 154 | mode_cmd.height = surface_height; |
155 | |||
156 | /* avivo can't scanout real 24bpp */ | ||
157 | if ((surface_bpp == 24) && ASIC_IS_AVIVO(rdev)) | ||
158 | surface_bpp = 32; | ||
159 | |||
152 | mode_cmd.bpp = surface_bpp; | 160 | mode_cmd.bpp = surface_bpp; |
153 | /* need to align pitch with crtc limits */ | 161 | /* need to align pitch with crtc limits */ |
154 | mode_cmd.pitch = radeon_align_pitch(rdev, mode_cmd.width, mode_cmd.bpp, fb_tiled) * ((mode_cmd.bpp + 1) / 8); | 162 | mode_cmd.pitch = radeon_align_pitch(rdev, mode_cmd.width, mode_cmd.bpp, fb_tiled) * ((mode_cmd.bpp + 1) / 8); |
@@ -217,7 +225,11 @@ int radeonfb_create(struct drm_device *dev, | |||
217 | rfbdev = info->par; | 225 | rfbdev = info->par; |
218 | rfbdev->helper.funcs = &radeon_fb_helper_funcs; | 226 | rfbdev->helper.funcs = &radeon_fb_helper_funcs; |
219 | rfbdev->helper.dev = dev; | 227 | rfbdev->helper.dev = dev; |
220 | ret = drm_fb_helper_init_crtc_count(&rfbdev->helper, 2, | 228 | if (rdev->flags & RADEON_SINGLE_CRTC) |
229 | crtc_count = 1; | ||
230 | else | ||
231 | crtc_count = 2; | ||
232 | ret = drm_fb_helper_init_crtc_count(&rfbdev->helper, crtc_count, | ||
221 | RADEONFB_CONN_LIMIT); | 233 | RADEONFB_CONN_LIMIT); |
222 | if (ret) | 234 | if (ret) |
223 | goto out_unref; | 235 | goto out_unref; |
@@ -234,7 +246,7 @@ int radeonfb_create(struct drm_device *dev, | |||
234 | 246 | ||
235 | strcpy(info->fix.id, "radeondrmfb"); | 247 | strcpy(info->fix.id, "radeondrmfb"); |
236 | 248 | ||
237 | drm_fb_helper_fill_fix(info, fb->pitch); | 249 | drm_fb_helper_fill_fix(info, fb->pitch, fb->depth); |
238 | 250 | ||
239 | info->flags = FBINFO_DEFAULT; | 251 | info->flags = FBINFO_DEFAULT; |
240 | info->fbops = &radeonfb_ops; | 252 | info->fbops = &radeonfb_ops; |
@@ -309,7 +321,7 @@ int radeon_parse_options(char *options) | |||
309 | 321 | ||
310 | int radeonfb_probe(struct drm_device *dev) | 322 | int radeonfb_probe(struct drm_device *dev) |
311 | { | 323 | { |
312 | return drm_fb_helper_single_fb_probe(dev, &radeonfb_create); | 324 | return drm_fb_helper_single_fb_probe(dev, 32, &radeonfb_create); |
313 | } | 325 | } |
314 | 326 | ||
315 | int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb) | 327 | int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb) |
diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c index 1841145a7c4f..8e0a8759e428 100644 --- a/drivers/gpu/drm/radeon/radeon_irq_kms.c +++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c | |||
@@ -83,8 +83,12 @@ void radeon_driver_irq_uninstall_kms(struct drm_device *dev) | |||
83 | int radeon_irq_kms_init(struct radeon_device *rdev) | 83 | int radeon_irq_kms_init(struct radeon_device *rdev) |
84 | { | 84 | { |
85 | int r = 0; | 85 | int r = 0; |
86 | int num_crtc = 2; | ||
86 | 87 | ||
87 | r = drm_vblank_init(rdev->ddev, 2); | 88 | if (rdev->flags & RADEON_SINGLE_CRTC) |
89 | num_crtc = 1; | ||
90 | |||
91 | r = drm_vblank_init(rdev->ddev, num_crtc); | ||
88 | if (r) { | 92 | if (r) { |
89 | return r; | 93 | return r; |
90 | } | 94 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c index 2b997a15fb1f..36410f85d705 100644 --- a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c +++ b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c | |||
@@ -1053,6 +1053,7 @@ static const struct drm_crtc_helper_funcs legacy_helper_funcs = { | |||
1053 | .mode_set_base = radeon_crtc_set_base, | 1053 | .mode_set_base = radeon_crtc_set_base, |
1054 | .prepare = radeon_crtc_prepare, | 1054 | .prepare = radeon_crtc_prepare, |
1055 | .commit = radeon_crtc_commit, | 1055 | .commit = radeon_crtc_commit, |
1056 | .load_lut = radeon_crtc_load_lut, | ||
1056 | }; | 1057 | }; |
1057 | 1058 | ||
1058 | 1059 | ||
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c index b1547f700d73..6ceb958fd194 100644 --- a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c +++ b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c | |||
@@ -881,7 +881,7 @@ static void radeon_legacy_tv_dac_mode_set(struct drm_encoder *encoder, | |||
881 | R420_TV_DAC_DACADJ_MASK | | 881 | R420_TV_DAC_DACADJ_MASK | |
882 | R420_TV_DAC_RDACPD | | 882 | R420_TV_DAC_RDACPD | |
883 | R420_TV_DAC_GDACPD | | 883 | R420_TV_DAC_GDACPD | |
884 | R420_TV_DAC_GDACPD | | 884 | R420_TV_DAC_BDACPD | |
885 | R420_TV_DAC_TVENABLE); | 885 | R420_TV_DAC_TVENABLE); |
886 | } else { | 886 | } else { |
887 | tv_dac_cntl &= ~(RADEON_TV_DAC_STD_MASK | | 887 | tv_dac_cntl &= ~(RADEON_TV_DAC_STD_MASK | |
@@ -889,7 +889,7 @@ static void radeon_legacy_tv_dac_mode_set(struct drm_encoder *encoder, | |||
889 | RADEON_TV_DAC_DACADJ_MASK | | 889 | RADEON_TV_DAC_DACADJ_MASK | |
890 | RADEON_TV_DAC_RDACPD | | 890 | RADEON_TV_DAC_RDACPD | |
891 | RADEON_TV_DAC_GDACPD | | 891 | RADEON_TV_DAC_GDACPD | |
892 | RADEON_TV_DAC_GDACPD); | 892 | RADEON_TV_DAC_BDACPD); |
893 | } | 893 | } |
894 | 894 | ||
895 | /* FIXME TV */ | 895 | /* FIXME TV */ |
@@ -1318,7 +1318,10 @@ radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t | |||
1318 | return; | 1318 | return; |
1319 | 1319 | ||
1320 | encoder = &radeon_encoder->base; | 1320 | encoder = &radeon_encoder->base; |
1321 | encoder->possible_crtcs = 0x3; | 1321 | if (rdev->flags & RADEON_SINGLE_CRTC) |
1322 | encoder->possible_crtcs = 0x1; | ||
1323 | else | ||
1324 | encoder->possible_crtcs = 0x3; | ||
1322 | encoder->possible_clones = 0; | 1325 | encoder->possible_clones = 0; |
1323 | 1326 | ||
1324 | radeon_encoder->enc_priv = NULL; | 1327 | radeon_encoder->enc_priv = NULL; |
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h index 570a58729daf..e61226817ccf 100644 --- a/drivers/gpu/drm/radeon/radeon_mode.h +++ b/drivers/gpu/drm/radeon/radeon_mode.h | |||
@@ -407,6 +407,8 @@ extern void | |||
407 | radeon_combios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on); | 407 | radeon_combios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on); |
408 | extern void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | 408 | extern void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, |
409 | u16 blue, int regno); | 409 | u16 blue, int regno); |
410 | extern void radeon_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
411 | u16 *blue, int regno); | ||
410 | struct drm_framebuffer *radeon_framebuffer_create(struct drm_device *dev, | 412 | struct drm_framebuffer *radeon_framebuffer_create(struct drm_device *dev, |
411 | struct drm_mode_fb_cmd *mode_cmd, | 413 | struct drm_mode_fb_cmd *mode_cmd, |
412 | struct drm_gem_object *obj); | 414 | struct drm_gem_object *obj); |
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c index 73af463b7a59..1f056dadc5c2 100644 --- a/drivers/gpu/drm/radeon/radeon_object.c +++ b/drivers/gpu/drm/radeon/radeon_object.c | |||
@@ -400,11 +400,9 @@ void radeon_object_list_add_object(struct radeon_object_list *lobj, | |||
400 | int radeon_object_list_reserve(struct list_head *head) | 400 | int radeon_object_list_reserve(struct list_head *head) |
401 | { | 401 | { |
402 | struct radeon_object_list *lobj; | 402 | struct radeon_object_list *lobj; |
403 | struct list_head *i; | ||
404 | int r; | 403 | int r; |
405 | 404 | ||
406 | list_for_each(i, head) { | 405 | list_for_each_entry(lobj, head, list){ |
407 | lobj = list_entry(i, struct radeon_object_list, list); | ||
408 | if (!lobj->robj->pin_count) { | 406 | if (!lobj->robj->pin_count) { |
409 | r = radeon_object_reserve(lobj->robj, true); | 407 | r = radeon_object_reserve(lobj->robj, true); |
410 | if (unlikely(r != 0)) { | 408 | if (unlikely(r != 0)) { |
@@ -420,13 +418,10 @@ int radeon_object_list_reserve(struct list_head *head) | |||
420 | void radeon_object_list_unreserve(struct list_head *head) | 418 | void radeon_object_list_unreserve(struct list_head *head) |
421 | { | 419 | { |
422 | struct radeon_object_list *lobj; | 420 | struct radeon_object_list *lobj; |
423 | struct list_head *i; | ||
424 | 421 | ||
425 | list_for_each(i, head) { | 422 | list_for_each_entry(lobj, head, list) { |
426 | lobj = list_entry(i, struct radeon_object_list, list); | ||
427 | if (!lobj->robj->pin_count) { | 423 | if (!lobj->robj->pin_count) { |
428 | radeon_object_unreserve(lobj->robj); | 424 | radeon_object_unreserve(lobj->robj); |
429 | } else { | ||
430 | } | 425 | } |
431 | } | 426 | } |
432 | } | 427 | } |
@@ -436,7 +431,6 @@ int radeon_object_list_validate(struct list_head *head, void *fence) | |||
436 | struct radeon_object_list *lobj; | 431 | struct radeon_object_list *lobj; |
437 | struct radeon_object *robj; | 432 | struct radeon_object *robj; |
438 | struct radeon_fence *old_fence = NULL; | 433 | struct radeon_fence *old_fence = NULL; |
439 | struct list_head *i; | ||
440 | int r; | 434 | int r; |
441 | 435 | ||
442 | r = radeon_object_list_reserve(head); | 436 | r = radeon_object_list_reserve(head); |
@@ -444,8 +438,7 @@ int radeon_object_list_validate(struct list_head *head, void *fence) | |||
444 | radeon_object_list_unreserve(head); | 438 | radeon_object_list_unreserve(head); |
445 | return r; | 439 | return r; |
446 | } | 440 | } |
447 | list_for_each(i, head) { | 441 | list_for_each_entry(lobj, head, list) { |
448 | lobj = list_entry(i, struct radeon_object_list, list); | ||
449 | robj = lobj->robj; | 442 | robj = lobj->robj; |
450 | if (!robj->pin_count) { | 443 | if (!robj->pin_count) { |
451 | if (lobj->wdomain) { | 444 | if (lobj->wdomain) { |
@@ -482,10 +475,8 @@ void radeon_object_list_unvalidate(struct list_head *head) | |||
482 | { | 475 | { |
483 | struct radeon_object_list *lobj; | 476 | struct radeon_object_list *lobj; |
484 | struct radeon_fence *old_fence = NULL; | 477 | struct radeon_fence *old_fence = NULL; |
485 | struct list_head *i; | ||
486 | 478 | ||
487 | list_for_each(i, head) { | 479 | list_for_each_entry(lobj, head, list) { |
488 | lobj = list_entry(i, struct radeon_object_list, list); | ||
489 | old_fence = (struct radeon_fence *)lobj->robj->tobj.sync_obj; | 480 | old_fence = (struct radeon_fence *)lobj->robj->tobj.sync_obj; |
490 | lobj->robj->tobj.sync_obj = NULL; | 481 | lobj->robj->tobj.sync_obj = NULL; |
491 | if (old_fence) { | 482 | if (old_fence) { |
diff --git a/drivers/gpu/drm/radeon/rs100d.h b/drivers/gpu/drm/radeon/rs100d.h new file mode 100644 index 000000000000..48a913a06cfd --- /dev/null +++ b/drivers/gpu/drm/radeon/rs100d.h | |||
@@ -0,0 +1,40 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef __RS100D_H__ | ||
29 | #define __RS100D_H__ | ||
30 | |||
31 | /* Registers */ | ||
32 | #define R_00015C_NB_TOM 0x00015C | ||
33 | #define S_00015C_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
34 | #define G_00015C_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
35 | #define C_00015C_MC_FB_START 0xFFFF0000 | ||
36 | #define S_00015C_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
37 | #define G_00015C_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
38 | #define C_00015C_MC_FB_TOP 0x0000FFFF | ||
39 | |||
40 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs400.c b/drivers/gpu/drm/radeon/rs400.c index a3fbdad938c7..a769c296f6a6 100644 --- a/drivers/gpu/drm/radeon/rs400.c +++ b/drivers/gpu/drm/radeon/rs400.c | |||
@@ -27,27 +27,12 @@ | |||
27 | */ | 27 | */ |
28 | #include <linux/seq_file.h> | 28 | #include <linux/seq_file.h> |
29 | #include <drm/drmP.h> | 29 | #include <drm/drmP.h> |
30 | #include "radeon_reg.h" | ||
31 | #include "radeon.h" | 30 | #include "radeon.h" |
31 | #include "rs400d.h" | ||
32 | 32 | ||
33 | /* rs400,rs480 depends on : */ | 33 | /* This files gather functions specifics to : rs400,rs480 */ |
34 | void r100_hdp_reset(struct radeon_device *rdev); | 34 | static int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev); |
35 | void r100_mc_disable_clients(struct radeon_device *rdev); | ||
36 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
37 | void r420_pipes_init(struct radeon_device *rdev); | ||
38 | 35 | ||
39 | /* This files gather functions specifics to : | ||
40 | * rs400,rs480 | ||
41 | * | ||
42 | * Some of these functions might be used by newer ASICs. | ||
43 | */ | ||
44 | void rs400_gpu_init(struct radeon_device *rdev); | ||
45 | int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev); | ||
46 | |||
47 | |||
48 | /* | ||
49 | * GART functions. | ||
50 | */ | ||
51 | void rs400_gart_adjust_size(struct radeon_device *rdev) | 36 | void rs400_gart_adjust_size(struct radeon_device *rdev) |
52 | { | 37 | { |
53 | /* Check gart size */ | 38 | /* Check gart size */ |
@@ -238,61 +223,6 @@ int rs400_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr) | |||
238 | return 0; | 223 | return 0; |
239 | } | 224 | } |
240 | 225 | ||
241 | |||
242 | /* | ||
243 | * MC functions. | ||
244 | */ | ||
245 | int rs400_mc_init(struct radeon_device *rdev) | ||
246 | { | ||
247 | uint32_t tmp; | ||
248 | int r; | ||
249 | |||
250 | if (r100_debugfs_rbbm_init(rdev)) { | ||
251 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
252 | } | ||
253 | |||
254 | rs400_gpu_init(rdev); | ||
255 | rs400_gart_disable(rdev); | ||
256 | rdev->mc.gtt_location = rdev->mc.mc_vram_size; | ||
257 | rdev->mc.gtt_location += (rdev->mc.gtt_size - 1); | ||
258 | rdev->mc.gtt_location &= ~(rdev->mc.gtt_size - 1); | ||
259 | r = radeon_mc_setup(rdev); | ||
260 | if (r) { | ||
261 | return r; | ||
262 | } | ||
263 | |||
264 | r100_mc_disable_clients(rdev); | ||
265 | if (r300_mc_wait_for_idle(rdev)) { | ||
266 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
267 | "programming pipes. Bad things might happen.\n"); | ||
268 | } | ||
269 | |||
270 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
271 | tmp = REG_SET(RADEON_MC_FB_TOP, tmp >> 16); | ||
272 | tmp |= REG_SET(RADEON_MC_FB_START, rdev->mc.vram_location >> 16); | ||
273 | WREG32(RADEON_MC_FB_LOCATION, tmp); | ||
274 | tmp = RREG32(RADEON_HOST_PATH_CNTL) | RADEON_HP_LIN_RD_CACHE_DIS; | ||
275 | WREG32(RADEON_HOST_PATH_CNTL, tmp | RADEON_HDP_SOFT_RESET | RADEON_HDP_READ_BUFFER_INVALIDATE); | ||
276 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
277 | WREG32(RADEON_HOST_PATH_CNTL, tmp); | ||
278 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
279 | |||
280 | return 0; | ||
281 | } | ||
282 | |||
283 | void rs400_mc_fini(struct radeon_device *rdev) | ||
284 | { | ||
285 | } | ||
286 | |||
287 | |||
288 | /* | ||
289 | * Global GPU functions | ||
290 | */ | ||
291 | void rs400_errata(struct radeon_device *rdev) | ||
292 | { | ||
293 | rdev->pll_errata = 0; | ||
294 | } | ||
295 | |||
296 | void rs400_gpu_init(struct radeon_device *rdev) | 226 | void rs400_gpu_init(struct radeon_device *rdev) |
297 | { | 227 | { |
298 | /* FIXME: HDP same place on rs400 ? */ | 228 | /* FIXME: HDP same place on rs400 ? */ |
@@ -305,10 +235,6 @@ void rs400_gpu_init(struct radeon_device *rdev) | |||
305 | } | 235 | } |
306 | } | 236 | } |
307 | 237 | ||
308 | |||
309 | /* | ||
310 | * VRAM info. | ||
311 | */ | ||
312 | void rs400_vram_info(struct radeon_device *rdev) | 238 | void rs400_vram_info(struct radeon_device *rdev) |
313 | { | 239 | { |
314 | rs400_gart_adjust_size(rdev); | 240 | rs400_gart_adjust_size(rdev); |
@@ -319,10 +245,6 @@ void rs400_vram_info(struct radeon_device *rdev) | |||
319 | r100_vram_init_sizes(rdev); | 245 | r100_vram_init_sizes(rdev); |
320 | } | 246 | } |
321 | 247 | ||
322 | |||
323 | /* | ||
324 | * Indirect registers accessor | ||
325 | */ | ||
326 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg) | 248 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg) |
327 | { | 249 | { |
328 | uint32_t r; | 250 | uint32_t r; |
@@ -340,10 +262,6 @@ void rs400_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | |||
340 | WREG32(RS480_NB_MC_INDEX, 0xff); | 262 | WREG32(RS480_NB_MC_INDEX, 0xff); |
341 | } | 263 | } |
342 | 264 | ||
343 | |||
344 | /* | ||
345 | * Debugfs info | ||
346 | */ | ||
347 | #if defined(CONFIG_DEBUG_FS) | 265 | #if defined(CONFIG_DEBUG_FS) |
348 | static int rs400_debugfs_gart_info(struct seq_file *m, void *data) | 266 | static int rs400_debugfs_gart_info(struct seq_file *m, void *data) |
349 | { | 267 | { |
@@ -419,7 +337,7 @@ static struct drm_info_list rs400_gart_info_list[] = { | |||
419 | }; | 337 | }; |
420 | #endif | 338 | #endif |
421 | 339 | ||
422 | int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | 340 | static int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev) |
423 | { | 341 | { |
424 | #if defined(CONFIG_DEBUG_FS) | 342 | #if defined(CONFIG_DEBUG_FS) |
425 | return radeon_debugfs_add_files(rdev, rs400_gart_info_list, 1); | 343 | return radeon_debugfs_add_files(rdev, rs400_gart_info_list, 1); |
@@ -427,3 +345,188 @@ int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | |||
427 | return 0; | 345 | return 0; |
428 | #endif | 346 | #endif |
429 | } | 347 | } |
348 | |||
349 | static int rs400_mc_init(struct radeon_device *rdev) | ||
350 | { | ||
351 | int r; | ||
352 | u32 tmp; | ||
353 | |||
354 | /* Setup GPU memory space */ | ||
355 | tmp = G_00015C_MC_FB_START(RREG32(R_00015C_NB_TOM)); | ||
356 | rdev->mc.vram_location = G_00015C_MC_FB_START(tmp) << 16; | ||
357 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
358 | r = radeon_mc_setup(rdev); | ||
359 | if (r) | ||
360 | return r; | ||
361 | return 0; | ||
362 | } | ||
363 | |||
364 | void rs400_mc_program(struct radeon_device *rdev) | ||
365 | { | ||
366 | struct r100_mc_save save; | ||
367 | |||
368 | /* Stops all mc clients */ | ||
369 | r100_mc_stop(rdev, &save); | ||
370 | |||
371 | /* Wait for mc idle */ | ||
372 | if (r300_mc_wait_for_idle(rdev)) | ||
373 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); | ||
374 | WREG32(R_000148_MC_FB_LOCATION, | ||
375 | S_000148_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
376 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
377 | |||
378 | r100_mc_resume(rdev, &save); | ||
379 | } | ||
380 | |||
381 | static int rs400_startup(struct radeon_device *rdev) | ||
382 | { | ||
383 | int r; | ||
384 | |||
385 | rs400_mc_program(rdev); | ||
386 | /* Resume clock */ | ||
387 | r300_clock_startup(rdev); | ||
388 | /* Initialize GPU configuration (# pipes, ...) */ | ||
389 | rs400_gpu_init(rdev); | ||
390 | /* Initialize GART (initialize after TTM so we can allocate | ||
391 | * memory through TTM but finalize after TTM) */ | ||
392 | r = rs400_gart_enable(rdev); | ||
393 | if (r) | ||
394 | return r; | ||
395 | /* Enable IRQ */ | ||
396 | rdev->irq.sw_int = true; | ||
397 | r100_irq_set(rdev); | ||
398 | /* 1M ring buffer */ | ||
399 | r = r100_cp_init(rdev, 1024 * 1024); | ||
400 | if (r) { | ||
401 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
402 | return r; | ||
403 | } | ||
404 | r = r100_wb_init(rdev); | ||
405 | if (r) | ||
406 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
407 | r = r100_ib_init(rdev); | ||
408 | if (r) { | ||
409 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
410 | return r; | ||
411 | } | ||
412 | return 0; | ||
413 | } | ||
414 | |||
415 | int rs400_resume(struct radeon_device *rdev) | ||
416 | { | ||
417 | /* Make sur GART are not working */ | ||
418 | rs400_gart_disable(rdev); | ||
419 | /* Resume clock before doing reset */ | ||
420 | r300_clock_startup(rdev); | ||
421 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
422 | if (radeon_gpu_reset(rdev)) { | ||
423 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
424 | RREG32(R_000E40_RBBM_STATUS), | ||
425 | RREG32(R_0007C0_CP_STAT)); | ||
426 | } | ||
427 | /* post */ | ||
428 | radeon_combios_asic_init(rdev->ddev); | ||
429 | /* Resume clock after posting */ | ||
430 | r300_clock_startup(rdev); | ||
431 | return rs400_startup(rdev); | ||
432 | } | ||
433 | |||
434 | int rs400_suspend(struct radeon_device *rdev) | ||
435 | { | ||
436 | r100_cp_disable(rdev); | ||
437 | r100_wb_disable(rdev); | ||
438 | r100_irq_disable(rdev); | ||
439 | rs400_gart_disable(rdev); | ||
440 | return 0; | ||
441 | } | ||
442 | |||
443 | void rs400_fini(struct radeon_device *rdev) | ||
444 | { | ||
445 | rs400_suspend(rdev); | ||
446 | r100_cp_fini(rdev); | ||
447 | r100_wb_fini(rdev); | ||
448 | r100_ib_fini(rdev); | ||
449 | radeon_gem_fini(rdev); | ||
450 | rs400_gart_fini(rdev); | ||
451 | radeon_irq_kms_fini(rdev); | ||
452 | radeon_fence_driver_fini(rdev); | ||
453 | radeon_object_fini(rdev); | ||
454 | radeon_atombios_fini(rdev); | ||
455 | kfree(rdev->bios); | ||
456 | rdev->bios = NULL; | ||
457 | } | ||
458 | |||
459 | int rs400_init(struct radeon_device *rdev) | ||
460 | { | ||
461 | int r; | ||
462 | |||
463 | /* Disable VGA */ | ||
464 | r100_vga_render_disable(rdev); | ||
465 | /* Initialize scratch registers */ | ||
466 | radeon_scratch_init(rdev); | ||
467 | /* Initialize surface registers */ | ||
468 | radeon_surface_init(rdev); | ||
469 | /* TODO: disable VGA need to use VGA request */ | ||
470 | /* BIOS*/ | ||
471 | if (!radeon_get_bios(rdev)) { | ||
472 | if (ASIC_IS_AVIVO(rdev)) | ||
473 | return -EINVAL; | ||
474 | } | ||
475 | if (rdev->is_atom_bios) { | ||
476 | dev_err(rdev->dev, "Expecting combios for RS400/RS480 GPU\n"); | ||
477 | return -EINVAL; | ||
478 | } else { | ||
479 | r = radeon_combios_init(rdev); | ||
480 | if (r) | ||
481 | return r; | ||
482 | } | ||
483 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
484 | if (radeon_gpu_reset(rdev)) { | ||
485 | dev_warn(rdev->dev, | ||
486 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
487 | RREG32(R_000E40_RBBM_STATUS), | ||
488 | RREG32(R_0007C0_CP_STAT)); | ||
489 | } | ||
490 | /* check if cards are posted or not */ | ||
491 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
492 | DRM_INFO("GPU not posted. posting now...\n"); | ||
493 | radeon_combios_asic_init(rdev->ddev); | ||
494 | } | ||
495 | /* Initialize clocks */ | ||
496 | radeon_get_clock_info(rdev->ddev); | ||
497 | /* Get vram informations */ | ||
498 | rs400_vram_info(rdev); | ||
499 | /* Initialize memory controller (also test AGP) */ | ||
500 | r = rs400_mc_init(rdev); | ||
501 | if (r) | ||
502 | return r; | ||
503 | /* Fence driver */ | ||
504 | r = radeon_fence_driver_init(rdev); | ||
505 | if (r) | ||
506 | return r; | ||
507 | r = radeon_irq_kms_init(rdev); | ||
508 | if (r) | ||
509 | return r; | ||
510 | /* Memory manager */ | ||
511 | r = radeon_object_init(rdev); | ||
512 | if (r) | ||
513 | return r; | ||
514 | r = rs400_gart_init(rdev); | ||
515 | if (r) | ||
516 | return r; | ||
517 | r300_set_reg_safe(rdev); | ||
518 | rdev->accel_working = true; | ||
519 | r = rs400_startup(rdev); | ||
520 | if (r) { | ||
521 | /* Somethings want wront with the accel init stop accel */ | ||
522 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
523 | rs400_suspend(rdev); | ||
524 | r100_cp_fini(rdev); | ||
525 | r100_wb_fini(rdev); | ||
526 | r100_ib_fini(rdev); | ||
527 | rs400_gart_fini(rdev); | ||
528 | radeon_irq_kms_fini(rdev); | ||
529 | rdev->accel_working = false; | ||
530 | } | ||
531 | return 0; | ||
532 | } | ||
diff --git a/drivers/gpu/drm/radeon/rs400d.h b/drivers/gpu/drm/radeon/rs400d.h new file mode 100644 index 000000000000..6d8bac58ced9 --- /dev/null +++ b/drivers/gpu/drm/radeon/rs400d.h | |||
@@ -0,0 +1,160 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef __RS400D_H__ | ||
29 | #define __RS400D_H__ | ||
30 | |||
31 | /* Registers */ | ||
32 | #define R_000148_MC_FB_LOCATION 0x000148 | ||
33 | #define S_000148_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
34 | #define G_000148_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
35 | #define C_000148_MC_FB_START 0xFFFF0000 | ||
36 | #define S_000148_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
37 | #define G_000148_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
38 | #define C_000148_MC_FB_TOP 0x0000FFFF | ||
39 | #define R_00015C_NB_TOM 0x00015C | ||
40 | #define S_00015C_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
41 | #define G_00015C_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
42 | #define C_00015C_MC_FB_START 0xFFFF0000 | ||
43 | #define S_00015C_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
44 | #define G_00015C_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
45 | #define C_00015C_MC_FB_TOP 0x0000FFFF | ||
46 | #define R_0007C0_CP_STAT 0x0007C0 | ||
47 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
48 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
49 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
50 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
51 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
52 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
53 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
54 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
55 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
56 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
57 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
58 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
59 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
60 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
61 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
62 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
63 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
64 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
65 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
66 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
67 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
68 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
69 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
70 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
71 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
72 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
73 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
74 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
75 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
76 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
77 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
78 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
79 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
80 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
81 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
82 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
83 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
84 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
85 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
86 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
87 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
88 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
89 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
90 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
91 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
92 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
93 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
94 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
95 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
96 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
97 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
98 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
99 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
100 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
101 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
102 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
103 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
104 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
105 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
106 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
107 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
108 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
109 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
110 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
111 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
112 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
113 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
114 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
115 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
116 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
117 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
118 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
119 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
120 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
121 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
122 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
123 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
124 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
125 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
126 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
127 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
128 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
129 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
130 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
131 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
132 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
133 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
134 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
135 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
136 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
137 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
138 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
139 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
140 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
141 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
142 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
143 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
144 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
145 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
146 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
147 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
148 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
149 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
150 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
151 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
152 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
153 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
154 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
155 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
156 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
157 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
158 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
159 | |||
160 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs600.c b/drivers/gpu/drm/radeon/rs600.c index 4a4fe1cb131c..10dfa78762da 100644 --- a/drivers/gpu/drm/radeon/rs600.c +++ b/drivers/gpu/drm/radeon/rs600.c | |||
@@ -25,27 +25,26 @@ | |||
25 | * Alex Deucher | 25 | * Alex Deucher |
26 | * Jerome Glisse | 26 | * Jerome Glisse |
27 | */ | 27 | */ |
28 | /* RS600 / Radeon X1250/X1270 integrated GPU | ||
29 | * | ||
30 | * This file gather function specific to RS600 which is the IGP of | ||
31 | * the X1250/X1270 family supporting intel CPU (while RS690/RS740 | ||
32 | * is the X1250/X1270 supporting AMD CPU). The display engine are | ||
33 | * the avivo one, bios is an atombios, 3D block are the one of the | ||
34 | * R4XX family. The GART is different from the RS400 one and is very | ||
35 | * close to the one of the R600 family (R600 likely being an evolution | ||
36 | * of the RS600 GART block). | ||
37 | */ | ||
28 | #include "drmP.h" | 38 | #include "drmP.h" |
29 | #include "radeon_reg.h" | ||
30 | #include "radeon.h" | 39 | #include "radeon.h" |
40 | #include "atom.h" | ||
41 | #include "rs600d.h" | ||
31 | 42 | ||
32 | #include "rs600_reg_safe.h" | 43 | #include "rs600_reg_safe.h" |
33 | 44 | ||
34 | /* rs600 depends on : */ | ||
35 | void r100_hdp_reset(struct radeon_device *rdev); | ||
36 | int r100_gui_wait_for_idle(struct radeon_device *rdev); | ||
37 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
38 | void r420_pipes_init(struct radeon_device *rdev); | ||
39 | |||
40 | /* This files gather functions specifics to : | ||
41 | * rs600 | ||
42 | * | ||
43 | * Some of these functions might be used by newer ASICs. | ||
44 | */ | ||
45 | void rs600_gpu_init(struct radeon_device *rdev); | 45 | void rs600_gpu_init(struct radeon_device *rdev); |
46 | int rs600_mc_wait_for_idle(struct radeon_device *rdev); | 46 | int rs600_mc_wait_for_idle(struct radeon_device *rdev); |
47 | 47 | ||
48 | |||
49 | /* | 48 | /* |
50 | * GART. | 49 | * GART. |
51 | */ | 50 | */ |
@@ -53,18 +52,18 @@ void rs600_gart_tlb_flush(struct radeon_device *rdev) | |||
53 | { | 52 | { |
54 | uint32_t tmp; | 53 | uint32_t tmp; |
55 | 54 | ||
56 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 55 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
57 | tmp &= ~(RS600_INVALIDATE_ALL_L1_TLBS | RS600_INVALIDATE_L2_CACHE); | 56 | tmp &= C_000100_INVALIDATE_ALL_L1_TLBS & C_000100_INVALIDATE_L2_CACHE; |
58 | WREG32_MC(RS600_MC_PT0_CNTL, tmp); | 57 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); |
59 | 58 | ||
60 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 59 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
61 | tmp |= RS600_INVALIDATE_ALL_L1_TLBS | RS600_INVALIDATE_L2_CACHE; | 60 | tmp |= S_000100_INVALIDATE_ALL_L1_TLBS(1) & S_000100_INVALIDATE_L2_CACHE(1); |
62 | WREG32_MC(RS600_MC_PT0_CNTL, tmp); | 61 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); |
63 | 62 | ||
64 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 63 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
65 | tmp &= ~(RS600_INVALIDATE_ALL_L1_TLBS | RS600_INVALIDATE_L2_CACHE); | 64 | tmp &= C_000100_INVALIDATE_ALL_L1_TLBS & C_000100_INVALIDATE_L2_CACHE; |
66 | WREG32_MC(RS600_MC_PT0_CNTL, tmp); | 65 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); |
67 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 66 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
68 | } | 67 | } |
69 | 68 | ||
70 | int rs600_gart_init(struct radeon_device *rdev) | 69 | int rs600_gart_init(struct radeon_device *rdev) |
@@ -86,7 +85,7 @@ int rs600_gart_init(struct radeon_device *rdev) | |||
86 | 85 | ||
87 | int rs600_gart_enable(struct radeon_device *rdev) | 86 | int rs600_gart_enable(struct radeon_device *rdev) |
88 | { | 87 | { |
89 | uint32_t tmp; | 88 | u32 tmp; |
90 | int r, i; | 89 | int r, i; |
91 | 90 | ||
92 | if (rdev->gart.table.vram.robj == NULL) { | 91 | if (rdev->gart.table.vram.robj == NULL) { |
@@ -96,46 +95,50 @@ int rs600_gart_enable(struct radeon_device *rdev) | |||
96 | r = radeon_gart_table_vram_pin(rdev); | 95 | r = radeon_gart_table_vram_pin(rdev); |
97 | if (r) | 96 | if (r) |
98 | return r; | 97 | return r; |
98 | /* Enable bus master */ | ||
99 | tmp = RREG32(R_00004C_BUS_CNTL) & C_00004C_BUS_MASTER_DIS; | ||
100 | WREG32(R_00004C_BUS_CNTL, tmp); | ||
99 | /* FIXME: setup default page */ | 101 | /* FIXME: setup default page */ |
100 | WREG32_MC(RS600_MC_PT0_CNTL, | 102 | WREG32_MC(R_000100_MC_PT0_CNTL, |
101 | (RS600_EFFECTIVE_L2_CACHE_SIZE(6) | | 103 | (S_000100_EFFECTIVE_L2_CACHE_SIZE(6) | |
102 | RS600_EFFECTIVE_L2_QUEUE_SIZE(6))); | 104 | S_000100_EFFECTIVE_L2_QUEUE_SIZE(6))); |
103 | for (i = 0; i < 19; i++) { | 105 | for (i = 0; i < 19; i++) { |
104 | WREG32_MC(RS600_MC_PT0_CLIENT0_CNTL + i, | 106 | WREG32_MC(R_00016C_MC_PT0_CLIENT0_CNTL + i, |
105 | (RS600_ENABLE_TRANSLATION_MODE_OVERRIDE | | 107 | S_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(1) | |
106 | RS600_SYSTEM_ACCESS_MODE_IN_SYS | | 108 | S_00016C_SYSTEM_ACCESS_MODE_MASK( |
107 | RS600_SYSTEM_APERTURE_UNMAPPED_ACCESS_DEFAULT_PAGE | | 109 | V_00016C_SYSTEM_ACCESS_MODE_IN_SYS) | |
108 | RS600_EFFECTIVE_L1_CACHE_SIZE(3) | | 110 | S_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS( |
109 | RS600_ENABLE_FRAGMENT_PROCESSING | | 111 | V_00016C_SYSTEM_APERTURE_UNMAPPED_DEFAULT_PAGE) | |
110 | RS600_EFFECTIVE_L1_QUEUE_SIZE(3))); | 112 | S_00016C_EFFECTIVE_L1_CACHE_SIZE(1) | |
113 | S_00016C_ENABLE_FRAGMENT_PROCESSING(1) | | ||
114 | S_00016C_EFFECTIVE_L1_QUEUE_SIZE(1)); | ||
111 | } | 115 | } |
112 | 116 | ||
113 | /* System context map to GART space */ | 117 | /* System context map to GART space */ |
114 | WREG32_MC(RS600_MC_PT0_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.gtt_location); | 118 | WREG32_MC(R_000112_MC_PT0_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.gtt_start); |
115 | tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; | 119 | WREG32_MC(R_000114_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR, rdev->mc.gtt_end); |
116 | WREG32_MC(RS600_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR, tmp); | ||
117 | 120 | ||
118 | /* enable first context */ | 121 | /* enable first context */ |
119 | WREG32_MC(RS600_MC_PT0_CONTEXT0_FLAT_START_ADDR, rdev->mc.gtt_location); | 122 | WREG32_MC(R_00013C_MC_PT0_CONTEXT0_FLAT_START_ADDR, rdev->mc.gtt_start); |
120 | tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; | 123 | WREG32_MC(R_00014C_MC_PT0_CONTEXT0_FLAT_END_ADDR, rdev->mc.gtt_end); |
121 | WREG32_MC(RS600_MC_PT0_CONTEXT0_FLAT_END_ADDR, tmp); | 124 | WREG32_MC(R_000102_MC_PT0_CONTEXT0_CNTL, |
122 | WREG32_MC(RS600_MC_PT0_CONTEXT0_CNTL, | 125 | S_000102_ENABLE_PAGE_TABLE(1) | |
123 | (RS600_ENABLE_PAGE_TABLE | RS600_PAGE_TABLE_TYPE_FLAT)); | 126 | S_000102_PAGE_TABLE_DEPTH(V_000102_PAGE_TABLE_FLAT)); |
124 | /* disable all other contexts */ | 127 | /* disable all other contexts */ |
125 | for (i = 1; i < 8; i++) { | 128 | for (i = 1; i < 8; i++) { |
126 | WREG32_MC(RS600_MC_PT0_CONTEXT0_CNTL + i, 0); | 129 | WREG32_MC(R_000102_MC_PT0_CONTEXT0_CNTL + i, 0); |
127 | } | 130 | } |
128 | 131 | ||
129 | /* setup the page table */ | 132 | /* setup the page table */ |
130 | WREG32_MC(RS600_MC_PT0_CONTEXT0_FLAT_BASE_ADDR, | 133 | WREG32_MC(R_00012C_MC_PT0_CONTEXT0_FLAT_BASE_ADDR, |
131 | rdev->gart.table_addr); | 134 | rdev->gart.table_addr); |
132 | WREG32_MC(RS600_MC_PT0_CONTEXT0_DEFAULT_READ_ADDR, 0); | 135 | WREG32_MC(R_00011C_MC_PT0_CONTEXT0_DEFAULT_READ_ADDR, 0); |
133 | 136 | ||
134 | /* enable page tables */ | 137 | /* enable page tables */ |
135 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 138 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
136 | WREG32_MC(RS600_MC_PT0_CNTL, (tmp | RS600_ENABLE_PT)); | 139 | WREG32_MC(R_000100_MC_PT0_CNTL, (tmp | S_000100_ENABLE_PT(1))); |
137 | tmp = RREG32_MC(RS600_MC_CNTL1); | 140 | tmp = RREG32_MC(R_000009_MC_CNTL1); |
138 | WREG32_MC(RS600_MC_CNTL1, (tmp | RS600_ENABLE_PAGE_TABLES)); | 141 | WREG32_MC(R_000009_MC_CNTL1, (tmp | S_000009_ENABLE_PAGE_TABLES(1))); |
139 | rs600_gart_tlb_flush(rdev); | 142 | rs600_gart_tlb_flush(rdev); |
140 | rdev->gart.ready = true; | 143 | rdev->gart.ready = true; |
141 | return 0; | 144 | return 0; |
@@ -146,10 +149,9 @@ void rs600_gart_disable(struct radeon_device *rdev) | |||
146 | uint32_t tmp; | 149 | uint32_t tmp; |
147 | 150 | ||
148 | /* FIXME: disable out of gart access */ | 151 | /* FIXME: disable out of gart access */ |
149 | WREG32_MC(RS600_MC_PT0_CNTL, 0); | 152 | WREG32_MC(R_000100_MC_PT0_CNTL, 0); |
150 | tmp = RREG32_MC(RS600_MC_CNTL1); | 153 | tmp = RREG32_MC(R_000009_MC_CNTL1); |
151 | tmp &= ~RS600_ENABLE_PAGE_TABLES; | 154 | WREG32_MC(R_000009_MC_CNTL1, tmp & C_000009_ENABLE_PAGE_TABLES); |
152 | WREG32_MC(RS600_MC_CNTL1, tmp); | ||
153 | if (rdev->gart.table.vram.robj) { | 155 | if (rdev->gart.table.vram.robj) { |
154 | radeon_object_kunmap(rdev->gart.table.vram.robj); | 156 | radeon_object_kunmap(rdev->gart.table.vram.robj); |
155 | radeon_object_unpin(rdev->gart.table.vram.robj); | 157 | radeon_object_unpin(rdev->gart.table.vram.robj); |
@@ -183,129 +185,61 @@ int rs600_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr) | |||
183 | return 0; | 185 | return 0; |
184 | } | 186 | } |
185 | 187 | ||
186 | |||
187 | /* | ||
188 | * MC. | ||
189 | */ | ||
190 | void rs600_mc_disable_clients(struct radeon_device *rdev) | ||
191 | { | ||
192 | unsigned tmp; | ||
193 | |||
194 | if (r100_gui_wait_for_idle(rdev)) { | ||
195 | printk(KERN_WARNING "Failed to wait GUI idle while " | ||
196 | "programming pipes. Bad things might happen.\n"); | ||
197 | } | ||
198 | |||
199 | rv515_vga_render_disable(rdev); | ||
200 | |||
201 | tmp = RREG32(AVIVO_D1VGA_CONTROL); | ||
202 | WREG32(AVIVO_D1VGA_CONTROL, tmp & ~AVIVO_DVGA_CONTROL_MODE_ENABLE); | ||
203 | tmp = RREG32(AVIVO_D2VGA_CONTROL); | ||
204 | WREG32(AVIVO_D2VGA_CONTROL, tmp & ~AVIVO_DVGA_CONTROL_MODE_ENABLE); | ||
205 | |||
206 | tmp = RREG32(AVIVO_D1CRTC_CONTROL); | ||
207 | WREG32(AVIVO_D1CRTC_CONTROL, tmp & ~AVIVO_CRTC_EN); | ||
208 | tmp = RREG32(AVIVO_D2CRTC_CONTROL); | ||
209 | WREG32(AVIVO_D2CRTC_CONTROL, tmp & ~AVIVO_CRTC_EN); | ||
210 | |||
211 | /* make sure all previous write got through */ | ||
212 | tmp = RREG32(AVIVO_D2CRTC_CONTROL); | ||
213 | |||
214 | mdelay(1); | ||
215 | } | ||
216 | |||
217 | int rs600_mc_init(struct radeon_device *rdev) | ||
218 | { | ||
219 | uint32_t tmp; | ||
220 | int r; | ||
221 | |||
222 | if (r100_debugfs_rbbm_init(rdev)) { | ||
223 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
224 | } | ||
225 | |||
226 | rs600_gpu_init(rdev); | ||
227 | rs600_gart_disable(rdev); | ||
228 | |||
229 | /* Setup GPU memory space */ | ||
230 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
231 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
232 | r = radeon_mc_setup(rdev); | ||
233 | if (r) { | ||
234 | return r; | ||
235 | } | ||
236 | |||
237 | /* Program GPU memory space */ | ||
238 | /* Enable bus master */ | ||
239 | tmp = RREG32(RADEON_BUS_CNTL) & ~RS600_BUS_MASTER_DIS; | ||
240 | WREG32(RADEON_BUS_CNTL, tmp); | ||
241 | /* FIXME: What does AGP means for such chipset ? */ | ||
242 | WREG32_MC(RS600_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
243 | /* FIXME: are this AGP reg in indirect MC range ? */ | ||
244 | WREG32_MC(RS600_MC_AGP_BASE, 0); | ||
245 | WREG32_MC(RS600_MC_AGP_BASE_2, 0); | ||
246 | rs600_mc_disable_clients(rdev); | ||
247 | if (rs600_mc_wait_for_idle(rdev)) { | ||
248 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
249 | "programming pipes. Bad things might happen.\n"); | ||
250 | } | ||
251 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
252 | tmp = REG_SET(RS600_MC_FB_TOP, tmp >> 16); | ||
253 | tmp |= REG_SET(RS600_MC_FB_START, rdev->mc.vram_location >> 16); | ||
254 | WREG32_MC(RS600_MC_FB_LOCATION, tmp); | ||
255 | WREG32(RS690_HDP_FB_LOCATION, rdev->mc.vram_location >> 16); | ||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | void rs600_mc_fini(struct radeon_device *rdev) | ||
260 | { | ||
261 | } | ||
262 | |||
263 | |||
264 | /* | ||
265 | * Interrupts | ||
266 | */ | ||
267 | int rs600_irq_set(struct radeon_device *rdev) | 188 | int rs600_irq_set(struct radeon_device *rdev) |
268 | { | 189 | { |
269 | uint32_t tmp = 0; | 190 | uint32_t tmp = 0; |
270 | uint32_t mode_int = 0; | 191 | uint32_t mode_int = 0; |
271 | 192 | ||
272 | if (rdev->irq.sw_int) { | 193 | if (rdev->irq.sw_int) { |
273 | tmp |= RADEON_SW_INT_ENABLE; | 194 | tmp |= S_000040_SW_INT_EN(1); |
274 | } | 195 | } |
275 | if (rdev->irq.crtc_vblank_int[0]) { | 196 | if (rdev->irq.crtc_vblank_int[0]) { |
276 | mode_int |= AVIVO_D1MODE_INT_MASK; | 197 | mode_int |= S_006540_D1MODE_VBLANK_INT_MASK(1); |
277 | } | 198 | } |
278 | if (rdev->irq.crtc_vblank_int[1]) { | 199 | if (rdev->irq.crtc_vblank_int[1]) { |
279 | mode_int |= AVIVO_D2MODE_INT_MASK; | 200 | mode_int |= S_006540_D2MODE_VBLANK_INT_MASK(1); |
280 | } | 201 | } |
281 | WREG32(RADEON_GEN_INT_CNTL, tmp); | 202 | WREG32(R_000040_GEN_INT_CNTL, tmp); |
282 | WREG32(AVIVO_DxMODE_INT_MASK, mode_int); | 203 | WREG32(R_006540_DxMODE_INT_MASK, mode_int); |
283 | return 0; | 204 | return 0; |
284 | } | 205 | } |
285 | 206 | ||
286 | static inline uint32_t rs600_irq_ack(struct radeon_device *rdev, u32 *r500_disp_int) | 207 | static inline uint32_t rs600_irq_ack(struct radeon_device *rdev, u32 *r500_disp_int) |
287 | { | 208 | { |
288 | uint32_t irqs = RREG32(RADEON_GEN_INT_STATUS); | 209 | uint32_t irqs = RREG32(R_000044_GEN_INT_STATUS); |
289 | uint32_t irq_mask = RADEON_SW_INT_TEST; | 210 | uint32_t irq_mask = ~C_000044_SW_INT; |
290 | 211 | ||
291 | if (irqs & AVIVO_DISPLAY_INT_STATUS) { | 212 | if (G_000044_DISPLAY_INT_STAT(irqs)) { |
292 | *r500_disp_int = RREG32(AVIVO_DISP_INTERRUPT_STATUS); | 213 | *r500_disp_int = RREG32(R_007EDC_DISP_INTERRUPT_STATUS); |
293 | if (*r500_disp_int & AVIVO_D1_VBLANK_INTERRUPT) { | 214 | if (G_007EDC_LB_D1_VBLANK_INTERRUPT(*r500_disp_int)) { |
294 | WREG32(AVIVO_D1MODE_VBLANK_STATUS, AVIVO_VBLANK_ACK); | 215 | WREG32(R_006534_D1MODE_VBLANK_STATUS, |
216 | S_006534_D1MODE_VBLANK_ACK(1)); | ||
295 | } | 217 | } |
296 | if (*r500_disp_int & AVIVO_D2_VBLANK_INTERRUPT) { | 218 | if (G_007EDC_LB_D2_VBLANK_INTERRUPT(*r500_disp_int)) { |
297 | WREG32(AVIVO_D2MODE_VBLANK_STATUS, AVIVO_VBLANK_ACK); | 219 | WREG32(R_006D34_D2MODE_VBLANK_STATUS, |
220 | S_006D34_D2MODE_VBLANK_ACK(1)); | ||
298 | } | 221 | } |
299 | } else { | 222 | } else { |
300 | *r500_disp_int = 0; | 223 | *r500_disp_int = 0; |
301 | } | 224 | } |
302 | 225 | ||
303 | if (irqs) { | 226 | if (irqs) { |
304 | WREG32(RADEON_GEN_INT_STATUS, irqs); | 227 | WREG32(R_000044_GEN_INT_STATUS, irqs); |
305 | } | 228 | } |
306 | return irqs & irq_mask; | 229 | return irqs & irq_mask; |
307 | } | 230 | } |
308 | 231 | ||
232 | void rs600_irq_disable(struct radeon_device *rdev) | ||
233 | { | ||
234 | u32 tmp; | ||
235 | |||
236 | WREG32(R_000040_GEN_INT_CNTL, 0); | ||
237 | WREG32(R_006540_DxMODE_INT_MASK, 0); | ||
238 | /* Wait and acknowledge irq */ | ||
239 | mdelay(1); | ||
240 | rs600_irq_ack(rdev, &tmp); | ||
241 | } | ||
242 | |||
309 | int rs600_irq_process(struct radeon_device *rdev) | 243 | int rs600_irq_process(struct radeon_device *rdev) |
310 | { | 244 | { |
311 | uint32_t status; | 245 | uint32_t status; |
@@ -317,16 +251,13 @@ int rs600_irq_process(struct radeon_device *rdev) | |||
317 | } | 251 | } |
318 | while (status || r500_disp_int) { | 252 | while (status || r500_disp_int) { |
319 | /* SW interrupt */ | 253 | /* SW interrupt */ |
320 | if (status & RADEON_SW_INT_TEST) { | 254 | if (G_000040_SW_INT_EN(status)) |
321 | radeon_fence_process(rdev); | 255 | radeon_fence_process(rdev); |
322 | } | ||
323 | /* Vertical blank interrupts */ | 256 | /* Vertical blank interrupts */ |
324 | if (r500_disp_int & AVIVO_D1_VBLANK_INTERRUPT) { | 257 | if (G_007EDC_LB_D1_VBLANK_INTERRUPT(r500_disp_int)) |
325 | drm_handle_vblank(rdev->ddev, 0); | 258 | drm_handle_vblank(rdev->ddev, 0); |
326 | } | 259 | if (G_007EDC_LB_D2_VBLANK_INTERRUPT(r500_disp_int)) |
327 | if (r500_disp_int & AVIVO_D2_VBLANK_INTERRUPT) { | ||
328 | drm_handle_vblank(rdev->ddev, 1); | 260 | drm_handle_vblank(rdev->ddev, 1); |
329 | } | ||
330 | status = rs600_irq_ack(rdev, &r500_disp_int); | 261 | status = rs600_irq_ack(rdev, &r500_disp_int); |
331 | } | 262 | } |
332 | return IRQ_HANDLED; | 263 | return IRQ_HANDLED; |
@@ -335,53 +266,34 @@ int rs600_irq_process(struct radeon_device *rdev) | |||
335 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc) | 266 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc) |
336 | { | 267 | { |
337 | if (crtc == 0) | 268 | if (crtc == 0) |
338 | return RREG32(AVIVO_D1CRTC_FRAME_COUNT); | 269 | return RREG32(R_0060A4_D1CRTC_STATUS_FRAME_COUNT); |
339 | else | 270 | else |
340 | return RREG32(AVIVO_D2CRTC_FRAME_COUNT); | 271 | return RREG32(R_0068A4_D2CRTC_STATUS_FRAME_COUNT); |
341 | } | 272 | } |
342 | 273 | ||
343 | |||
344 | /* | ||
345 | * Global GPU functions | ||
346 | */ | ||
347 | int rs600_mc_wait_for_idle(struct radeon_device *rdev) | 274 | int rs600_mc_wait_for_idle(struct radeon_device *rdev) |
348 | { | 275 | { |
349 | unsigned i; | 276 | unsigned i; |
350 | uint32_t tmp; | ||
351 | 277 | ||
352 | for (i = 0; i < rdev->usec_timeout; i++) { | 278 | for (i = 0; i < rdev->usec_timeout; i++) { |
353 | /* read MC_STATUS */ | 279 | if (G_000000_MC_IDLE(RREG32_MC(R_000000_MC_STATUS))) |
354 | tmp = RREG32_MC(RS600_MC_STATUS); | ||
355 | if (tmp & RS600_MC_STATUS_IDLE) { | ||
356 | return 0; | 280 | return 0; |
357 | } | 281 | udelay(1); |
358 | DRM_UDELAY(1); | ||
359 | } | 282 | } |
360 | return -1; | 283 | return -1; |
361 | } | 284 | } |
362 | 285 | ||
363 | void rs600_errata(struct radeon_device *rdev) | ||
364 | { | ||
365 | rdev->pll_errata = 0; | ||
366 | } | ||
367 | |||
368 | void rs600_gpu_init(struct radeon_device *rdev) | 286 | void rs600_gpu_init(struct radeon_device *rdev) |
369 | { | 287 | { |
370 | /* FIXME: HDP same place on rs600 ? */ | 288 | /* FIXME: HDP same place on rs600 ? */ |
371 | r100_hdp_reset(rdev); | 289 | r100_hdp_reset(rdev); |
372 | rv515_vga_render_disable(rdev); | ||
373 | /* FIXME: is this correct ? */ | 290 | /* FIXME: is this correct ? */ |
374 | r420_pipes_init(rdev); | 291 | r420_pipes_init(rdev); |
375 | if (rs600_mc_wait_for_idle(rdev)) { | 292 | /* Wait for mc idle */ |
376 | printk(KERN_WARNING "Failed to wait MC idle while " | 293 | if (rs600_mc_wait_for_idle(rdev)) |
377 | "programming pipes. Bad things might happen.\n"); | 294 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); |
378 | } | ||
379 | } | 295 | } |
380 | 296 | ||
381 | |||
382 | /* | ||
383 | * VRAM info. | ||
384 | */ | ||
385 | void rs600_vram_info(struct radeon_device *rdev) | 297 | void rs600_vram_info(struct radeon_device *rdev) |
386 | { | 298 | { |
387 | /* FIXME: to do or is these values sane ? */ | 299 | /* FIXME: to do or is these values sane ? */ |
@@ -394,31 +306,206 @@ void rs600_bandwidth_update(struct radeon_device *rdev) | |||
394 | /* FIXME: implement, should this be like rs690 ? */ | 306 | /* FIXME: implement, should this be like rs690 ? */ |
395 | } | 307 | } |
396 | 308 | ||
397 | |||
398 | /* | ||
399 | * Indirect registers accessor | ||
400 | */ | ||
401 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg) | 309 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg) |
402 | { | 310 | { |
403 | uint32_t r; | 311 | WREG32(R_000070_MC_IND_INDEX, S_000070_MC_IND_ADDR(reg) | |
404 | 312 | S_000070_MC_IND_CITF_ARB0(1)); | |
405 | WREG32(RS600_MC_INDEX, | 313 | return RREG32(R_000074_MC_IND_DATA); |
406 | ((reg & RS600_MC_ADDR_MASK) | RS600_MC_IND_CITF_ARB0)); | ||
407 | r = RREG32(RS600_MC_DATA); | ||
408 | return r; | ||
409 | } | 314 | } |
410 | 315 | ||
411 | void rs600_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | 316 | void rs600_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) |
412 | { | 317 | { |
413 | WREG32(RS600_MC_INDEX, | 318 | WREG32(R_000070_MC_IND_INDEX, S_000070_MC_IND_ADDR(reg) | |
414 | RS600_MC_IND_WR_EN | RS600_MC_IND_CITF_ARB0 | | 319 | S_000070_MC_IND_CITF_ARB0(1) | S_000070_MC_IND_WR_EN(1)); |
415 | ((reg) & RS600_MC_ADDR_MASK)); | 320 | WREG32(R_000074_MC_IND_DATA, v); |
416 | WREG32(RS600_MC_DATA, v); | ||
417 | } | 321 | } |
418 | 322 | ||
419 | int rs600_init(struct radeon_device *rdev) | 323 | void rs600_debugfs(struct radeon_device *rdev) |
324 | { | ||
325 | if (r100_debugfs_rbbm_init(rdev)) | ||
326 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
327 | } | ||
328 | |||
329 | void rs600_set_safe_registers(struct radeon_device *rdev) | ||
420 | { | 330 | { |
421 | rdev->config.r300.reg_safe_bm = rs600_reg_safe_bm; | 331 | rdev->config.r300.reg_safe_bm = rs600_reg_safe_bm; |
422 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(rs600_reg_safe_bm); | 332 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(rs600_reg_safe_bm); |
333 | } | ||
334 | |||
335 | static void rs600_mc_program(struct radeon_device *rdev) | ||
336 | { | ||
337 | struct rv515_mc_save save; | ||
338 | |||
339 | /* Stops all mc clients */ | ||
340 | rv515_mc_stop(rdev, &save); | ||
341 | |||
342 | /* Wait for mc idle */ | ||
343 | if (rs600_mc_wait_for_idle(rdev)) | ||
344 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); | ||
345 | |||
346 | /* FIXME: What does AGP means for such chipset ? */ | ||
347 | WREG32_MC(R_000005_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
348 | WREG32_MC(R_000006_AGP_BASE, 0); | ||
349 | WREG32_MC(R_000007_AGP_BASE_2, 0); | ||
350 | /* Program MC */ | ||
351 | WREG32_MC(R_000004_MC_FB_LOCATION, | ||
352 | S_000004_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
353 | S_000004_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
354 | WREG32(R_000134_HDP_FB_LOCATION, | ||
355 | S_000134_HDP_FB_START(rdev->mc.vram_start >> 16)); | ||
356 | |||
357 | rv515_mc_resume(rdev, &save); | ||
358 | } | ||
359 | |||
360 | static int rs600_startup(struct radeon_device *rdev) | ||
361 | { | ||
362 | int r; | ||
363 | |||
364 | rs600_mc_program(rdev); | ||
365 | /* Resume clock */ | ||
366 | rv515_clock_startup(rdev); | ||
367 | /* Initialize GPU configuration (# pipes, ...) */ | ||
368 | rs600_gpu_init(rdev); | ||
369 | /* Initialize GART (initialize after TTM so we can allocate | ||
370 | * memory through TTM but finalize after TTM) */ | ||
371 | r = rs600_gart_enable(rdev); | ||
372 | if (r) | ||
373 | return r; | ||
374 | /* Enable IRQ */ | ||
375 | rdev->irq.sw_int = true; | ||
376 | rs600_irq_set(rdev); | ||
377 | /* 1M ring buffer */ | ||
378 | r = r100_cp_init(rdev, 1024 * 1024); | ||
379 | if (r) { | ||
380 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
381 | return r; | ||
382 | } | ||
383 | r = r100_wb_init(rdev); | ||
384 | if (r) | ||
385 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
386 | r = r100_ib_init(rdev); | ||
387 | if (r) { | ||
388 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
389 | return r; | ||
390 | } | ||
391 | return 0; | ||
392 | } | ||
393 | |||
394 | int rs600_resume(struct radeon_device *rdev) | ||
395 | { | ||
396 | /* Make sur GART are not working */ | ||
397 | rs600_gart_disable(rdev); | ||
398 | /* Resume clock before doing reset */ | ||
399 | rv515_clock_startup(rdev); | ||
400 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
401 | if (radeon_gpu_reset(rdev)) { | ||
402 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
403 | RREG32(R_000E40_RBBM_STATUS), | ||
404 | RREG32(R_0007C0_CP_STAT)); | ||
405 | } | ||
406 | /* post */ | ||
407 | atom_asic_init(rdev->mode_info.atom_context); | ||
408 | /* Resume clock after posting */ | ||
409 | rv515_clock_startup(rdev); | ||
410 | return rs600_startup(rdev); | ||
411 | } | ||
412 | |||
413 | int rs600_suspend(struct radeon_device *rdev) | ||
414 | { | ||
415 | r100_cp_disable(rdev); | ||
416 | r100_wb_disable(rdev); | ||
417 | rs600_irq_disable(rdev); | ||
418 | rs600_gart_disable(rdev); | ||
419 | return 0; | ||
420 | } | ||
421 | |||
422 | void rs600_fini(struct radeon_device *rdev) | ||
423 | { | ||
424 | rs600_suspend(rdev); | ||
425 | r100_cp_fini(rdev); | ||
426 | r100_wb_fini(rdev); | ||
427 | r100_ib_fini(rdev); | ||
428 | radeon_gem_fini(rdev); | ||
429 | rs600_gart_fini(rdev); | ||
430 | radeon_irq_kms_fini(rdev); | ||
431 | radeon_fence_driver_fini(rdev); | ||
432 | radeon_object_fini(rdev); | ||
433 | radeon_atombios_fini(rdev); | ||
434 | kfree(rdev->bios); | ||
435 | rdev->bios = NULL; | ||
436 | } | ||
437 | |||
438 | int rs600_init(struct radeon_device *rdev) | ||
439 | { | ||
440 | int r; | ||
441 | |||
442 | /* Disable VGA */ | ||
443 | rv515_vga_render_disable(rdev); | ||
444 | /* Initialize scratch registers */ | ||
445 | radeon_scratch_init(rdev); | ||
446 | /* Initialize surface registers */ | ||
447 | radeon_surface_init(rdev); | ||
448 | /* BIOS */ | ||
449 | if (!radeon_get_bios(rdev)) { | ||
450 | if (ASIC_IS_AVIVO(rdev)) | ||
451 | return -EINVAL; | ||
452 | } | ||
453 | if (rdev->is_atom_bios) { | ||
454 | r = radeon_atombios_init(rdev); | ||
455 | if (r) | ||
456 | return r; | ||
457 | } else { | ||
458 | dev_err(rdev->dev, "Expecting atombios for RS600 GPU\n"); | ||
459 | return -EINVAL; | ||
460 | } | ||
461 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
462 | if (radeon_gpu_reset(rdev)) { | ||
463 | dev_warn(rdev->dev, | ||
464 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
465 | RREG32(R_000E40_RBBM_STATUS), | ||
466 | RREG32(R_0007C0_CP_STAT)); | ||
467 | } | ||
468 | /* check if cards are posted or not */ | ||
469 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
470 | DRM_INFO("GPU not posted. posting now...\n"); | ||
471 | atom_asic_init(rdev->mode_info.atom_context); | ||
472 | } | ||
473 | /* Initialize clocks */ | ||
474 | radeon_get_clock_info(rdev->ddev); | ||
475 | /* Get vram informations */ | ||
476 | rs600_vram_info(rdev); | ||
477 | /* Initialize memory controller (also test AGP) */ | ||
478 | r = r420_mc_init(rdev); | ||
479 | if (r) | ||
480 | return r; | ||
481 | rs600_debugfs(rdev); | ||
482 | /* Fence driver */ | ||
483 | r = radeon_fence_driver_init(rdev); | ||
484 | if (r) | ||
485 | return r; | ||
486 | r = radeon_irq_kms_init(rdev); | ||
487 | if (r) | ||
488 | return r; | ||
489 | /* Memory manager */ | ||
490 | r = radeon_object_init(rdev); | ||
491 | if (r) | ||
492 | return r; | ||
493 | r = rs600_gart_init(rdev); | ||
494 | if (r) | ||
495 | return r; | ||
496 | rs600_set_safe_registers(rdev); | ||
497 | rdev->accel_working = true; | ||
498 | r = rs600_startup(rdev); | ||
499 | if (r) { | ||
500 | /* Somethings want wront with the accel init stop accel */ | ||
501 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
502 | rs600_suspend(rdev); | ||
503 | r100_cp_fini(rdev); | ||
504 | r100_wb_fini(rdev); | ||
505 | r100_ib_fini(rdev); | ||
506 | rs600_gart_fini(rdev); | ||
507 | radeon_irq_kms_fini(rdev); | ||
508 | rdev->accel_working = false; | ||
509 | } | ||
423 | return 0; | 510 | return 0; |
424 | } | 511 | } |
diff --git a/drivers/gpu/drm/radeon/rs600d.h b/drivers/gpu/drm/radeon/rs600d.h new file mode 100644 index 000000000000..81308924859a --- /dev/null +++ b/drivers/gpu/drm/radeon/rs600d.h | |||
@@ -0,0 +1,470 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef __RS600D_H__ | ||
29 | #define __RS600D_H__ | ||
30 | |||
31 | /* Registers */ | ||
32 | #define R_000040_GEN_INT_CNTL 0x000040 | ||
33 | #define S_000040_DISPLAY_INT_STATUS(x) (((x) & 0x1) << 0) | ||
34 | #define G_000040_DISPLAY_INT_STATUS(x) (((x) >> 0) & 0x1) | ||
35 | #define C_000040_DISPLAY_INT_STATUS 0xFFFFFFFE | ||
36 | #define S_000040_DMA_VIPH0_INT_EN(x) (((x) & 0x1) << 12) | ||
37 | #define G_000040_DMA_VIPH0_INT_EN(x) (((x) >> 12) & 0x1) | ||
38 | #define C_000040_DMA_VIPH0_INT_EN 0xFFFFEFFF | ||
39 | #define S_000040_CRTC2_VSYNC(x) (((x) & 0x1) << 6) | ||
40 | #define G_000040_CRTC2_VSYNC(x) (((x) >> 6) & 0x1) | ||
41 | #define C_000040_CRTC2_VSYNC 0xFFFFFFBF | ||
42 | #define S_000040_SNAPSHOT2(x) (((x) & 0x1) << 7) | ||
43 | #define G_000040_SNAPSHOT2(x) (((x) >> 7) & 0x1) | ||
44 | #define C_000040_SNAPSHOT2 0xFFFFFF7F | ||
45 | #define S_000040_CRTC2_VBLANK(x) (((x) & 0x1) << 9) | ||
46 | #define G_000040_CRTC2_VBLANK(x) (((x) >> 9) & 0x1) | ||
47 | #define C_000040_CRTC2_VBLANK 0xFFFFFDFF | ||
48 | #define S_000040_FP2_DETECT(x) (((x) & 0x1) << 10) | ||
49 | #define G_000040_FP2_DETECT(x) (((x) >> 10) & 0x1) | ||
50 | #define C_000040_FP2_DETECT 0xFFFFFBFF | ||
51 | #define S_000040_VSYNC_DIFF_OVER_LIMIT(x) (((x) & 0x1) << 11) | ||
52 | #define G_000040_VSYNC_DIFF_OVER_LIMIT(x) (((x) >> 11) & 0x1) | ||
53 | #define C_000040_VSYNC_DIFF_OVER_LIMIT 0xFFFFF7FF | ||
54 | #define S_000040_DMA_VIPH1_INT_EN(x) (((x) & 0x1) << 13) | ||
55 | #define G_000040_DMA_VIPH1_INT_EN(x) (((x) >> 13) & 0x1) | ||
56 | #define C_000040_DMA_VIPH1_INT_EN 0xFFFFDFFF | ||
57 | #define S_000040_DMA_VIPH2_INT_EN(x) (((x) & 0x1) << 14) | ||
58 | #define G_000040_DMA_VIPH2_INT_EN(x) (((x) >> 14) & 0x1) | ||
59 | #define C_000040_DMA_VIPH2_INT_EN 0xFFFFBFFF | ||
60 | #define S_000040_DMA_VIPH3_INT_EN(x) (((x) & 0x1) << 15) | ||
61 | #define G_000040_DMA_VIPH3_INT_EN(x) (((x) >> 15) & 0x1) | ||
62 | #define C_000040_DMA_VIPH3_INT_EN 0xFFFF7FFF | ||
63 | #define S_000040_I2C_INT_EN(x) (((x) & 0x1) << 17) | ||
64 | #define G_000040_I2C_INT_EN(x) (((x) >> 17) & 0x1) | ||
65 | #define C_000040_I2C_INT_EN 0xFFFDFFFF | ||
66 | #define S_000040_GUI_IDLE(x) (((x) & 0x1) << 19) | ||
67 | #define G_000040_GUI_IDLE(x) (((x) >> 19) & 0x1) | ||
68 | #define C_000040_GUI_IDLE 0xFFF7FFFF | ||
69 | #define S_000040_VIPH_INT_EN(x) (((x) & 0x1) << 24) | ||
70 | #define G_000040_VIPH_INT_EN(x) (((x) >> 24) & 0x1) | ||
71 | #define C_000040_VIPH_INT_EN 0xFEFFFFFF | ||
72 | #define S_000040_SW_INT_EN(x) (((x) & 0x1) << 25) | ||
73 | #define G_000040_SW_INT_EN(x) (((x) >> 25) & 0x1) | ||
74 | #define C_000040_SW_INT_EN 0xFDFFFFFF | ||
75 | #define S_000040_GEYSERVILLE(x) (((x) & 0x1) << 27) | ||
76 | #define G_000040_GEYSERVILLE(x) (((x) >> 27) & 0x1) | ||
77 | #define C_000040_GEYSERVILLE 0xF7FFFFFF | ||
78 | #define S_000040_HDCP_AUTHORIZED_INT(x) (((x) & 0x1) << 28) | ||
79 | #define G_000040_HDCP_AUTHORIZED_INT(x) (((x) >> 28) & 0x1) | ||
80 | #define C_000040_HDCP_AUTHORIZED_INT 0xEFFFFFFF | ||
81 | #define S_000040_DVI_I2C_INT(x) (((x) & 0x1) << 29) | ||
82 | #define G_000040_DVI_I2C_INT(x) (((x) >> 29) & 0x1) | ||
83 | #define C_000040_DVI_I2C_INT 0xDFFFFFFF | ||
84 | #define S_000040_GUIDMA(x) (((x) & 0x1) << 30) | ||
85 | #define G_000040_GUIDMA(x) (((x) >> 30) & 0x1) | ||
86 | #define C_000040_GUIDMA 0xBFFFFFFF | ||
87 | #define S_000040_VIDDMA(x) (((x) & 0x1) << 31) | ||
88 | #define G_000040_VIDDMA(x) (((x) >> 31) & 0x1) | ||
89 | #define C_000040_VIDDMA 0x7FFFFFFF | ||
90 | #define R_000044_GEN_INT_STATUS 0x000044 | ||
91 | #define S_000044_DISPLAY_INT_STAT(x) (((x) & 0x1) << 0) | ||
92 | #define G_000044_DISPLAY_INT_STAT(x) (((x) >> 0) & 0x1) | ||
93 | #define C_000044_DISPLAY_INT_STAT 0xFFFFFFFE | ||
94 | #define S_000044_VGA_INT_STAT(x) (((x) & 0x1) << 1) | ||
95 | #define G_000044_VGA_INT_STAT(x) (((x) >> 1) & 0x1) | ||
96 | #define C_000044_VGA_INT_STAT 0xFFFFFFFD | ||
97 | #define S_000044_CAP0_INT_ACTIVE(x) (((x) & 0x1) << 8) | ||
98 | #define G_000044_CAP0_INT_ACTIVE(x) (((x) >> 8) & 0x1) | ||
99 | #define C_000044_CAP0_INT_ACTIVE 0xFFFFFEFF | ||
100 | #define S_000044_DMA_VIPH0_INT(x) (((x) & 0x1) << 12) | ||
101 | #define G_000044_DMA_VIPH0_INT(x) (((x) >> 12) & 0x1) | ||
102 | #define C_000044_DMA_VIPH0_INT 0xFFFFEFFF | ||
103 | #define S_000044_DMA_VIPH1_INT(x) (((x) & 0x1) << 13) | ||
104 | #define G_000044_DMA_VIPH1_INT(x) (((x) >> 13) & 0x1) | ||
105 | #define C_000044_DMA_VIPH1_INT 0xFFFFDFFF | ||
106 | #define S_000044_DMA_VIPH2_INT(x) (((x) & 0x1) << 14) | ||
107 | #define G_000044_DMA_VIPH2_INT(x) (((x) >> 14) & 0x1) | ||
108 | #define C_000044_DMA_VIPH2_INT 0xFFFFBFFF | ||
109 | #define S_000044_DMA_VIPH3_INT(x) (((x) & 0x1) << 15) | ||
110 | #define G_000044_DMA_VIPH3_INT(x) (((x) >> 15) & 0x1) | ||
111 | #define C_000044_DMA_VIPH3_INT 0xFFFF7FFF | ||
112 | #define S_000044_MC_PROBE_FAULT_STAT(x) (((x) & 0x1) << 16) | ||
113 | #define G_000044_MC_PROBE_FAULT_STAT(x) (((x) >> 16) & 0x1) | ||
114 | #define C_000044_MC_PROBE_FAULT_STAT 0xFFFEFFFF | ||
115 | #define S_000044_I2C_INT(x) (((x) & 0x1) << 17) | ||
116 | #define G_000044_I2C_INT(x) (((x) >> 17) & 0x1) | ||
117 | #define C_000044_I2C_INT 0xFFFDFFFF | ||
118 | #define S_000044_SCRATCH_INT_STAT(x) (((x) & 0x1) << 18) | ||
119 | #define G_000044_SCRATCH_INT_STAT(x) (((x) >> 18) & 0x1) | ||
120 | #define C_000044_SCRATCH_INT_STAT 0xFFFBFFFF | ||
121 | #define S_000044_GUI_IDLE_STAT(x) (((x) & 0x1) << 19) | ||
122 | #define G_000044_GUI_IDLE_STAT(x) (((x) >> 19) & 0x1) | ||
123 | #define C_000044_GUI_IDLE_STAT 0xFFF7FFFF | ||
124 | #define S_000044_ATI_OVERDRIVE_INT_STAT(x) (((x) & 0x1) << 20) | ||
125 | #define G_000044_ATI_OVERDRIVE_INT_STAT(x) (((x) >> 20) & 0x1) | ||
126 | #define C_000044_ATI_OVERDRIVE_INT_STAT 0xFFEFFFFF | ||
127 | #define S_000044_MC_PROTECTION_FAULT_STAT(x) (((x) & 0x1) << 21) | ||
128 | #define G_000044_MC_PROTECTION_FAULT_STAT(x) (((x) >> 21) & 0x1) | ||
129 | #define C_000044_MC_PROTECTION_FAULT_STAT 0xFFDFFFFF | ||
130 | #define S_000044_RBBM_READ_INT_STAT(x) (((x) & 0x1) << 22) | ||
131 | #define G_000044_RBBM_READ_INT_STAT(x) (((x) >> 22) & 0x1) | ||
132 | #define C_000044_RBBM_READ_INT_STAT 0xFFBFFFFF | ||
133 | #define S_000044_CB_CONTEXT_SWITCH_STAT(x) (((x) & 0x1) << 23) | ||
134 | #define G_000044_CB_CONTEXT_SWITCH_STAT(x) (((x) >> 23) & 0x1) | ||
135 | #define C_000044_CB_CONTEXT_SWITCH_STAT 0xFF7FFFFF | ||
136 | #define S_000044_VIPH_INT(x) (((x) & 0x1) << 24) | ||
137 | #define G_000044_VIPH_INT(x) (((x) >> 24) & 0x1) | ||
138 | #define C_000044_VIPH_INT 0xFEFFFFFF | ||
139 | #define S_000044_SW_INT(x) (((x) & 0x1) << 25) | ||
140 | #define G_000044_SW_INT(x) (((x) >> 25) & 0x1) | ||
141 | #define C_000044_SW_INT 0xFDFFFFFF | ||
142 | #define S_000044_SW_INT_SET(x) (((x) & 0x1) << 26) | ||
143 | #define G_000044_SW_INT_SET(x) (((x) >> 26) & 0x1) | ||
144 | #define C_000044_SW_INT_SET 0xFBFFFFFF | ||
145 | #define S_000044_IDCT_INT_STAT(x) (((x) & 0x1) << 27) | ||
146 | #define G_000044_IDCT_INT_STAT(x) (((x) >> 27) & 0x1) | ||
147 | #define C_000044_IDCT_INT_STAT 0xF7FFFFFF | ||
148 | #define S_000044_GUIDMA_STAT(x) (((x) & 0x1) << 30) | ||
149 | #define G_000044_GUIDMA_STAT(x) (((x) >> 30) & 0x1) | ||
150 | #define C_000044_GUIDMA_STAT 0xBFFFFFFF | ||
151 | #define S_000044_VIDDMA_STAT(x) (((x) & 0x1) << 31) | ||
152 | #define G_000044_VIDDMA_STAT(x) (((x) >> 31) & 0x1) | ||
153 | #define C_000044_VIDDMA_STAT 0x7FFFFFFF | ||
154 | #define R_00004C_BUS_CNTL 0x00004C | ||
155 | #define S_00004C_BUS_MASTER_DIS(x) (((x) & 0x1) << 14) | ||
156 | #define G_00004C_BUS_MASTER_DIS(x) (((x) >> 14) & 0x1) | ||
157 | #define C_00004C_BUS_MASTER_DIS 0xFFFFBFFF | ||
158 | #define S_00004C_BUS_MSI_REARM(x) (((x) & 0x1) << 20) | ||
159 | #define G_00004C_BUS_MSI_REARM(x) (((x) >> 20) & 0x1) | ||
160 | #define C_00004C_BUS_MSI_REARM 0xFFEFFFFF | ||
161 | #define R_000070_MC_IND_INDEX 0x000070 | ||
162 | #define S_000070_MC_IND_ADDR(x) (((x) & 0xFFFF) << 0) | ||
163 | #define G_000070_MC_IND_ADDR(x) (((x) >> 0) & 0xFFFF) | ||
164 | #define C_000070_MC_IND_ADDR 0xFFFF0000 | ||
165 | #define S_000070_MC_IND_SEQ_RBS_0(x) (((x) & 0x1) << 16) | ||
166 | #define G_000070_MC_IND_SEQ_RBS_0(x) (((x) >> 16) & 0x1) | ||
167 | #define C_000070_MC_IND_SEQ_RBS_0 0xFFFEFFFF | ||
168 | #define S_000070_MC_IND_SEQ_RBS_1(x) (((x) & 0x1) << 17) | ||
169 | #define G_000070_MC_IND_SEQ_RBS_1(x) (((x) >> 17) & 0x1) | ||
170 | #define C_000070_MC_IND_SEQ_RBS_1 0xFFFDFFFF | ||
171 | #define S_000070_MC_IND_SEQ_RBS_2(x) (((x) & 0x1) << 18) | ||
172 | #define G_000070_MC_IND_SEQ_RBS_2(x) (((x) >> 18) & 0x1) | ||
173 | #define C_000070_MC_IND_SEQ_RBS_2 0xFFFBFFFF | ||
174 | #define S_000070_MC_IND_SEQ_RBS_3(x) (((x) & 0x1) << 19) | ||
175 | #define G_000070_MC_IND_SEQ_RBS_3(x) (((x) >> 19) & 0x1) | ||
176 | #define C_000070_MC_IND_SEQ_RBS_3 0xFFF7FFFF | ||
177 | #define S_000070_MC_IND_AIC_RBS(x) (((x) & 0x1) << 20) | ||
178 | #define G_000070_MC_IND_AIC_RBS(x) (((x) >> 20) & 0x1) | ||
179 | #define C_000070_MC_IND_AIC_RBS 0xFFEFFFFF | ||
180 | #define S_000070_MC_IND_CITF_ARB0(x) (((x) & 0x1) << 21) | ||
181 | #define G_000070_MC_IND_CITF_ARB0(x) (((x) >> 21) & 0x1) | ||
182 | #define C_000070_MC_IND_CITF_ARB0 0xFFDFFFFF | ||
183 | #define S_000070_MC_IND_CITF_ARB1(x) (((x) & 0x1) << 22) | ||
184 | #define G_000070_MC_IND_CITF_ARB1(x) (((x) >> 22) & 0x1) | ||
185 | #define C_000070_MC_IND_CITF_ARB1 0xFFBFFFFF | ||
186 | #define S_000070_MC_IND_WR_EN(x) (((x) & 0x1) << 23) | ||
187 | #define G_000070_MC_IND_WR_EN(x) (((x) >> 23) & 0x1) | ||
188 | #define C_000070_MC_IND_WR_EN 0xFF7FFFFF | ||
189 | #define S_000070_MC_IND_RD_INV(x) (((x) & 0x1) << 24) | ||
190 | #define G_000070_MC_IND_RD_INV(x) (((x) >> 24) & 0x1) | ||
191 | #define C_000070_MC_IND_RD_INV 0xFEFFFFFF | ||
192 | #define R_000074_MC_IND_DATA 0x000074 | ||
193 | #define S_000074_MC_IND_DATA(x) (((x) & 0xFFFFFFFF) << 0) | ||
194 | #define G_000074_MC_IND_DATA(x) (((x) >> 0) & 0xFFFFFFFF) | ||
195 | #define C_000074_MC_IND_DATA 0x00000000 | ||
196 | #define R_000134_HDP_FB_LOCATION 0x000134 | ||
197 | #define S_000134_HDP_FB_START(x) (((x) & 0xFFFF) << 0) | ||
198 | #define G_000134_HDP_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
199 | #define C_000134_HDP_FB_START 0xFFFF0000 | ||
200 | #define R_0007C0_CP_STAT 0x0007C0 | ||
201 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
202 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
203 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
204 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
205 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
206 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
207 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
208 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
209 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
210 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
211 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
212 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
213 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
214 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
215 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
216 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
217 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
218 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
219 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
220 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
221 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
222 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
223 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
224 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
225 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
226 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
227 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
228 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
229 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
230 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
231 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
232 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
233 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
234 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
235 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
236 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
237 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
238 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
239 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
240 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
241 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
242 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
243 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
244 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
245 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
246 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
247 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
248 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
249 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
250 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
251 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
252 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
253 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
254 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
255 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
256 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
257 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
258 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
259 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
260 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
261 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
262 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
263 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
264 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
265 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
266 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
267 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
268 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
269 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
270 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
271 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
272 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
273 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
274 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
275 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
276 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
277 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
278 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
279 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
280 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
281 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
282 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
283 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
284 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
285 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
286 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
287 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
288 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
289 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
290 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
291 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
292 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
293 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
294 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
295 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
296 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
297 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
298 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
299 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
300 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
301 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
302 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
303 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
304 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
305 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
306 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
307 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
308 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
309 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
310 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
311 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
312 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
313 | #define R_0060A4_D1CRTC_STATUS_FRAME_COUNT 0x0060A4 | ||
314 | #define S_0060A4_D1CRTC_FRAME_COUNT(x) (((x) & 0xFFFFFF) << 0) | ||
315 | #define G_0060A4_D1CRTC_FRAME_COUNT(x) (((x) >> 0) & 0xFFFFFF) | ||
316 | #define C_0060A4_D1CRTC_FRAME_COUNT 0xFF000000 | ||
317 | #define R_006534_D1MODE_VBLANK_STATUS 0x006534 | ||
318 | #define S_006534_D1MODE_VBLANK_OCCURRED(x) (((x) & 0x1) << 0) | ||
319 | #define G_006534_D1MODE_VBLANK_OCCURRED(x) (((x) >> 0) & 0x1) | ||
320 | #define C_006534_D1MODE_VBLANK_OCCURRED 0xFFFFFFFE | ||
321 | #define S_006534_D1MODE_VBLANK_ACK(x) (((x) & 0x1) << 4) | ||
322 | #define G_006534_D1MODE_VBLANK_ACK(x) (((x) >> 4) & 0x1) | ||
323 | #define C_006534_D1MODE_VBLANK_ACK 0xFFFFFFEF | ||
324 | #define S_006534_D1MODE_VBLANK_STAT(x) (((x) & 0x1) << 12) | ||
325 | #define G_006534_D1MODE_VBLANK_STAT(x) (((x) >> 12) & 0x1) | ||
326 | #define C_006534_D1MODE_VBLANK_STAT 0xFFFFEFFF | ||
327 | #define S_006534_D1MODE_VBLANK_INTERRUPT(x) (((x) & 0x1) << 16) | ||
328 | #define G_006534_D1MODE_VBLANK_INTERRUPT(x) (((x) >> 16) & 0x1) | ||
329 | #define C_006534_D1MODE_VBLANK_INTERRUPT 0xFFFEFFFF | ||
330 | #define R_006540_DxMODE_INT_MASK 0x006540 | ||
331 | #define S_006540_D1MODE_VBLANK_INT_MASK(x) (((x) & 0x1) << 0) | ||
332 | #define G_006540_D1MODE_VBLANK_INT_MASK(x) (((x) >> 0) & 0x1) | ||
333 | #define C_006540_D1MODE_VBLANK_INT_MASK 0xFFFFFFFE | ||
334 | #define S_006540_D1MODE_VLINE_INT_MASK(x) (((x) & 0x1) << 4) | ||
335 | #define G_006540_D1MODE_VLINE_INT_MASK(x) (((x) >> 4) & 0x1) | ||
336 | #define C_006540_D1MODE_VLINE_INT_MASK 0xFFFFFFEF | ||
337 | #define S_006540_D2MODE_VBLANK_INT_MASK(x) (((x) & 0x1) << 8) | ||
338 | #define G_006540_D2MODE_VBLANK_INT_MASK(x) (((x) >> 8) & 0x1) | ||
339 | #define C_006540_D2MODE_VBLANK_INT_MASK 0xFFFFFEFF | ||
340 | #define S_006540_D2MODE_VLINE_INT_MASK(x) (((x) & 0x1) << 12) | ||
341 | #define G_006540_D2MODE_VLINE_INT_MASK(x) (((x) >> 12) & 0x1) | ||
342 | #define C_006540_D2MODE_VLINE_INT_MASK 0xFFFFEFFF | ||
343 | #define S_006540_D1MODE_VBLANK_CP_SEL(x) (((x) & 0x1) << 30) | ||
344 | #define G_006540_D1MODE_VBLANK_CP_SEL(x) (((x) >> 30) & 0x1) | ||
345 | #define C_006540_D1MODE_VBLANK_CP_SEL 0xBFFFFFFF | ||
346 | #define S_006540_D2MODE_VBLANK_CP_SEL(x) (((x) & 0x1) << 31) | ||
347 | #define G_006540_D2MODE_VBLANK_CP_SEL(x) (((x) >> 31) & 0x1) | ||
348 | #define C_006540_D2MODE_VBLANK_CP_SEL 0x7FFFFFFF | ||
349 | #define R_0068A4_D2CRTC_STATUS_FRAME_COUNT 0x0068A4 | ||
350 | #define S_0068A4_D2CRTC_FRAME_COUNT(x) (((x) & 0xFFFFFF) << 0) | ||
351 | #define G_0068A4_D2CRTC_FRAME_COUNT(x) (((x) >> 0) & 0xFFFFFF) | ||
352 | #define C_0068A4_D2CRTC_FRAME_COUNT 0xFF000000 | ||
353 | #define R_006D34_D2MODE_VBLANK_STATUS 0x006D34 | ||
354 | #define S_006D34_D2MODE_VBLANK_OCCURRED(x) (((x) & 0x1) << 0) | ||
355 | #define G_006D34_D2MODE_VBLANK_OCCURRED(x) (((x) >> 0) & 0x1) | ||
356 | #define C_006D34_D2MODE_VBLANK_OCCURRED 0xFFFFFFFE | ||
357 | #define S_006D34_D2MODE_VBLANK_ACK(x) (((x) & 0x1) << 4) | ||
358 | #define G_006D34_D2MODE_VBLANK_ACK(x) (((x) >> 4) & 0x1) | ||
359 | #define C_006D34_D2MODE_VBLANK_ACK 0xFFFFFFEF | ||
360 | #define S_006D34_D2MODE_VBLANK_STAT(x) (((x) & 0x1) << 12) | ||
361 | #define G_006D34_D2MODE_VBLANK_STAT(x) (((x) >> 12) & 0x1) | ||
362 | #define C_006D34_D2MODE_VBLANK_STAT 0xFFFFEFFF | ||
363 | #define S_006D34_D2MODE_VBLANK_INTERRUPT(x) (((x) & 0x1) << 16) | ||
364 | #define G_006D34_D2MODE_VBLANK_INTERRUPT(x) (((x) >> 16) & 0x1) | ||
365 | #define C_006D34_D2MODE_VBLANK_INTERRUPT 0xFFFEFFFF | ||
366 | #define R_007EDC_DISP_INTERRUPT_STATUS 0x007EDC | ||
367 | #define S_007EDC_LB_D1_VBLANK_INTERRUPT(x) (((x) & 0x1) << 4) | ||
368 | #define G_007EDC_LB_D1_VBLANK_INTERRUPT(x) (((x) >> 4) & 0x1) | ||
369 | #define C_007EDC_LB_D1_VBLANK_INTERRUPT 0xFFFFFFEF | ||
370 | #define S_007EDC_LB_D2_VBLANK_INTERRUPT(x) (((x) & 0x1) << 5) | ||
371 | #define G_007EDC_LB_D2_VBLANK_INTERRUPT(x) (((x) >> 5) & 0x1) | ||
372 | #define C_007EDC_LB_D2_VBLANK_INTERRUPT 0xFFFFFFDF | ||
373 | |||
374 | |||
375 | /* MC registers */ | ||
376 | #define R_000000_MC_STATUS 0x000000 | ||
377 | #define S_000000_MC_IDLE(x) (((x) & 0x1) << 0) | ||
378 | #define G_000000_MC_IDLE(x) (((x) >> 0) & 0x1) | ||
379 | #define C_000000_MC_IDLE 0xFFFFFFFE | ||
380 | #define R_000004_MC_FB_LOCATION 0x000004 | ||
381 | #define S_000004_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
382 | #define G_000004_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
383 | #define C_000004_MC_FB_START 0xFFFF0000 | ||
384 | #define S_000004_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
385 | #define G_000004_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
386 | #define C_000004_MC_FB_TOP 0x0000FFFF | ||
387 | #define R_000005_MC_AGP_LOCATION 0x000005 | ||
388 | #define S_000005_MC_AGP_START(x) (((x) & 0xFFFF) << 0) | ||
389 | #define G_000005_MC_AGP_START(x) (((x) >> 0) & 0xFFFF) | ||
390 | #define C_000005_MC_AGP_START 0xFFFF0000 | ||
391 | #define S_000005_MC_AGP_TOP(x) (((x) & 0xFFFF) << 16) | ||
392 | #define G_000005_MC_AGP_TOP(x) (((x) >> 16) & 0xFFFF) | ||
393 | #define C_000005_MC_AGP_TOP 0x0000FFFF | ||
394 | #define R_000006_AGP_BASE 0x000006 | ||
395 | #define S_000006_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | ||
396 | #define G_000006_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | ||
397 | #define C_000006_AGP_BASE_ADDR 0x00000000 | ||
398 | #define R_000007_AGP_BASE_2 0x000007 | ||
399 | #define S_000007_AGP_BASE_ADDR_2(x) (((x) & 0xF) << 0) | ||
400 | #define G_000007_AGP_BASE_ADDR_2(x) (((x) >> 0) & 0xF) | ||
401 | #define C_000007_AGP_BASE_ADDR_2 0xFFFFFFF0 | ||
402 | #define R_000009_MC_CNTL1 0x000009 | ||
403 | #define S_000009_ENABLE_PAGE_TABLES(x) (((x) & 0x1) << 26) | ||
404 | #define G_000009_ENABLE_PAGE_TABLES(x) (((x) >> 26) & 0x1) | ||
405 | #define C_000009_ENABLE_PAGE_TABLES 0xFBFFFFFF | ||
406 | /* FIXME don't know the various field size need feedback from AMD */ | ||
407 | #define R_000100_MC_PT0_CNTL 0x000100 | ||
408 | #define S_000100_ENABLE_PT(x) (((x) & 0x1) << 0) | ||
409 | #define G_000100_ENABLE_PT(x) (((x) >> 0) & 0x1) | ||
410 | #define C_000100_ENABLE_PT 0xFFFFFFFE | ||
411 | #define S_000100_EFFECTIVE_L2_CACHE_SIZE(x) (((x) & 0x7) << 15) | ||
412 | #define G_000100_EFFECTIVE_L2_CACHE_SIZE(x) (((x) >> 15) & 0x7) | ||
413 | #define C_000100_EFFECTIVE_L2_CACHE_SIZE 0xFFFC7FFF | ||
414 | #define S_000100_EFFECTIVE_L2_QUEUE_SIZE(x) (((x) & 0x7) << 21) | ||
415 | #define G_000100_EFFECTIVE_L2_QUEUE_SIZE(x) (((x) >> 21) & 0x7) | ||
416 | #define C_000100_EFFECTIVE_L2_QUEUE_SIZE 0xFF1FFFFF | ||
417 | #define S_000100_INVALIDATE_ALL_L1_TLBS(x) (((x) & 0x1) << 28) | ||
418 | #define G_000100_INVALIDATE_ALL_L1_TLBS(x) (((x) >> 28) & 0x1) | ||
419 | #define C_000100_INVALIDATE_ALL_L1_TLBS 0xEFFFFFFF | ||
420 | #define S_000100_INVALIDATE_L2_CACHE(x) (((x) & 0x1) << 29) | ||
421 | #define G_000100_INVALIDATE_L2_CACHE(x) (((x) >> 29) & 0x1) | ||
422 | #define C_000100_INVALIDATE_L2_CACHE 0xDFFFFFFF | ||
423 | #define R_000102_MC_PT0_CONTEXT0_CNTL 0x000102 | ||
424 | #define S_000102_ENABLE_PAGE_TABLE(x) (((x) & 0x1) << 0) | ||
425 | #define G_000102_ENABLE_PAGE_TABLE(x) (((x) >> 0) & 0x1) | ||
426 | #define C_000102_ENABLE_PAGE_TABLE 0xFFFFFFFE | ||
427 | #define S_000102_PAGE_TABLE_DEPTH(x) (((x) & 0x3) << 1) | ||
428 | #define G_000102_PAGE_TABLE_DEPTH(x) (((x) >> 1) & 0x3) | ||
429 | #define C_000102_PAGE_TABLE_DEPTH 0xFFFFFFF9 | ||
430 | #define V_000102_PAGE_TABLE_FLAT 0 | ||
431 | /* R600 documentation suggest that this should be a number of pages */ | ||
432 | #define R_000112_MC_PT0_SYSTEM_APERTURE_LOW_ADDR 0x000112 | ||
433 | #define R_000114_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR 0x000114 | ||
434 | #define R_00011C_MC_PT0_CONTEXT0_DEFAULT_READ_ADDR 0x00011C | ||
435 | #define R_00012C_MC_PT0_CONTEXT0_FLAT_BASE_ADDR 0x00012C | ||
436 | #define R_00013C_MC_PT0_CONTEXT0_FLAT_START_ADDR 0x00013C | ||
437 | #define R_00014C_MC_PT0_CONTEXT0_FLAT_END_ADDR 0x00014C | ||
438 | #define R_00016C_MC_PT0_CLIENT0_CNTL 0x00016C | ||
439 | #define S_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(x) (((x) & 0x1) << 0) | ||
440 | #define G_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(x) (((x) >> 0) & 0x1) | ||
441 | #define C_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE 0xFFFFFFFE | ||
442 | #define S_00016C_TRANSLATION_MODE_OVERRIDE(x) (((x) & 0x1) << 1) | ||
443 | #define G_00016C_TRANSLATION_MODE_OVERRIDE(x) (((x) >> 1) & 0x1) | ||
444 | #define C_00016C_TRANSLATION_MODE_OVERRIDE 0xFFFFFFFD | ||
445 | #define S_00016C_SYSTEM_ACCESS_MODE_MASK(x) (((x) & 0x3) << 8) | ||
446 | #define G_00016C_SYSTEM_ACCESS_MODE_MASK(x) (((x) >> 8) & 0x3) | ||
447 | #define C_00016C_SYSTEM_ACCESS_MODE_MASK 0xFFFFFCFF | ||
448 | #define V_00016C_SYSTEM_ACCESS_MODE_PA_ONLY 0 | ||
449 | #define V_00016C_SYSTEM_ACCESS_MODE_USE_SYS_MAP 1 | ||
450 | #define V_00016C_SYSTEM_ACCESS_MODE_IN_SYS 2 | ||
451 | #define V_00016C_SYSTEM_ACCESS_MODE_NOT_IN_SYS 3 | ||
452 | #define S_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS(x) (((x) & 0x1) << 10) | ||
453 | #define G_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS(x) (((x) >> 10) & 0x1) | ||
454 | #define C_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS 0xFFFFFBFF | ||
455 | #define V_00016C_SYSTEM_APERTURE_UNMAPPED_PASSTHROUGH 0 | ||
456 | #define V_00016C_SYSTEM_APERTURE_UNMAPPED_DEFAULT_PAGE 1 | ||
457 | #define S_00016C_EFFECTIVE_L1_CACHE_SIZE(x) (((x) & 0x7) << 11) | ||
458 | #define G_00016C_EFFECTIVE_L1_CACHE_SIZE(x) (((x) >> 11) & 0x7) | ||
459 | #define C_00016C_EFFECTIVE_L1_CACHE_SIZE 0xFFFFC7FF | ||
460 | #define S_00016C_ENABLE_FRAGMENT_PROCESSING(x) (((x) & 0x1) << 14) | ||
461 | #define G_00016C_ENABLE_FRAGMENT_PROCESSING(x) (((x) >> 14) & 0x1) | ||
462 | #define C_00016C_ENABLE_FRAGMENT_PROCESSING 0xFFFFBFFF | ||
463 | #define S_00016C_EFFECTIVE_L1_QUEUE_SIZE(x) (((x) & 0x7) << 15) | ||
464 | #define G_00016C_EFFECTIVE_L1_QUEUE_SIZE(x) (((x) >> 15) & 0x7) | ||
465 | #define C_00016C_EFFECTIVE_L1_QUEUE_SIZE 0xFFFC7FFF | ||
466 | #define S_00016C_INVALIDATE_L1_TLB(x) (((x) & 0x1) << 20) | ||
467 | #define G_00016C_INVALIDATE_L1_TLB(x) (((x) >> 20) & 0x1) | ||
468 | #define C_00016C_INVALIDATE_L1_TLB 0xFFEFFFFF | ||
469 | |||
470 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs690.c b/drivers/gpu/drm/radeon/rs690.c index 7a0098ddf977..025e3225346c 100644 --- a/drivers/gpu/drm/radeon/rs690.c +++ b/drivers/gpu/drm/radeon/rs690.c | |||
@@ -26,105 +26,29 @@ | |||
26 | * Jerome Glisse | 26 | * Jerome Glisse |
27 | */ | 27 | */ |
28 | #include "drmP.h" | 28 | #include "drmP.h" |
29 | #include "radeon_reg.h" | ||
30 | #include "radeon.h" | 29 | #include "radeon.h" |
31 | #include "rs690r.h" | ||
32 | #include "atom.h" | 30 | #include "atom.h" |
33 | #include "atom-bits.h" | 31 | #include "rs690d.h" |
34 | |||
35 | /* rs690,rs740 depends on : */ | ||
36 | void r100_hdp_reset(struct radeon_device *rdev); | ||
37 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
38 | void r420_pipes_init(struct radeon_device *rdev); | ||
39 | void rs400_gart_disable(struct radeon_device *rdev); | ||
40 | int rs400_gart_enable(struct radeon_device *rdev); | ||
41 | void rs400_gart_adjust_size(struct radeon_device *rdev); | ||
42 | void rs600_mc_disable_clients(struct radeon_device *rdev); | ||
43 | |||
44 | /* This files gather functions specifics to : | ||
45 | * rs690,rs740 | ||
46 | * | ||
47 | * Some of these functions might be used by newer ASICs. | ||
48 | */ | ||
49 | void rs690_gpu_init(struct radeon_device *rdev); | ||
50 | int rs690_mc_wait_for_idle(struct radeon_device *rdev); | ||
51 | |||
52 | |||
53 | /* | ||
54 | * MC functions. | ||
55 | */ | ||
56 | int rs690_mc_init(struct radeon_device *rdev) | ||
57 | { | ||
58 | uint32_t tmp; | ||
59 | int r; | ||
60 | |||
61 | if (r100_debugfs_rbbm_init(rdev)) { | ||
62 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
63 | } | ||
64 | |||
65 | rs690_gpu_init(rdev); | ||
66 | rs400_gart_disable(rdev); | ||
67 | |||
68 | /* Setup GPU memory space */ | ||
69 | rdev->mc.gtt_location = rdev->mc.mc_vram_size; | ||
70 | rdev->mc.gtt_location += (rdev->mc.gtt_size - 1); | ||
71 | rdev->mc.gtt_location &= ~(rdev->mc.gtt_size - 1); | ||
72 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
73 | r = radeon_mc_setup(rdev); | ||
74 | if (r) { | ||
75 | return r; | ||
76 | } | ||
77 | |||
78 | /* Program GPU memory space */ | ||
79 | rs600_mc_disable_clients(rdev); | ||
80 | if (rs690_mc_wait_for_idle(rdev)) { | ||
81 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
82 | "programming pipes. Bad things might happen.\n"); | ||
83 | } | ||
84 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
85 | tmp = REG_SET(RS690_MC_FB_TOP, tmp >> 16); | ||
86 | tmp |= REG_SET(RS690_MC_FB_START, rdev->mc.vram_location >> 16); | ||
87 | WREG32_MC(RS690_MCCFG_FB_LOCATION, tmp); | ||
88 | /* FIXME: Does this reg exist on RS480,RS740 ? */ | ||
89 | WREG32(0x310, rdev->mc.vram_location); | ||
90 | WREG32(RS690_HDP_FB_LOCATION, rdev->mc.vram_location >> 16); | ||
91 | return 0; | ||
92 | } | ||
93 | |||
94 | void rs690_mc_fini(struct radeon_device *rdev) | ||
95 | { | ||
96 | } | ||
97 | |||
98 | 32 | ||
99 | /* | 33 | static int rs690_mc_wait_for_idle(struct radeon_device *rdev) |
100 | * Global GPU functions | ||
101 | */ | ||
102 | int rs690_mc_wait_for_idle(struct radeon_device *rdev) | ||
103 | { | 34 | { |
104 | unsigned i; | 35 | unsigned i; |
105 | uint32_t tmp; | 36 | uint32_t tmp; |
106 | 37 | ||
107 | for (i = 0; i < rdev->usec_timeout; i++) { | 38 | for (i = 0; i < rdev->usec_timeout; i++) { |
108 | /* read MC_STATUS */ | 39 | /* read MC_STATUS */ |
109 | tmp = RREG32_MC(RS690_MC_STATUS); | 40 | tmp = RREG32_MC(R_000090_MC_SYSTEM_STATUS); |
110 | if (tmp & RS690_MC_STATUS_IDLE) { | 41 | if (G_000090_MC_SYSTEM_IDLE(tmp)) |
111 | return 0; | 42 | return 0; |
112 | } | 43 | udelay(1); |
113 | DRM_UDELAY(1); | ||
114 | } | 44 | } |
115 | return -1; | 45 | return -1; |
116 | } | 46 | } |
117 | 47 | ||
118 | void rs690_errata(struct radeon_device *rdev) | 48 | static void rs690_gpu_init(struct radeon_device *rdev) |
119 | { | ||
120 | rdev->pll_errata = 0; | ||
121 | } | ||
122 | |||
123 | void rs690_gpu_init(struct radeon_device *rdev) | ||
124 | { | 49 | { |
125 | /* FIXME: HDP same place on rs690 ? */ | 50 | /* FIXME: HDP same place on rs690 ? */ |
126 | r100_hdp_reset(rdev); | 51 | r100_hdp_reset(rdev); |
127 | rv515_vga_render_disable(rdev); | ||
128 | /* FIXME: is this correct ? */ | 52 | /* FIXME: is this correct ? */ |
129 | r420_pipes_init(rdev); | 53 | r420_pipes_init(rdev); |
130 | if (rs690_mc_wait_for_idle(rdev)) { | 54 | if (rs690_mc_wait_for_idle(rdev)) { |
@@ -133,10 +57,6 @@ void rs690_gpu_init(struct radeon_device *rdev) | |||
133 | } | 57 | } |
134 | } | 58 | } |
135 | 59 | ||
136 | |||
137 | /* | ||
138 | * VRAM info. | ||
139 | */ | ||
140 | void rs690_pm_info(struct radeon_device *rdev) | 60 | void rs690_pm_info(struct radeon_device *rdev) |
141 | { | 61 | { |
142 | int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo); | 62 | int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo); |
@@ -250,39 +170,39 @@ void rs690_line_buffer_adjust(struct radeon_device *rdev, | |||
250 | /* | 170 | /* |
251 | * Line Buffer Setup | 171 | * Line Buffer Setup |
252 | * There is a single line buffer shared by both display controllers. | 172 | * There is a single line buffer shared by both display controllers. |
253 | * DC_LB_MEMORY_SPLIT controls how that line buffer is shared between | 173 | * R_006520_DC_LB_MEMORY_SPLIT controls how that line buffer is shared between |
254 | * the display controllers. The paritioning can either be done | 174 | * the display controllers. The paritioning can either be done |
255 | * manually or via one of four preset allocations specified in bits 1:0: | 175 | * manually or via one of four preset allocations specified in bits 1:0: |
256 | * 0 - line buffer is divided in half and shared between crtc | 176 | * 0 - line buffer is divided in half and shared between crtc |
257 | * 1 - D1 gets 3/4 of the line buffer, D2 gets 1/4 | 177 | * 1 - D1 gets 3/4 of the line buffer, D2 gets 1/4 |
258 | * 2 - D1 gets the whole buffer | 178 | * 2 - D1 gets the whole buffer |
259 | * 3 - D1 gets 1/4 of the line buffer, D2 gets 3/4 | 179 | * 3 - D1 gets 1/4 of the line buffer, D2 gets 3/4 |
260 | * Setting bit 2 of DC_LB_MEMORY_SPLIT controls switches to manual | 180 | * Setting bit 2 of R_006520_DC_LB_MEMORY_SPLIT controls switches to manual |
261 | * allocation mode. In manual allocation mode, D1 always starts at 0, | 181 | * allocation mode. In manual allocation mode, D1 always starts at 0, |
262 | * D1 end/2 is specified in bits 14:4; D2 allocation follows D1. | 182 | * D1 end/2 is specified in bits 14:4; D2 allocation follows D1. |
263 | */ | 183 | */ |
264 | tmp = RREG32(DC_LB_MEMORY_SPLIT) & ~DC_LB_MEMORY_SPLIT_MASK; | 184 | tmp = RREG32(R_006520_DC_LB_MEMORY_SPLIT) & C_006520_DC_LB_MEMORY_SPLIT; |
265 | tmp &= ~DC_LB_MEMORY_SPLIT_SHIFT_MODE; | 185 | tmp &= ~C_006520_DC_LB_MEMORY_SPLIT_MODE; |
266 | /* auto */ | 186 | /* auto */ |
267 | if (mode1 && mode2) { | 187 | if (mode1 && mode2) { |
268 | if (mode1->hdisplay > mode2->hdisplay) { | 188 | if (mode1->hdisplay > mode2->hdisplay) { |
269 | if (mode1->hdisplay > 2560) | 189 | if (mode1->hdisplay > 2560) |
270 | tmp |= DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q; | 190 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q; |
271 | else | 191 | else |
272 | tmp |= DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; | 192 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; |
273 | } else if (mode2->hdisplay > mode1->hdisplay) { | 193 | } else if (mode2->hdisplay > mode1->hdisplay) { |
274 | if (mode2->hdisplay > 2560) | 194 | if (mode2->hdisplay > 2560) |
275 | tmp |= DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; | 195 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; |
276 | else | 196 | else |
277 | tmp |= DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; | 197 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; |
278 | } else | 198 | } else |
279 | tmp |= AVIVO_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; | 199 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; |
280 | } else if (mode1) { | 200 | } else if (mode1) { |
281 | tmp |= DC_LB_MEMORY_SPLIT_D1_ONLY; | 201 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_ONLY; |
282 | } else if (mode2) { | 202 | } else if (mode2) { |
283 | tmp |= DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; | 203 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; |
284 | } | 204 | } |
285 | WREG32(DC_LB_MEMORY_SPLIT, tmp); | 205 | WREG32(R_006520_DC_LB_MEMORY_SPLIT, tmp); |
286 | } | 206 | } |
287 | 207 | ||
288 | struct rs690_watermark { | 208 | struct rs690_watermark { |
@@ -487,28 +407,28 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
487 | * option. | 407 | * option. |
488 | */ | 408 | */ |
489 | if (rdev->disp_priority == 2) { | 409 | if (rdev->disp_priority == 2) { |
490 | tmp = RREG32_MC(MC_INIT_MISC_LAT_TIMER); | 410 | tmp = RREG32_MC(R_000104_MC_INIT_MISC_LAT_TIMER); |
491 | tmp &= ~MC_DISP1R_INIT_LAT_MASK; | 411 | tmp &= C_000104_MC_DISP0R_INIT_LAT; |
492 | tmp &= ~MC_DISP0R_INIT_LAT_MASK; | 412 | tmp &= C_000104_MC_DISP1R_INIT_LAT; |
493 | if (mode1) | ||
494 | tmp |= (1 << MC_DISP1R_INIT_LAT_SHIFT); | ||
495 | if (mode0) | 413 | if (mode0) |
496 | tmp |= (1 << MC_DISP0R_INIT_LAT_SHIFT); | 414 | tmp |= S_000104_MC_DISP0R_INIT_LAT(1); |
497 | WREG32_MC(MC_INIT_MISC_LAT_TIMER, tmp); | 415 | if (mode1) |
416 | tmp |= S_000104_MC_DISP1R_INIT_LAT(1); | ||
417 | WREG32_MC(R_000104_MC_INIT_MISC_LAT_TIMER, tmp); | ||
498 | } | 418 | } |
499 | rs690_line_buffer_adjust(rdev, mode0, mode1); | 419 | rs690_line_buffer_adjust(rdev, mode0, mode1); |
500 | 420 | ||
501 | if ((rdev->family == CHIP_RS690) || (rdev->family == CHIP_RS740)) | 421 | if ((rdev->family == CHIP_RS690) || (rdev->family == CHIP_RS740)) |
502 | WREG32(DCP_CONTROL, 0); | 422 | WREG32(R_006C9C_DCP_CONTROL, 0); |
503 | if ((rdev->family == CHIP_RS780) || (rdev->family == CHIP_RS880)) | 423 | if ((rdev->family == CHIP_RS780) || (rdev->family == CHIP_RS880)) |
504 | WREG32(DCP_CONTROL, 2); | 424 | WREG32(R_006C9C_DCP_CONTROL, 2); |
505 | 425 | ||
506 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[0], &wm0); | 426 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[0], &wm0); |
507 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[1], &wm1); | 427 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[1], &wm1); |
508 | 428 | ||
509 | tmp = (wm0.lb_request_fifo_depth - 1); | 429 | tmp = (wm0.lb_request_fifo_depth - 1); |
510 | tmp |= (wm1.lb_request_fifo_depth - 1) << 16; | 430 | tmp |= (wm1.lb_request_fifo_depth - 1) << 16; |
511 | WREG32(LB_MAX_REQ_OUTSTANDING, tmp); | 431 | WREG32(R_006D58_LB_MAX_REQ_OUTSTANDING, tmp); |
512 | 432 | ||
513 | if (mode0 && mode1) { | 433 | if (mode0 && mode1) { |
514 | if (rfixed_trunc(wm0.dbpp) > 64) | 434 | if (rfixed_trunc(wm0.dbpp) > 64) |
@@ -561,10 +481,10 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
561 | priority_mark12.full = 0; | 481 | priority_mark12.full = 0; |
562 | if (wm1.priority_mark_max.full > priority_mark12.full) | 482 | if (wm1.priority_mark_max.full > priority_mark12.full) |
563 | priority_mark12.full = wm1.priority_mark_max.full; | 483 | priority_mark12.full = wm1.priority_mark_max.full; |
564 | WREG32(D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); | 484 | WREG32(R_006548_D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); |
565 | WREG32(D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); | 485 | WREG32(R_00654C_D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); |
566 | WREG32(D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); | 486 | WREG32(R_006D48_D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); |
567 | WREG32(D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); | 487 | WREG32(R_006D4C_D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); |
568 | } else if (mode0) { | 488 | } else if (mode0) { |
569 | if (rfixed_trunc(wm0.dbpp) > 64) | 489 | if (rfixed_trunc(wm0.dbpp) > 64) |
570 | a.full = rfixed_mul(wm0.dbpp, wm0.num_line_pair); | 490 | a.full = rfixed_mul(wm0.dbpp, wm0.num_line_pair); |
@@ -591,10 +511,12 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
591 | priority_mark02.full = 0; | 511 | priority_mark02.full = 0; |
592 | if (wm0.priority_mark_max.full > priority_mark02.full) | 512 | if (wm0.priority_mark_max.full > priority_mark02.full) |
593 | priority_mark02.full = wm0.priority_mark_max.full; | 513 | priority_mark02.full = wm0.priority_mark_max.full; |
594 | WREG32(D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); | 514 | WREG32(R_006548_D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); |
595 | WREG32(D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); | 515 | WREG32(R_00654C_D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); |
596 | WREG32(D2MODE_PRIORITY_A_CNT, MODE_PRIORITY_OFF); | 516 | WREG32(R_006D48_D2MODE_PRIORITY_A_CNT, |
597 | WREG32(D2MODE_PRIORITY_B_CNT, MODE_PRIORITY_OFF); | 517 | S_006D48_D2MODE_PRIORITY_A_OFF(1)); |
518 | WREG32(R_006D4C_D2MODE_PRIORITY_B_CNT, | ||
519 | S_006D4C_D2MODE_PRIORITY_B_OFF(1)); | ||
598 | } else { | 520 | } else { |
599 | if (rfixed_trunc(wm1.dbpp) > 64) | 521 | if (rfixed_trunc(wm1.dbpp) > 64) |
600 | a.full = rfixed_mul(wm1.dbpp, wm1.num_line_pair); | 522 | a.full = rfixed_mul(wm1.dbpp, wm1.num_line_pair); |
@@ -621,30 +543,203 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
621 | priority_mark12.full = 0; | 543 | priority_mark12.full = 0; |
622 | if (wm1.priority_mark_max.full > priority_mark12.full) | 544 | if (wm1.priority_mark_max.full > priority_mark12.full) |
623 | priority_mark12.full = wm1.priority_mark_max.full; | 545 | priority_mark12.full = wm1.priority_mark_max.full; |
624 | WREG32(D1MODE_PRIORITY_A_CNT, MODE_PRIORITY_OFF); | 546 | WREG32(R_006548_D1MODE_PRIORITY_A_CNT, |
625 | WREG32(D1MODE_PRIORITY_B_CNT, MODE_PRIORITY_OFF); | 547 | S_006548_D1MODE_PRIORITY_A_OFF(1)); |
626 | WREG32(D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); | 548 | WREG32(R_00654C_D1MODE_PRIORITY_B_CNT, |
627 | WREG32(D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); | 549 | S_00654C_D1MODE_PRIORITY_B_OFF(1)); |
550 | WREG32(R_006D48_D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); | ||
551 | WREG32(R_006D4C_D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); | ||
628 | } | 552 | } |
629 | } | 553 | } |
630 | 554 | ||
631 | /* | ||
632 | * Indirect registers accessor | ||
633 | */ | ||
634 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg) | 555 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg) |
635 | { | 556 | { |
636 | uint32_t r; | 557 | uint32_t r; |
637 | 558 | ||
638 | WREG32(RS690_MC_INDEX, (reg & RS690_MC_INDEX_MASK)); | 559 | WREG32(R_000078_MC_INDEX, S_000078_MC_IND_ADDR(reg)); |
639 | r = RREG32(RS690_MC_DATA); | 560 | r = RREG32(R_00007C_MC_DATA); |
640 | WREG32(RS690_MC_INDEX, RS690_MC_INDEX_MASK); | 561 | WREG32(R_000078_MC_INDEX, ~C_000078_MC_IND_ADDR); |
641 | return r; | 562 | return r; |
642 | } | 563 | } |
643 | 564 | ||
644 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | 565 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) |
645 | { | 566 | { |
646 | WREG32(RS690_MC_INDEX, | 567 | WREG32(R_000078_MC_INDEX, S_000078_MC_IND_ADDR(reg) | |
647 | RS690_MC_INDEX_WR_EN | ((reg) & RS690_MC_INDEX_MASK)); | 568 | S_000078_MC_IND_WR_EN(1)); |
648 | WREG32(RS690_MC_DATA, v); | 569 | WREG32(R_00007C_MC_DATA, v); |
649 | WREG32(RS690_MC_INDEX, RS690_MC_INDEX_WR_ACK); | 570 | WREG32(R_000078_MC_INDEX, 0x7F); |
571 | } | ||
572 | |||
573 | void rs690_mc_program(struct radeon_device *rdev) | ||
574 | { | ||
575 | struct rv515_mc_save save; | ||
576 | |||
577 | /* Stops all mc clients */ | ||
578 | rv515_mc_stop(rdev, &save); | ||
579 | |||
580 | /* Wait for mc idle */ | ||
581 | if (rs690_mc_wait_for_idle(rdev)) | ||
582 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); | ||
583 | /* Program MC, should be a 32bits limited address space */ | ||
584 | WREG32_MC(R_000100_MCCFG_FB_LOCATION, | ||
585 | S_000100_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
586 | S_000100_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
587 | WREG32(R_000134_HDP_FB_LOCATION, | ||
588 | S_000134_HDP_FB_START(rdev->mc.vram_start >> 16)); | ||
589 | |||
590 | rv515_mc_resume(rdev, &save); | ||
591 | } | ||
592 | |||
593 | static int rs690_startup(struct radeon_device *rdev) | ||
594 | { | ||
595 | int r; | ||
596 | |||
597 | rs690_mc_program(rdev); | ||
598 | /* Resume clock */ | ||
599 | rv515_clock_startup(rdev); | ||
600 | /* Initialize GPU configuration (# pipes, ...) */ | ||
601 | rs690_gpu_init(rdev); | ||
602 | /* Initialize GART (initialize after TTM so we can allocate | ||
603 | * memory through TTM but finalize after TTM) */ | ||
604 | r = rs400_gart_enable(rdev); | ||
605 | if (r) | ||
606 | return r; | ||
607 | /* Enable IRQ */ | ||
608 | rdev->irq.sw_int = true; | ||
609 | rs600_irq_set(rdev); | ||
610 | /* 1M ring buffer */ | ||
611 | r = r100_cp_init(rdev, 1024 * 1024); | ||
612 | if (r) { | ||
613 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
614 | return r; | ||
615 | } | ||
616 | r = r100_wb_init(rdev); | ||
617 | if (r) | ||
618 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
619 | r = r100_ib_init(rdev); | ||
620 | if (r) { | ||
621 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
622 | return r; | ||
623 | } | ||
624 | return 0; | ||
625 | } | ||
626 | |||
627 | int rs690_resume(struct radeon_device *rdev) | ||
628 | { | ||
629 | /* Make sur GART are not working */ | ||
630 | rs400_gart_disable(rdev); | ||
631 | /* Resume clock before doing reset */ | ||
632 | rv515_clock_startup(rdev); | ||
633 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
634 | if (radeon_gpu_reset(rdev)) { | ||
635 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
636 | RREG32(R_000E40_RBBM_STATUS), | ||
637 | RREG32(R_0007C0_CP_STAT)); | ||
638 | } | ||
639 | /* post */ | ||
640 | atom_asic_init(rdev->mode_info.atom_context); | ||
641 | /* Resume clock after posting */ | ||
642 | rv515_clock_startup(rdev); | ||
643 | return rs690_startup(rdev); | ||
644 | } | ||
645 | |||
646 | int rs690_suspend(struct radeon_device *rdev) | ||
647 | { | ||
648 | r100_cp_disable(rdev); | ||
649 | r100_wb_disable(rdev); | ||
650 | rs600_irq_disable(rdev); | ||
651 | rs400_gart_disable(rdev); | ||
652 | return 0; | ||
653 | } | ||
654 | |||
655 | void rs690_fini(struct radeon_device *rdev) | ||
656 | { | ||
657 | rs690_suspend(rdev); | ||
658 | r100_cp_fini(rdev); | ||
659 | r100_wb_fini(rdev); | ||
660 | r100_ib_fini(rdev); | ||
661 | radeon_gem_fini(rdev); | ||
662 | rs400_gart_fini(rdev); | ||
663 | radeon_irq_kms_fini(rdev); | ||
664 | radeon_fence_driver_fini(rdev); | ||
665 | radeon_object_fini(rdev); | ||
666 | radeon_atombios_fini(rdev); | ||
667 | kfree(rdev->bios); | ||
668 | rdev->bios = NULL; | ||
669 | } | ||
670 | |||
671 | int rs690_init(struct radeon_device *rdev) | ||
672 | { | ||
673 | int r; | ||
674 | |||
675 | /* Disable VGA */ | ||
676 | rv515_vga_render_disable(rdev); | ||
677 | /* Initialize scratch registers */ | ||
678 | radeon_scratch_init(rdev); | ||
679 | /* Initialize surface registers */ | ||
680 | radeon_surface_init(rdev); | ||
681 | /* TODO: disable VGA need to use VGA request */ | ||
682 | /* BIOS*/ | ||
683 | if (!radeon_get_bios(rdev)) { | ||
684 | if (ASIC_IS_AVIVO(rdev)) | ||
685 | return -EINVAL; | ||
686 | } | ||
687 | if (rdev->is_atom_bios) { | ||
688 | r = radeon_atombios_init(rdev); | ||
689 | if (r) | ||
690 | return r; | ||
691 | } else { | ||
692 | dev_err(rdev->dev, "Expecting atombios for RV515 GPU\n"); | ||
693 | return -EINVAL; | ||
694 | } | ||
695 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
696 | if (radeon_gpu_reset(rdev)) { | ||
697 | dev_warn(rdev->dev, | ||
698 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
699 | RREG32(R_000E40_RBBM_STATUS), | ||
700 | RREG32(R_0007C0_CP_STAT)); | ||
701 | } | ||
702 | /* check if cards are posted or not */ | ||
703 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
704 | DRM_INFO("GPU not posted. posting now...\n"); | ||
705 | atom_asic_init(rdev->mode_info.atom_context); | ||
706 | } | ||
707 | /* Initialize clocks */ | ||
708 | radeon_get_clock_info(rdev->ddev); | ||
709 | /* Get vram informations */ | ||
710 | rs690_vram_info(rdev); | ||
711 | /* Initialize memory controller (also test AGP) */ | ||
712 | r = r420_mc_init(rdev); | ||
713 | if (r) | ||
714 | return r; | ||
715 | rv515_debugfs(rdev); | ||
716 | /* Fence driver */ | ||
717 | r = radeon_fence_driver_init(rdev); | ||
718 | if (r) | ||
719 | return r; | ||
720 | r = radeon_irq_kms_init(rdev); | ||
721 | if (r) | ||
722 | return r; | ||
723 | /* Memory manager */ | ||
724 | r = radeon_object_init(rdev); | ||
725 | if (r) | ||
726 | return r; | ||
727 | r = rs400_gart_init(rdev); | ||
728 | if (r) | ||
729 | return r; | ||
730 | rs600_set_safe_registers(rdev); | ||
731 | rdev->accel_working = true; | ||
732 | r = rs690_startup(rdev); | ||
733 | if (r) { | ||
734 | /* Somethings want wront with the accel init stop accel */ | ||
735 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
736 | rs690_suspend(rdev); | ||
737 | r100_cp_fini(rdev); | ||
738 | r100_wb_fini(rdev); | ||
739 | r100_ib_fini(rdev); | ||
740 | rs400_gart_fini(rdev); | ||
741 | radeon_irq_kms_fini(rdev); | ||
742 | rdev->accel_working = false; | ||
743 | } | ||
744 | return 0; | ||
650 | } | 745 | } |
diff --git a/drivers/gpu/drm/radeon/rs690d.h b/drivers/gpu/drm/radeon/rs690d.h new file mode 100644 index 000000000000..62d31e7a897f --- /dev/null +++ b/drivers/gpu/drm/radeon/rs690d.h | |||
@@ -0,0 +1,307 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef __RS690D_H__ | ||
29 | #define __RS690D_H__ | ||
30 | |||
31 | /* Registers */ | ||
32 | #define R_000078_MC_INDEX 0x000078 | ||
33 | #define S_000078_MC_IND_ADDR(x) (((x) & 0x1FF) << 0) | ||
34 | #define G_000078_MC_IND_ADDR(x) (((x) >> 0) & 0x1FF) | ||
35 | #define C_000078_MC_IND_ADDR 0xFFFFFE00 | ||
36 | #define S_000078_MC_IND_WR_EN(x) (((x) & 0x1) << 9) | ||
37 | #define G_000078_MC_IND_WR_EN(x) (((x) >> 9) & 0x1) | ||
38 | #define C_000078_MC_IND_WR_EN 0xFFFFFDFF | ||
39 | #define R_00007C_MC_DATA 0x00007C | ||
40 | #define S_00007C_MC_DATA(x) (((x) & 0xFFFFFFFF) << 0) | ||
41 | #define G_00007C_MC_DATA(x) (((x) >> 0) & 0xFFFFFFFF) | ||
42 | #define C_00007C_MC_DATA 0x00000000 | ||
43 | #define R_0000F8_CONFIG_MEMSIZE 0x0000F8 | ||
44 | #define S_0000F8_CONFIG_MEMSIZE(x) (((x) & 0xFFFFFFFF) << 0) | ||
45 | #define G_0000F8_CONFIG_MEMSIZE(x) (((x) >> 0) & 0xFFFFFFFF) | ||
46 | #define C_0000F8_CONFIG_MEMSIZE 0x00000000 | ||
47 | #define R_000134_HDP_FB_LOCATION 0x000134 | ||
48 | #define S_000134_HDP_FB_START(x) (((x) & 0xFFFF) << 0) | ||
49 | #define G_000134_HDP_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
50 | #define C_000134_HDP_FB_START 0xFFFF0000 | ||
51 | #define R_0007C0_CP_STAT 0x0007C0 | ||
52 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
53 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
54 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
55 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
56 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
57 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
58 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
59 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
60 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
61 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
62 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
63 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
64 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
65 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
66 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
67 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
68 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
69 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
70 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
71 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
72 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
73 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
74 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
75 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
76 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
77 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
78 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
79 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
80 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
81 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
82 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
83 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
84 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
85 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
86 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
87 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
88 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
89 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
90 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
91 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
92 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
93 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
94 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
95 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
96 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
97 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
98 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
99 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
100 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
101 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
102 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
103 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
104 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
105 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
106 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
107 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
108 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
109 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
110 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
111 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
112 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
113 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
114 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
115 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
116 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
117 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
118 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
119 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
120 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
121 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
122 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
123 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
124 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
125 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
126 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
127 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
128 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
129 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
130 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
131 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
132 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
133 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
134 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
135 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
136 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
137 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
138 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
139 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
140 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
141 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
142 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
143 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
144 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
145 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
146 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
147 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
148 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
149 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
150 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
151 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
152 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
153 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
154 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
155 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
156 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
157 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
158 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
159 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
160 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
161 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
162 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
163 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
164 | #define R_006520_DC_LB_MEMORY_SPLIT 0x006520 | ||
165 | #define S_006520_DC_LB_MEMORY_SPLIT(x) (((x) & 0x3) << 0) | ||
166 | #define G_006520_DC_LB_MEMORY_SPLIT(x) (((x) >> 0) & 0x3) | ||
167 | #define C_006520_DC_LB_MEMORY_SPLIT 0xFFFFFFFC | ||
168 | #define S_006520_DC_LB_MEMORY_SPLIT_MODE(x) (((x) & 0x1) << 2) | ||
169 | #define G_006520_DC_LB_MEMORY_SPLIT_MODE(x) (((x) >> 2) & 0x1) | ||
170 | #define C_006520_DC_LB_MEMORY_SPLIT_MODE 0xFFFFFFFB | ||
171 | #define V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF 0 | ||
172 | #define V_006520_DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q 1 | ||
173 | #define V_006520_DC_LB_MEMORY_SPLIT_D1_ONLY 2 | ||
174 | #define V_006520_DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q 3 | ||
175 | #define S_006520_DC_LB_DISP1_END_ADR(x) (((x) & 0x7FF) << 4) | ||
176 | #define G_006520_DC_LB_DISP1_END_ADR(x) (((x) >> 4) & 0x7FF) | ||
177 | #define C_006520_DC_LB_DISP1_END_ADR 0xFFFF800F | ||
178 | #define R_006548_D1MODE_PRIORITY_A_CNT 0x006548 | ||
179 | #define S_006548_D1MODE_PRIORITY_MARK_A(x) (((x) & 0x7FFF) << 0) | ||
180 | #define G_006548_D1MODE_PRIORITY_MARK_A(x) (((x) >> 0) & 0x7FFF) | ||
181 | #define C_006548_D1MODE_PRIORITY_MARK_A 0xFFFF8000 | ||
182 | #define S_006548_D1MODE_PRIORITY_A_OFF(x) (((x) & 0x1) << 16) | ||
183 | #define G_006548_D1MODE_PRIORITY_A_OFF(x) (((x) >> 16) & 0x1) | ||
184 | #define C_006548_D1MODE_PRIORITY_A_OFF 0xFFFEFFFF | ||
185 | #define S_006548_D1MODE_PRIORITY_A_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
186 | #define G_006548_D1MODE_PRIORITY_A_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
187 | #define C_006548_D1MODE_PRIORITY_A_FORCE_MASK 0xFEFFFFFF | ||
188 | #define R_00654C_D1MODE_PRIORITY_B_CNT 0x00654C | ||
189 | #define S_00654C_D1MODE_PRIORITY_MARK_B(x) (((x) & 0x7FFF) << 0) | ||
190 | #define G_00654C_D1MODE_PRIORITY_MARK_B(x) (((x) >> 0) & 0x7FFF) | ||
191 | #define C_00654C_D1MODE_PRIORITY_MARK_B 0xFFFF8000 | ||
192 | #define S_00654C_D1MODE_PRIORITY_B_OFF(x) (((x) & 0x1) << 16) | ||
193 | #define G_00654C_D1MODE_PRIORITY_B_OFF(x) (((x) >> 16) & 0x1) | ||
194 | #define C_00654C_D1MODE_PRIORITY_B_OFF 0xFFFEFFFF | ||
195 | #define S_00654C_D1MODE_PRIORITY_B_ALWAYS_ON(x) (((x) & 0x1) << 20) | ||
196 | #define G_00654C_D1MODE_PRIORITY_B_ALWAYS_ON(x) (((x) >> 20) & 0x1) | ||
197 | #define C_00654C_D1MODE_PRIORITY_B_ALWAYS_ON 0xFFEFFFFF | ||
198 | #define S_00654C_D1MODE_PRIORITY_B_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
199 | #define G_00654C_D1MODE_PRIORITY_B_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
200 | #define C_00654C_D1MODE_PRIORITY_B_FORCE_MASK 0xFEFFFFFF | ||
201 | #define R_006C9C_DCP_CONTROL 0x006C9C | ||
202 | #define R_006D48_D2MODE_PRIORITY_A_CNT 0x006D48 | ||
203 | #define S_006D48_D2MODE_PRIORITY_MARK_A(x) (((x) & 0x7FFF) << 0) | ||
204 | #define G_006D48_D2MODE_PRIORITY_MARK_A(x) (((x) >> 0) & 0x7FFF) | ||
205 | #define C_006D48_D2MODE_PRIORITY_MARK_A 0xFFFF8000 | ||
206 | #define S_006D48_D2MODE_PRIORITY_A_OFF(x) (((x) & 0x1) << 16) | ||
207 | #define G_006D48_D2MODE_PRIORITY_A_OFF(x) (((x) >> 16) & 0x1) | ||
208 | #define C_006D48_D2MODE_PRIORITY_A_OFF 0xFFFEFFFF | ||
209 | #define S_006D48_D2MODE_PRIORITY_A_ALWAYS_ON(x) (((x) & 0x1) << 20) | ||
210 | #define G_006D48_D2MODE_PRIORITY_A_ALWAYS_ON(x) (((x) >> 20) & 0x1) | ||
211 | #define C_006D48_D2MODE_PRIORITY_A_ALWAYS_ON 0xFFEFFFFF | ||
212 | #define S_006D48_D2MODE_PRIORITY_A_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
213 | #define G_006D48_D2MODE_PRIORITY_A_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
214 | #define C_006D48_D2MODE_PRIORITY_A_FORCE_MASK 0xFEFFFFFF | ||
215 | #define R_006D4C_D2MODE_PRIORITY_B_CNT 0x006D4C | ||
216 | #define S_006D4C_D2MODE_PRIORITY_MARK_B(x) (((x) & 0x7FFF) << 0) | ||
217 | #define G_006D4C_D2MODE_PRIORITY_MARK_B(x) (((x) >> 0) & 0x7FFF) | ||
218 | #define C_006D4C_D2MODE_PRIORITY_MARK_B 0xFFFF8000 | ||
219 | #define S_006D4C_D2MODE_PRIORITY_B_OFF(x) (((x) & 0x1) << 16) | ||
220 | #define G_006D4C_D2MODE_PRIORITY_B_OFF(x) (((x) >> 16) & 0x1) | ||
221 | #define C_006D4C_D2MODE_PRIORITY_B_OFF 0xFFFEFFFF | ||
222 | #define S_006D4C_D2MODE_PRIORITY_B_ALWAYS_ON(x) (((x) & 0x1) << 20) | ||
223 | #define G_006D4C_D2MODE_PRIORITY_B_ALWAYS_ON(x) (((x) >> 20) & 0x1) | ||
224 | #define C_006D4C_D2MODE_PRIORITY_B_ALWAYS_ON 0xFFEFFFFF | ||
225 | #define S_006D4C_D2MODE_PRIORITY_B_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
226 | #define G_006D4C_D2MODE_PRIORITY_B_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
227 | #define C_006D4C_D2MODE_PRIORITY_B_FORCE_MASK 0xFEFFFFFF | ||
228 | #define R_006D58_LB_MAX_REQ_OUTSTANDING 0x006D58 | ||
229 | #define S_006D58_LB_D1_MAX_REQ_OUTSTANDING(x) (((x) & 0xF) << 0) | ||
230 | #define G_006D58_LB_D1_MAX_REQ_OUTSTANDING(x) (((x) >> 0) & 0xF) | ||
231 | #define C_006D58_LB_D1_MAX_REQ_OUTSTANDING 0xFFFFFFF0 | ||
232 | #define S_006D58_LB_D2_MAX_REQ_OUTSTANDING(x) (((x) & 0xF) << 16) | ||
233 | #define G_006D58_LB_D2_MAX_REQ_OUTSTANDING(x) (((x) >> 16) & 0xF) | ||
234 | #define C_006D58_LB_D2_MAX_REQ_OUTSTANDING 0xFFF0FFFF | ||
235 | |||
236 | |||
237 | #define R_000090_MC_SYSTEM_STATUS 0x000090 | ||
238 | #define S_000090_MC_SYSTEM_IDLE(x) (((x) & 0x1) << 0) | ||
239 | #define G_000090_MC_SYSTEM_IDLE(x) (((x) >> 0) & 0x1) | ||
240 | #define C_000090_MC_SYSTEM_IDLE 0xFFFFFFFE | ||
241 | #define S_000090_MC_SEQUENCER_IDLE(x) (((x) & 0x1) << 1) | ||
242 | #define G_000090_MC_SEQUENCER_IDLE(x) (((x) >> 1) & 0x1) | ||
243 | #define C_000090_MC_SEQUENCER_IDLE 0xFFFFFFFD | ||
244 | #define S_000090_MC_ARBITER_IDLE(x) (((x) & 0x1) << 2) | ||
245 | #define G_000090_MC_ARBITER_IDLE(x) (((x) >> 2) & 0x1) | ||
246 | #define C_000090_MC_ARBITER_IDLE 0xFFFFFFFB | ||
247 | #define S_000090_MC_SELECT_PM(x) (((x) & 0x1) << 3) | ||
248 | #define G_000090_MC_SELECT_PM(x) (((x) >> 3) & 0x1) | ||
249 | #define C_000090_MC_SELECT_PM 0xFFFFFFF7 | ||
250 | #define S_000090_RESERVED4(x) (((x) & 0xF) << 4) | ||
251 | #define G_000090_RESERVED4(x) (((x) >> 4) & 0xF) | ||
252 | #define C_000090_RESERVED4 0xFFFFFF0F | ||
253 | #define S_000090_RESERVED8(x) (((x) & 0xF) << 8) | ||
254 | #define G_000090_RESERVED8(x) (((x) >> 8) & 0xF) | ||
255 | #define C_000090_RESERVED8 0xFFFFF0FF | ||
256 | #define S_000090_RESERVED12(x) (((x) & 0xF) << 12) | ||
257 | #define G_000090_RESERVED12(x) (((x) >> 12) & 0xF) | ||
258 | #define C_000090_RESERVED12 0xFFFF0FFF | ||
259 | #define S_000090_MCA_INIT_EXECUTED(x) (((x) & 0x1) << 16) | ||
260 | #define G_000090_MCA_INIT_EXECUTED(x) (((x) >> 16) & 0x1) | ||
261 | #define C_000090_MCA_INIT_EXECUTED 0xFFFEFFFF | ||
262 | #define S_000090_MCA_IDLE(x) (((x) & 0x1) << 17) | ||
263 | #define G_000090_MCA_IDLE(x) (((x) >> 17) & 0x1) | ||
264 | #define C_000090_MCA_IDLE 0xFFFDFFFF | ||
265 | #define S_000090_MCA_SEQ_IDLE(x) (((x) & 0x1) << 18) | ||
266 | #define G_000090_MCA_SEQ_IDLE(x) (((x) >> 18) & 0x1) | ||
267 | #define C_000090_MCA_SEQ_IDLE 0xFFFBFFFF | ||
268 | #define S_000090_MCA_ARB_IDLE(x) (((x) & 0x1) << 19) | ||
269 | #define G_000090_MCA_ARB_IDLE(x) (((x) >> 19) & 0x1) | ||
270 | #define C_000090_MCA_ARB_IDLE 0xFFF7FFFF | ||
271 | #define S_000090_RESERVED20(x) (((x) & 0xFFF) << 20) | ||
272 | #define G_000090_RESERVED20(x) (((x) >> 20) & 0xFFF) | ||
273 | #define C_000090_RESERVED20 0x000FFFFF | ||
274 | #define R_000100_MCCFG_FB_LOCATION 0x000100 | ||
275 | #define S_000100_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
276 | #define G_000100_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
277 | #define C_000100_MC_FB_START 0xFFFF0000 | ||
278 | #define S_000100_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
279 | #define G_000100_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
280 | #define C_000100_MC_FB_TOP 0x0000FFFF | ||
281 | #define R_000104_MC_INIT_MISC_LAT_TIMER 0x000104 | ||
282 | #define S_000104_MC_CPR_INIT_LAT(x) (((x) & 0xF) << 0) | ||
283 | #define G_000104_MC_CPR_INIT_LAT(x) (((x) >> 0) & 0xF) | ||
284 | #define C_000104_MC_CPR_INIT_LAT 0xFFFFFFF0 | ||
285 | #define S_000104_MC_VF_INIT_LAT(x) (((x) & 0xF) << 4) | ||
286 | #define G_000104_MC_VF_INIT_LAT(x) (((x) >> 4) & 0xF) | ||
287 | #define C_000104_MC_VF_INIT_LAT 0xFFFFFF0F | ||
288 | #define S_000104_MC_DISP0R_INIT_LAT(x) (((x) & 0xF) << 8) | ||
289 | #define G_000104_MC_DISP0R_INIT_LAT(x) (((x) >> 8) & 0xF) | ||
290 | #define C_000104_MC_DISP0R_INIT_LAT 0xFFFFF0FF | ||
291 | #define S_000104_MC_DISP1R_INIT_LAT(x) (((x) & 0xF) << 12) | ||
292 | #define G_000104_MC_DISP1R_INIT_LAT(x) (((x) >> 12) & 0xF) | ||
293 | #define C_000104_MC_DISP1R_INIT_LAT 0xFFFF0FFF | ||
294 | #define S_000104_MC_FIXED_INIT_LAT(x) (((x) & 0xF) << 16) | ||
295 | #define G_000104_MC_FIXED_INIT_LAT(x) (((x) >> 16) & 0xF) | ||
296 | #define C_000104_MC_FIXED_INIT_LAT 0xFFF0FFFF | ||
297 | #define S_000104_MC_E2R_INIT_LAT(x) (((x) & 0xF) << 20) | ||
298 | #define G_000104_MC_E2R_INIT_LAT(x) (((x) >> 20) & 0xF) | ||
299 | #define C_000104_MC_E2R_INIT_LAT 0xFF0FFFFF | ||
300 | #define S_000104_SAME_PAGE_PRIO(x) (((x) & 0xF) << 24) | ||
301 | #define G_000104_SAME_PAGE_PRIO(x) (((x) >> 24) & 0xF) | ||
302 | #define C_000104_SAME_PAGE_PRIO 0xF0FFFFFF | ||
303 | #define S_000104_MC_GLOBW_INIT_LAT(x) (((x) & 0xF) << 28) | ||
304 | #define G_000104_MC_GLOBW_INIT_LAT(x) (((x) >> 28) & 0xF) | ||
305 | #define C_000104_MC_GLOBW_INIT_LAT 0x0FFFFFFF | ||
306 | |||
307 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs690r.h b/drivers/gpu/drm/radeon/rs690r.h deleted file mode 100644 index c0d9faa2175b..000000000000 --- a/drivers/gpu/drm/radeon/rs690r.h +++ /dev/null | |||
@@ -1,99 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef RS690R_H | ||
29 | #define RS690R_H | ||
30 | |||
31 | /* RS690/RS740 registers */ | ||
32 | #define MC_INDEX 0x0078 | ||
33 | # define MC_INDEX_MASK 0x1FF | ||
34 | # define MC_INDEX_WR_EN (1 << 9) | ||
35 | # define MC_INDEX_WR_ACK 0x7F | ||
36 | #define MC_DATA 0x007C | ||
37 | #define HDP_FB_LOCATION 0x0134 | ||
38 | #define DC_LB_MEMORY_SPLIT 0x6520 | ||
39 | #define DC_LB_MEMORY_SPLIT_MASK 0x00000003 | ||
40 | #define DC_LB_MEMORY_SPLIT_SHIFT 0 | ||
41 | #define DC_LB_MEMORY_SPLIT_D1HALF_D2HALF 0 | ||
42 | #define DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q 1 | ||
43 | #define DC_LB_MEMORY_SPLIT_D1_ONLY 2 | ||
44 | #define DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q 3 | ||
45 | #define DC_LB_MEMORY_SPLIT_SHIFT_MODE (1 << 2) | ||
46 | #define DC_LB_DISP1_END_ADR_SHIFT 4 | ||
47 | #define DC_LB_DISP1_END_ADR_MASK 0x00007FF0 | ||
48 | #define D1MODE_PRIORITY_A_CNT 0x6548 | ||
49 | #define MODE_PRIORITY_MARK_MASK 0x00007FFF | ||
50 | #define MODE_PRIORITY_OFF (1 << 16) | ||
51 | #define MODE_PRIORITY_ALWAYS_ON (1 << 20) | ||
52 | #define MODE_PRIORITY_FORCE_MASK (1 << 24) | ||
53 | #define D1MODE_PRIORITY_B_CNT 0x654C | ||
54 | #define LB_MAX_REQ_OUTSTANDING 0x6D58 | ||
55 | #define LB_D1_MAX_REQ_OUTSTANDING_MASK 0x0000000F | ||
56 | #define LB_D1_MAX_REQ_OUTSTANDING_SHIFT 0 | ||
57 | #define LB_D2_MAX_REQ_OUTSTANDING_MASK 0x000F0000 | ||
58 | #define LB_D2_MAX_REQ_OUTSTANDING_SHIFT 16 | ||
59 | #define DCP_CONTROL 0x6C9C | ||
60 | #define D2MODE_PRIORITY_A_CNT 0x6D48 | ||
61 | #define D2MODE_PRIORITY_B_CNT 0x6D4C | ||
62 | |||
63 | /* MC indirect registers */ | ||
64 | #define MC_STATUS_IDLE (1 << 0) | ||
65 | #define MC_MISC_CNTL 0x18 | ||
66 | #define DISABLE_GTW (1 << 1) | ||
67 | #define GART_INDEX_REG_EN (1 << 12) | ||
68 | #define BLOCK_GFX_D3_EN (1 << 14) | ||
69 | #define GART_FEATURE_ID 0x2B | ||
70 | #define HANG_EN (1 << 11) | ||
71 | #define TLB_ENABLE (1 << 18) | ||
72 | #define P2P_ENABLE (1 << 19) | ||
73 | #define GTW_LAC_EN (1 << 25) | ||
74 | #define LEVEL2_GART (0 << 30) | ||
75 | #define LEVEL1_GART (1 << 30) | ||
76 | #define PDC_EN (1 << 31) | ||
77 | #define GART_BASE 0x2C | ||
78 | #define GART_CACHE_CNTRL 0x2E | ||
79 | # define GART_CACHE_INVALIDATE (1 << 0) | ||
80 | #define MC_STATUS 0x90 | ||
81 | #define MCCFG_FB_LOCATION 0x100 | ||
82 | #define MC_FB_START_MASK 0x0000FFFF | ||
83 | #define MC_FB_START_SHIFT 0 | ||
84 | #define MC_FB_TOP_MASK 0xFFFF0000 | ||
85 | #define MC_FB_TOP_SHIFT 16 | ||
86 | #define MCCFG_AGP_LOCATION 0x101 | ||
87 | #define MC_AGP_START_MASK 0x0000FFFF | ||
88 | #define MC_AGP_START_SHIFT 0 | ||
89 | #define MC_AGP_TOP_MASK 0xFFFF0000 | ||
90 | #define MC_AGP_TOP_SHIFT 16 | ||
91 | #define MCCFG_AGP_BASE 0x102 | ||
92 | #define MCCFG_AGP_BASE_2 0x103 | ||
93 | #define MC_INIT_MISC_LAT_TIMER 0x104 | ||
94 | #define MC_DISP0R_INIT_LAT_SHIFT 8 | ||
95 | #define MC_DISP0R_INIT_LAT_MASK 0x00000F00 | ||
96 | #define MC_DISP1R_INIT_LAT_SHIFT 12 | ||
97 | #define MC_DISP1R_INIT_LAT_MASK 0x0000F000 | ||
98 | |||
99 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv200d.h b/drivers/gpu/drm/radeon/rv200d.h new file mode 100644 index 000000000000..c5b398330c26 --- /dev/null +++ b/drivers/gpu/drm/radeon/rv200d.h | |||
@@ -0,0 +1,36 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef __RV200D_H__ | ||
29 | #define __RV200D_H__ | ||
30 | |||
31 | #define R_00015C_AGP_BASE_2 0x00015C | ||
32 | #define S_00015C_AGP_BASE_ADDR_2(x) (((x) & 0xF) << 0) | ||
33 | #define G_00015C_AGP_BASE_ADDR_2(x) (((x) >> 0) & 0xF) | ||
34 | #define C_00015C_AGP_BASE_ADDR_2 0xFFFFFFF0 | ||
35 | |||
36 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv250d.h b/drivers/gpu/drm/radeon/rv250d.h new file mode 100644 index 000000000000..e5a70b06fe1f --- /dev/null +++ b/drivers/gpu/drm/radeon/rv250d.h | |||
@@ -0,0 +1,123 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef __RV250D_H__ | ||
29 | #define __RV250D_H__ | ||
30 | |||
31 | #define R_00000D_SCLK_CNTL_M6 0x00000D | ||
32 | #define S_00000D_SCLK_SRC_SEL(x) (((x) & 0x7) << 0) | ||
33 | #define G_00000D_SCLK_SRC_SEL(x) (((x) >> 0) & 0x7) | ||
34 | #define C_00000D_SCLK_SRC_SEL 0xFFFFFFF8 | ||
35 | #define S_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 3) | ||
36 | #define G_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) >> 3) & 0x1) | ||
37 | #define C_00000D_CP_MAX_DYN_STOP_LAT 0xFFFFFFF7 | ||
38 | #define S_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 4) | ||
39 | #define G_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) >> 4) & 0x1) | ||
40 | #define C_00000D_HDP_MAX_DYN_STOP_LAT 0xFFFFFFEF | ||
41 | #define S_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 5) | ||
42 | #define G_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) >> 5) & 0x1) | ||
43 | #define C_00000D_TV_MAX_DYN_STOP_LAT 0xFFFFFFDF | ||
44 | #define S_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 6) | ||
45 | #define G_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) >> 6) & 0x1) | ||
46 | #define C_00000D_E2_MAX_DYN_STOP_LAT 0xFFFFFFBF | ||
47 | #define S_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 7) | ||
48 | #define G_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) >> 7) & 0x1) | ||
49 | #define C_00000D_SE_MAX_DYN_STOP_LAT 0xFFFFFF7F | ||
50 | #define S_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 8) | ||
51 | #define G_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) >> 8) & 0x1) | ||
52 | #define C_00000D_IDCT_MAX_DYN_STOP_LAT 0xFFFFFEFF | ||
53 | #define S_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 9) | ||
54 | #define G_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) >> 9) & 0x1) | ||
55 | #define C_00000D_VIP_MAX_DYN_STOP_LAT 0xFFFFFDFF | ||
56 | #define S_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 10) | ||
57 | #define G_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) >> 10) & 0x1) | ||
58 | #define C_00000D_RE_MAX_DYN_STOP_LAT 0xFFFFFBFF | ||
59 | #define S_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 11) | ||
60 | #define G_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) >> 11) & 0x1) | ||
61 | #define C_00000D_PB_MAX_DYN_STOP_LAT 0xFFFFF7FF | ||
62 | #define S_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 12) | ||
63 | #define G_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) >> 12) & 0x1) | ||
64 | #define C_00000D_TAM_MAX_DYN_STOP_LAT 0xFFFFEFFF | ||
65 | #define S_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 13) | ||
66 | #define G_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) >> 13) & 0x1) | ||
67 | #define C_00000D_TDM_MAX_DYN_STOP_LAT 0xFFFFDFFF | ||
68 | #define S_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 14) | ||
69 | #define G_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) >> 14) & 0x1) | ||
70 | #define C_00000D_RB_MAX_DYN_STOP_LAT 0xFFFFBFFF | ||
71 | #define S_00000D_FORCE_DISP2(x) (((x) & 0x1) << 15) | ||
72 | #define G_00000D_FORCE_DISP2(x) (((x) >> 15) & 0x1) | ||
73 | #define C_00000D_FORCE_DISP2 0xFFFF7FFF | ||
74 | #define S_00000D_FORCE_CP(x) (((x) & 0x1) << 16) | ||
75 | #define G_00000D_FORCE_CP(x) (((x) >> 16) & 0x1) | ||
76 | #define C_00000D_FORCE_CP 0xFFFEFFFF | ||
77 | #define S_00000D_FORCE_HDP(x) (((x) & 0x1) << 17) | ||
78 | #define G_00000D_FORCE_HDP(x) (((x) >> 17) & 0x1) | ||
79 | #define C_00000D_FORCE_HDP 0xFFFDFFFF | ||
80 | #define S_00000D_FORCE_DISP1(x) (((x) & 0x1) << 18) | ||
81 | #define G_00000D_FORCE_DISP1(x) (((x) >> 18) & 0x1) | ||
82 | #define C_00000D_FORCE_DISP1 0xFFFBFFFF | ||
83 | #define S_00000D_FORCE_TOP(x) (((x) & 0x1) << 19) | ||
84 | #define G_00000D_FORCE_TOP(x) (((x) >> 19) & 0x1) | ||
85 | #define C_00000D_FORCE_TOP 0xFFF7FFFF | ||
86 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | ||
87 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | ||
88 | #define C_00000D_FORCE_E2 0xFFEFFFFF | ||
89 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | ||
90 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | ||
91 | #define C_00000D_FORCE_SE 0xFFDFFFFF | ||
92 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | ||
93 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | ||
94 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | ||
95 | #define S_00000D_FORCE_VIP(x) (((x) & 0x1) << 23) | ||
96 | #define G_00000D_FORCE_VIP(x) (((x) >> 23) & 0x1) | ||
97 | #define C_00000D_FORCE_VIP 0xFF7FFFFF | ||
98 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | ||
99 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | ||
100 | #define C_00000D_FORCE_RE 0xFEFFFFFF | ||
101 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | ||
102 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | ||
103 | #define C_00000D_FORCE_PB 0xFDFFFFFF | ||
104 | #define S_00000D_FORCE_TAM(x) (((x) & 0x1) << 26) | ||
105 | #define G_00000D_FORCE_TAM(x) (((x) >> 26) & 0x1) | ||
106 | #define C_00000D_FORCE_TAM 0xFBFFFFFF | ||
107 | #define S_00000D_FORCE_TDM(x) (((x) & 0x1) << 27) | ||
108 | #define G_00000D_FORCE_TDM(x) (((x) >> 27) & 0x1) | ||
109 | #define C_00000D_FORCE_TDM 0xF7FFFFFF | ||
110 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | ||
111 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | ||
112 | #define C_00000D_FORCE_RB 0xEFFFFFFF | ||
113 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) | ||
114 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) | ||
115 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF | ||
116 | #define S_00000D_FORCE_SUBPIC(x) (((x) & 0x1) << 30) | ||
117 | #define G_00000D_FORCE_SUBPIC(x) (((x) >> 30) & 0x1) | ||
118 | #define C_00000D_FORCE_SUBPIC 0xBFFFFFFF | ||
119 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) | ||
120 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) | ||
121 | #define C_00000D_FORCE_OV0 0x7FFFFFFF | ||
122 | |||
123 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv350d.h b/drivers/gpu/drm/radeon/rv350d.h new file mode 100644 index 000000000000..c75c5ed9e654 --- /dev/null +++ b/drivers/gpu/drm/radeon/rv350d.h | |||
@@ -0,0 +1,52 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Jerome Glisse. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Dave Airlie | ||
25 | * Alex Deucher | ||
26 | * Jerome Glisse | ||
27 | */ | ||
28 | #ifndef __RV350D_H__ | ||
29 | #define __RV350D_H__ | ||
30 | |||
31 | /* RV350, RV380 registers */ | ||
32 | /* #define R_00000D_SCLK_CNTL 0x00000D */ | ||
33 | #define S_00000D_FORCE_VAP(x) (((x) & 0x1) << 21) | ||
34 | #define G_00000D_FORCE_VAP(x) (((x) >> 21) & 0x1) | ||
35 | #define C_00000D_FORCE_VAP 0xFFDFFFFF | ||
36 | #define S_00000D_FORCE_SR(x) (((x) & 0x1) << 25) | ||
37 | #define G_00000D_FORCE_SR(x) (((x) >> 25) & 0x1) | ||
38 | #define C_00000D_FORCE_SR 0xFDFFFFFF | ||
39 | #define S_00000D_FORCE_PX(x) (((x) & 0x1) << 26) | ||
40 | #define G_00000D_FORCE_PX(x) (((x) >> 26) & 0x1) | ||
41 | #define C_00000D_FORCE_PX 0xFBFFFFFF | ||
42 | #define S_00000D_FORCE_TX(x) (((x) & 0x1) << 27) | ||
43 | #define G_00000D_FORCE_TX(x) (((x) >> 27) & 0x1) | ||
44 | #define C_00000D_FORCE_TX 0xF7FFFFFF | ||
45 | #define S_00000D_FORCE_US(x) (((x) & 0x1) << 28) | ||
46 | #define G_00000D_FORCE_US(x) (((x) >> 28) & 0x1) | ||
47 | #define C_00000D_FORCE_US 0xEFFFFFFF | ||
48 | #define S_00000D_FORCE_SU(x) (((x) & 0x1) << 30) | ||
49 | #define G_00000D_FORCE_SU(x) (((x) >> 30) & 0x1) | ||
50 | #define C_00000D_FORCE_SU 0xBFFFFFFF | ||
51 | |||
52 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv515.c b/drivers/gpu/drm/radeon/rv515.c index e53b5ca7a253..41a34c23e6d8 100644 --- a/drivers/gpu/drm/radeon/rv515.c +++ b/drivers/gpu/drm/radeon/rv515.c | |||
@@ -478,7 +478,7 @@ static int rv515_startup(struct radeon_device *rdev) | |||
478 | } | 478 | } |
479 | /* Enable IRQ */ | 479 | /* Enable IRQ */ |
480 | rdev->irq.sw_int = true; | 480 | rdev->irq.sw_int = true; |
481 | r100_irq_set(rdev); | 481 | rs600_irq_set(rdev); |
482 | /* 1M ring buffer */ | 482 | /* 1M ring buffer */ |
483 | r = r100_cp_init(rdev, 1024 * 1024); | 483 | r = r100_cp_init(rdev, 1024 * 1024); |
484 | if (r) { | 484 | if (r) { |
@@ -520,7 +520,7 @@ int rv515_suspend(struct radeon_device *rdev) | |||
520 | { | 520 | { |
521 | r100_cp_disable(rdev); | 521 | r100_cp_disable(rdev); |
522 | r100_wb_disable(rdev); | 522 | r100_wb_disable(rdev); |
523 | r100_irq_disable(rdev); | 523 | rs600_irq_disable(rdev); |
524 | if (rdev->flags & RADEON_IS_PCIE) | 524 | if (rdev->flags & RADEON_IS_PCIE) |
525 | rv370_pcie_gart_disable(rdev); | 525 | rv370_pcie_gart_disable(rdev); |
526 | return 0; | 526 | return 0; |
@@ -553,7 +553,6 @@ int rv515_init(struct radeon_device *rdev) | |||
553 | { | 553 | { |
554 | int r; | 554 | int r; |
555 | 555 | ||
556 | rdev->new_init_path = true; | ||
557 | /* Initialize scratch registers */ | 556 | /* Initialize scratch registers */ |
558 | radeon_scratch_init(rdev); | 557 | radeon_scratch_init(rdev); |
559 | /* Initialize surface registers */ | 558 | /* Initialize surface registers */ |
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c index e0b97d161397..595ac638039d 100644 --- a/drivers/gpu/drm/radeon/rv770.c +++ b/drivers/gpu/drm/radeon/rv770.c | |||
@@ -75,7 +75,7 @@ int rv770_pcie_gart_enable(struct radeon_device *rdev) | |||
75 | WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp); | 75 | WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp); |
76 | WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp); | 76 | WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp); |
77 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); | 77 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); |
78 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, (rdev->mc.gtt_end - 1) >> 12); | 78 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, rdev->mc.gtt_end >> 12); |
79 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); | 79 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); |
80 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | | 80 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | |
81 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); | 81 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); |
@@ -126,17 +126,36 @@ void rv770_pcie_gart_fini(struct radeon_device *rdev) | |||
126 | } | 126 | } |
127 | 127 | ||
128 | 128 | ||
129 | /* | 129 | void rv770_agp_enable(struct radeon_device *rdev) |
130 | * MC | ||
131 | */ | ||
132 | static void rv770_mc_resume(struct radeon_device *rdev) | ||
133 | { | 130 | { |
134 | u32 d1vga_control, d2vga_control; | 131 | u32 tmp; |
135 | u32 vga_render_control, vga_hdp_control; | 132 | int i; |
136 | u32 d1crtc_control, d2crtc_control; | 133 | |
137 | u32 new_d1grph_primary, new_d1grph_secondary; | 134 | /* Setup L2 cache */ |
138 | u32 new_d2grph_primary, new_d2grph_secondary; | 135 | WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING | |
139 | u64 old_vram_start; | 136 | ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE | |
137 | EFFECTIVE_L2_QUEUE_SIZE(7)); | ||
138 | WREG32(VM_L2_CNTL2, 0); | ||
139 | WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2)); | ||
140 | /* Setup TLB control */ | ||
141 | tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING | | ||
142 | SYSTEM_ACCESS_MODE_NOT_IN_SYS | | ||
143 | SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU | | ||
144 | EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5); | ||
145 | WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp); | ||
146 | WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp); | ||
147 | WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp); | ||
148 | WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp); | ||
149 | WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp); | ||
150 | WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp); | ||
151 | WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp); | ||
152 | for (i = 0; i < 7; i++) | ||
153 | WREG32(VM_CONTEXT0_CNTL + (i * 4), 0); | ||
154 | } | ||
155 | |||
156 | static void rv770_mc_program(struct radeon_device *rdev) | ||
157 | { | ||
158 | struct rv515_mc_save save; | ||
140 | u32 tmp; | 159 | u32 tmp; |
141 | int i, j; | 160 | int i, j; |
142 | 161 | ||
@@ -150,53 +169,42 @@ static void rv770_mc_resume(struct radeon_device *rdev) | |||
150 | } | 169 | } |
151 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); | 170 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); |
152 | 171 | ||
153 | d1vga_control = RREG32(D1VGA_CONTROL); | 172 | rv515_mc_stop(rdev, &save); |
154 | d2vga_control = RREG32(D2VGA_CONTROL); | ||
155 | vga_render_control = RREG32(VGA_RENDER_CONTROL); | ||
156 | vga_hdp_control = RREG32(VGA_HDP_CONTROL); | ||
157 | d1crtc_control = RREG32(D1CRTC_CONTROL); | ||
158 | d2crtc_control = RREG32(D2CRTC_CONTROL); | ||
159 | old_vram_start = (u64)(RREG32(MC_VM_FB_LOCATION) & 0xFFFF) << 24; | ||
160 | new_d1grph_primary = RREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS); | ||
161 | new_d1grph_secondary = RREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS); | ||
162 | new_d1grph_primary += rdev->mc.vram_start - old_vram_start; | ||
163 | new_d1grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
164 | new_d2grph_primary = RREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS); | ||
165 | new_d2grph_secondary = RREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS); | ||
166 | new_d2grph_primary += rdev->mc.vram_start - old_vram_start; | ||
167 | new_d2grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
168 | |||
169 | /* Stop all video */ | ||
170 | WREG32(D1VGA_CONTROL, 0); | ||
171 | WREG32(D2VGA_CONTROL, 0); | ||
172 | WREG32(VGA_RENDER_CONTROL, 0); | ||
173 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
174 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
175 | WREG32(D1CRTC_CONTROL, 0); | ||
176 | WREG32(D2CRTC_CONTROL, 0); | ||
177 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
178 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
179 | |||
180 | mdelay(1); | ||
181 | if (r600_mc_wait_for_idle(rdev)) { | 173 | if (r600_mc_wait_for_idle(rdev)) { |
182 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 174 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
183 | } | 175 | } |
184 | |||
185 | /* Lockout access through VGA aperture*/ | 176 | /* Lockout access through VGA aperture*/ |
186 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); | 177 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); |
187 | |||
188 | /* Update configuration */ | 178 | /* Update configuration */ |
189 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.vram_start >> 12); | 179 | if (rdev->flags & RADEON_IS_AGP) { |
190 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, (rdev->mc.vram_end - 1) >> 12); | 180 | if (rdev->mc.vram_start < rdev->mc.gtt_start) { |
181 | /* VRAM before AGP */ | ||
182 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
183 | rdev->mc.vram_start >> 12); | ||
184 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
185 | rdev->mc.gtt_end >> 12); | ||
186 | } else { | ||
187 | /* VRAM after AGP */ | ||
188 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
189 | rdev->mc.gtt_start >> 12); | ||
190 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
191 | rdev->mc.vram_end >> 12); | ||
192 | } | ||
193 | } else { | ||
194 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
195 | rdev->mc.vram_start >> 12); | ||
196 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
197 | rdev->mc.vram_end >> 12); | ||
198 | } | ||
191 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); | 199 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); |
192 | tmp = (((rdev->mc.vram_end - 1) >> 24) & 0xFFFF) << 16; | 200 | tmp = ((rdev->mc.vram_end >> 24) & 0xFFFF) << 16; |
193 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); | 201 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); |
194 | WREG32(MC_VM_FB_LOCATION, tmp); | 202 | WREG32(MC_VM_FB_LOCATION, tmp); |
195 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); | 203 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); |
196 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); | 204 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); |
197 | WREG32(HDP_NONSURFACE_SIZE, (rdev->mc.mc_vram_size - 1) | 0x3FF); | 205 | WREG32(HDP_NONSURFACE_SIZE, (rdev->mc.mc_vram_size - 1) | 0x3FF); |
198 | if (rdev->flags & RADEON_IS_AGP) { | 206 | if (rdev->flags & RADEON_IS_AGP) { |
199 | WREG32(MC_VM_AGP_TOP, (rdev->mc.gtt_end - 1) >> 16); | 207 | WREG32(MC_VM_AGP_TOP, rdev->mc.gtt_end >> 16); |
200 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16); | 208 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16); |
201 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); | 209 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); |
202 | } else { | 210 | } else { |
@@ -204,31 +212,10 @@ static void rv770_mc_resume(struct radeon_device *rdev) | |||
204 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); | 212 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); |
205 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); | 213 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); |
206 | } | 214 | } |
207 | WREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS, new_d1grph_primary); | ||
208 | WREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS, new_d1grph_secondary); | ||
209 | WREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS, new_d2grph_primary); | ||
210 | WREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS, new_d2grph_secondary); | ||
211 | WREG32(VGA_MEMORY_BASE_ADDRESS, rdev->mc.vram_start); | ||
212 | |||
213 | /* Unlock host access */ | ||
214 | WREG32(VGA_HDP_CONTROL, vga_hdp_control); | ||
215 | |||
216 | mdelay(1); | ||
217 | if (r600_mc_wait_for_idle(rdev)) { | 215 | if (r600_mc_wait_for_idle(rdev)) { |
218 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 216 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
219 | } | 217 | } |
220 | 218 | rv515_mc_resume(rdev, &save); | |
221 | /* Restore video state */ | ||
222 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
223 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
224 | WREG32(D1CRTC_CONTROL, d1crtc_control); | ||
225 | WREG32(D2CRTC_CONTROL, d2crtc_control); | ||
226 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
227 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
228 | WREG32(D1VGA_CONTROL, d1vga_control); | ||
229 | WREG32(D2VGA_CONTROL, d2vga_control); | ||
230 | WREG32(VGA_RENDER_CONTROL, vga_render_control); | ||
231 | |||
232 | /* we need to own VRAM, so turn off the VGA renderer here | 219 | /* we need to own VRAM, so turn off the VGA renderer here |
233 | * to stop it overwriting our objects */ | 220 | * to stop it overwriting our objects */ |
234 | rv515_vga_render_disable(rdev); | 221 | rv515_vga_render_disable(rdev); |
@@ -840,9 +827,9 @@ int rv770_mc_init(struct radeon_device *rdev) | |||
840 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | 827 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; |
841 | } | 828 | } |
842 | rdev->mc.vram_start = rdev->mc.vram_location; | 829 | rdev->mc.vram_start = rdev->mc.vram_location; |
843 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size; | 830 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; |
844 | rdev->mc.gtt_start = rdev->mc.gtt_location; | 831 | rdev->mc.gtt_start = rdev->mc.gtt_location; |
845 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size; | 832 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; |
846 | /* FIXME: we should enforce default clock in case GPU is not in | 833 | /* FIXME: we should enforce default clock in case GPU is not in |
847 | * default setup | 834 | * default setup |
848 | */ | 835 | */ |
@@ -861,11 +848,14 @@ static int rv770_startup(struct radeon_device *rdev) | |||
861 | { | 848 | { |
862 | int r; | 849 | int r; |
863 | 850 | ||
864 | radeon_gpu_reset(rdev); | 851 | rv770_mc_program(rdev); |
865 | rv770_mc_resume(rdev); | 852 | if (rdev->flags & RADEON_IS_AGP) { |
866 | r = rv770_pcie_gart_enable(rdev); | 853 | rv770_agp_enable(rdev); |
867 | if (r) | 854 | } else { |
868 | return r; | 855 | r = rv770_pcie_gart_enable(rdev); |
856 | if (r) | ||
857 | return r; | ||
858 | } | ||
869 | rv770_gpu_init(rdev); | 859 | rv770_gpu_init(rdev); |
870 | 860 | ||
871 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, | 861 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, |
@@ -884,9 +874,8 @@ static int rv770_startup(struct radeon_device *rdev) | |||
884 | r = r600_cp_resume(rdev); | 874 | r = r600_cp_resume(rdev); |
885 | if (r) | 875 | if (r) |
886 | return r; | 876 | return r; |
887 | r = r600_wb_init(rdev); | 877 | /* write back buffer are not vital so don't worry about failure */ |
888 | if (r) | 878 | r600_wb_enable(rdev); |
889 | return r; | ||
890 | return 0; | 879 | return 0; |
891 | } | 880 | } |
892 | 881 | ||
@@ -894,15 +883,12 @@ int rv770_resume(struct radeon_device *rdev) | |||
894 | { | 883 | { |
895 | int r; | 884 | int r; |
896 | 885 | ||
897 | if (radeon_gpu_reset(rdev)) { | 886 | /* Do not reset GPU before posting, on rv770 hw unlike on r500 hw, |
898 | /* FIXME: what do we want to do here ? */ | 887 | * posting will perform necessary task to bring back GPU into good |
899 | } | 888 | * shape. |
889 | */ | ||
900 | /* post card */ | 890 | /* post card */ |
901 | if (rdev->is_atom_bios) { | 891 | atom_asic_init(rdev->mode_info.atom_context); |
902 | atom_asic_init(rdev->mode_info.atom_context); | ||
903 | } else { | ||
904 | radeon_combios_asic_init(rdev->ddev); | ||
905 | } | ||
906 | /* Initialize clocks */ | 892 | /* Initialize clocks */ |
907 | r = radeon_clocks_init(rdev); | 893 | r = radeon_clocks_init(rdev); |
908 | if (r) { | 894 | if (r) { |
@@ -915,7 +901,7 @@ int rv770_resume(struct radeon_device *rdev) | |||
915 | return r; | 901 | return r; |
916 | } | 902 | } |
917 | 903 | ||
918 | r = radeon_ib_test(rdev); | 904 | r = r600_ib_test(rdev); |
919 | if (r) { | 905 | if (r) { |
920 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 906 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
921 | return r; | 907 | return r; |
@@ -929,8 +915,8 @@ int rv770_suspend(struct radeon_device *rdev) | |||
929 | /* FIXME: we should wait for ring to be empty */ | 915 | /* FIXME: we should wait for ring to be empty */ |
930 | r700_cp_stop(rdev); | 916 | r700_cp_stop(rdev); |
931 | rdev->cp.ready = false; | 917 | rdev->cp.ready = false; |
918 | r600_wb_disable(rdev); | ||
932 | rv770_pcie_gart_disable(rdev); | 919 | rv770_pcie_gart_disable(rdev); |
933 | |||
934 | /* unpin shaders bo */ | 920 | /* unpin shaders bo */ |
935 | radeon_object_unpin(rdev->r600_blit.shader_obj); | 921 | radeon_object_unpin(rdev->r600_blit.shader_obj); |
936 | return 0; | 922 | return 0; |
@@ -946,7 +932,6 @@ int rv770_init(struct radeon_device *rdev) | |||
946 | { | 932 | { |
947 | int r; | 933 | int r; |
948 | 934 | ||
949 | rdev->new_init_path = true; | ||
950 | r = radeon_dummy_page_init(rdev); | 935 | r = radeon_dummy_page_init(rdev); |
951 | if (r) | 936 | if (r) |
952 | return r; | 937 | return r; |
@@ -960,8 +945,10 @@ int rv770_init(struct radeon_device *rdev) | |||
960 | return -EINVAL; | 945 | return -EINVAL; |
961 | } | 946 | } |
962 | /* Must be an ATOMBIOS */ | 947 | /* Must be an ATOMBIOS */ |
963 | if (!rdev->is_atom_bios) | 948 | if (!rdev->is_atom_bios) { |
949 | dev_err(rdev->dev, "Expecting atombios for R600 GPU\n"); | ||
964 | return -EINVAL; | 950 | return -EINVAL; |
951 | } | ||
965 | r = radeon_atombios_init(rdev); | 952 | r = radeon_atombios_init(rdev); |
966 | if (r) | 953 | if (r) |
967 | return r; | 954 | return r; |
@@ -983,15 +970,8 @@ int rv770_init(struct radeon_device *rdev) | |||
983 | if (r) | 970 | if (r) |
984 | return r; | 971 | return r; |
985 | r = rv770_mc_init(rdev); | 972 | r = rv770_mc_init(rdev); |
986 | if (r) { | 973 | if (r) |
987 | if (rdev->flags & RADEON_IS_AGP) { | ||
988 | /* Retry with disabling AGP */ | ||
989 | rv770_fini(rdev); | ||
990 | rdev->flags &= ~RADEON_IS_AGP; | ||
991 | return rv770_init(rdev); | ||
992 | } | ||
993 | return r; | 974 | return r; |
994 | } | ||
995 | /* Memory manager */ | 975 | /* Memory manager */ |
996 | r = radeon_object_init(rdev); | 976 | r = radeon_object_init(rdev); |
997 | if (r) | 977 | if (r) |
@@ -1020,12 +1000,10 @@ int rv770_init(struct radeon_device *rdev) | |||
1020 | 1000 | ||
1021 | r = rv770_startup(rdev); | 1001 | r = rv770_startup(rdev); |
1022 | if (r) { | 1002 | if (r) { |
1023 | if (rdev->flags & RADEON_IS_AGP) { | 1003 | rv770_suspend(rdev); |
1024 | /* Retry with disabling AGP */ | 1004 | r600_wb_fini(rdev); |
1025 | rv770_fini(rdev); | 1005 | radeon_ring_fini(rdev); |
1026 | rdev->flags &= ~RADEON_IS_AGP; | 1006 | rv770_pcie_gart_fini(rdev); |
1027 | return rv770_init(rdev); | ||
1028 | } | ||
1029 | rdev->accel_working = false; | 1007 | rdev->accel_working = false; |
1030 | } | 1008 | } |
1031 | if (rdev->accel_working) { | 1009 | if (rdev->accel_working) { |
@@ -1034,7 +1012,7 @@ int rv770_init(struct radeon_device *rdev) | |||
1034 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); | 1012 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); |
1035 | rdev->accel_working = false; | 1013 | rdev->accel_working = false; |
1036 | } | 1014 | } |
1037 | r = radeon_ib_test(rdev); | 1015 | r = r600_ib_test(rdev); |
1038 | if (r) { | 1016 | if (r) { |
1039 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 1017 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
1040 | rdev->accel_working = false; | 1018 | rdev->accel_working = false; |
@@ -1049,20 +1027,15 @@ void rv770_fini(struct radeon_device *rdev) | |||
1049 | 1027 | ||
1050 | r600_blit_fini(rdev); | 1028 | r600_blit_fini(rdev); |
1051 | radeon_ring_fini(rdev); | 1029 | radeon_ring_fini(rdev); |
1030 | r600_wb_fini(rdev); | ||
1052 | rv770_pcie_gart_fini(rdev); | 1031 | rv770_pcie_gart_fini(rdev); |
1053 | radeon_gem_fini(rdev); | 1032 | radeon_gem_fini(rdev); |
1054 | radeon_fence_driver_fini(rdev); | 1033 | radeon_fence_driver_fini(rdev); |
1055 | radeon_clocks_fini(rdev); | 1034 | radeon_clocks_fini(rdev); |
1056 | #if __OS_HAS_AGP | ||
1057 | if (rdev->flags & RADEON_IS_AGP) | 1035 | if (rdev->flags & RADEON_IS_AGP) |
1058 | radeon_agp_fini(rdev); | 1036 | radeon_agp_fini(rdev); |
1059 | #endif | ||
1060 | radeon_object_fini(rdev); | 1037 | radeon_object_fini(rdev); |
1061 | if (rdev->is_atom_bios) { | 1038 | radeon_atombios_fini(rdev); |
1062 | radeon_atombios_fini(rdev); | ||
1063 | } else { | ||
1064 | radeon_combios_fini(rdev); | ||
1065 | } | ||
1066 | kfree(rdev->bios); | 1039 | kfree(rdev->bios); |
1067 | rdev->bios = NULL; | 1040 | rdev->bios = NULL; |
1068 | radeon_dummy_page_fini(rdev); | 1041 | radeon_dummy_page_fini(rdev); |
diff --git a/drivers/gpu/drm/ttm/ttm_global.c b/drivers/gpu/drm/ttm/ttm_global.c index 541744d00d3e..b17007178a36 100644 --- a/drivers/gpu/drm/ttm/ttm_global.c +++ b/drivers/gpu/drm/ttm/ttm_global.c | |||
@@ -82,8 +82,8 @@ int ttm_global_item_ref(struct ttm_global_reference *ref) | |||
82 | if (unlikely(ret != 0)) | 82 | if (unlikely(ret != 0)) |
83 | goto out_err; | 83 | goto out_err; |
84 | 84 | ||
85 | ++item->refcount; | ||
86 | } | 85 | } |
86 | ++item->refcount; | ||
87 | ref->object = item->object; | 87 | ref->object = item->object; |
88 | object = item->object; | 88 | object = item->object; |
89 | mutex_unlock(&item->mutex); | 89 | mutex_unlock(&item->mutex); |
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c index 0c6639ea03dd..ba05275e5104 100644 --- a/drivers/hid/hidraw.c +++ b/drivers/hid/hidraw.c | |||
@@ -30,6 +30,7 @@ | |||
30 | #include <linux/major.h> | 30 | #include <linux/major.h> |
31 | #include <linux/hid.h> | 31 | #include <linux/hid.h> |
32 | #include <linux/mutex.h> | 32 | #include <linux/mutex.h> |
33 | #include <linux/sched.h> | ||
33 | #include <linux/smp_lock.h> | 34 | #include <linux/smp_lock.h> |
34 | 35 | ||
35 | #include <linux/hidraw.h> | 36 | #include <linux/hidraw.h> |
diff --git a/drivers/hwmon/fschmd.c b/drivers/hwmon/fschmd.c index ea955edde87e..2a7a85a6dc36 100644 --- a/drivers/hwmon/fschmd.c +++ b/drivers/hwmon/fschmd.c | |||
@@ -915,7 +915,7 @@ static int watchdog_ioctl(struct inode *inode, struct file *filp, | |||
915 | return ret; | 915 | return ret; |
916 | } | 916 | } |
917 | 917 | ||
918 | static struct file_operations watchdog_fops = { | 918 | static const struct file_operations watchdog_fops = { |
919 | .owner = THIS_MODULE, | 919 | .owner = THIS_MODULE, |
920 | .llseek = no_llseek, | 920 | .llseek = no_llseek, |
921 | .open = watchdog_open, | 921 | .open = watchdog_open, |
diff --git a/drivers/hwmon/lis3lv02d_spi.c b/drivers/hwmon/lis3lv02d_spi.c index ecd739534f6a..82b16808a274 100644 --- a/drivers/hwmon/lis3lv02d_spi.c +++ b/drivers/hwmon/lis3lv02d_spi.c | |||
@@ -83,7 +83,8 @@ static int __devexit lis302dl_spi_remove(struct spi_device *spi) | |||
83 | struct lis3lv02d *lis3 = spi_get_drvdata(spi); | 83 | struct lis3lv02d *lis3 = spi_get_drvdata(spi); |
84 | lis3lv02d_joystick_disable(); | 84 | lis3lv02d_joystick_disable(); |
85 | lis3lv02d_poweroff(lis3); | 85 | lis3lv02d_poweroff(lis3); |
86 | return 0; | 86 | |
87 | return lis3lv02d_remove_fs(&lis3_dev); | ||
87 | } | 88 | } |
88 | 89 | ||
89 | #ifdef CONFIG_PM | 90 | #ifdef CONFIG_PM |
diff --git a/drivers/hwmon/ltc4215.c b/drivers/hwmon/ltc4215.c index 6c9a04136e0a..00d975eb5b83 100644 --- a/drivers/hwmon/ltc4215.c +++ b/drivers/hwmon/ltc4215.c | |||
@@ -20,11 +20,6 @@ | |||
20 | #include <linux/hwmon.h> | 20 | #include <linux/hwmon.h> |
21 | #include <linux/hwmon-sysfs.h> | 21 | #include <linux/hwmon-sysfs.h> |
22 | 22 | ||
23 | static const unsigned short normal_i2c[] = { I2C_CLIENT_END }; | ||
24 | |||
25 | /* Insmod parameters */ | ||
26 | I2C_CLIENT_INSMOD_1(ltc4215); | ||
27 | |||
28 | /* Here are names of the chip's registers (a.k.a. commands) */ | 23 | /* Here are names of the chip's registers (a.k.a. commands) */ |
29 | enum ltc4215_cmd { | 24 | enum ltc4215_cmd { |
30 | LTC4215_CONTROL = 0x00, /* rw */ | 25 | LTC4215_CONTROL = 0x00, /* rw */ |
@@ -246,9 +241,13 @@ static const struct attribute_group ltc4215_group = { | |||
246 | static int ltc4215_probe(struct i2c_client *client, | 241 | static int ltc4215_probe(struct i2c_client *client, |
247 | const struct i2c_device_id *id) | 242 | const struct i2c_device_id *id) |
248 | { | 243 | { |
244 | struct i2c_adapter *adapter = client->adapter; | ||
249 | struct ltc4215_data *data; | 245 | struct ltc4215_data *data; |
250 | int ret; | 246 | int ret; |
251 | 247 | ||
248 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | ||
249 | return -ENODEV; | ||
250 | |||
252 | data = kzalloc(sizeof(*data), GFP_KERNEL); | 251 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
253 | if (!data) { | 252 | if (!data) { |
254 | ret = -ENOMEM; | 253 | ret = -ENOMEM; |
@@ -294,56 +293,20 @@ static int ltc4215_remove(struct i2c_client *client) | |||
294 | return 0; | 293 | return 0; |
295 | } | 294 | } |
296 | 295 | ||
297 | static int ltc4215_detect(struct i2c_client *client, | ||
298 | int kind, | ||
299 | struct i2c_board_info *info) | ||
300 | { | ||
301 | struct i2c_adapter *adapter = client->adapter; | ||
302 | |||
303 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | ||
304 | return -ENODEV; | ||
305 | |||
306 | if (kind < 0) { /* probed detection - check the chip type */ | ||
307 | s32 v; /* 8 bits from the chip, or -ERRNO */ | ||
308 | |||
309 | /* | ||
310 | * Register 0x01 bit b7 is reserved, expect 0 | ||
311 | * Register 0x03 bit b6 and b7 are reserved, expect 0 | ||
312 | */ | ||
313 | v = i2c_smbus_read_byte_data(client, LTC4215_ALERT); | ||
314 | if (v < 0 || (v & (1 << 7)) != 0) | ||
315 | return -ENODEV; | ||
316 | |||
317 | v = i2c_smbus_read_byte_data(client, LTC4215_FAULT); | ||
318 | if (v < 0 || (v & ((1 << 6) | (1 << 7))) != 0) | ||
319 | return -ENODEV; | ||
320 | } | ||
321 | |||
322 | strlcpy(info->type, "ltc4215", I2C_NAME_SIZE); | ||
323 | dev_info(&adapter->dev, "ltc4215 %s at address 0x%02x\n", | ||
324 | kind < 0 ? "probed" : "forced", | ||
325 | client->addr); | ||
326 | |||
327 | return 0; | ||
328 | } | ||
329 | |||
330 | static const struct i2c_device_id ltc4215_id[] = { | 296 | static const struct i2c_device_id ltc4215_id[] = { |
331 | { "ltc4215", ltc4215 }, | 297 | { "ltc4215", 0 }, |
332 | { } | 298 | { } |
333 | }; | 299 | }; |
334 | MODULE_DEVICE_TABLE(i2c, ltc4215_id); | 300 | MODULE_DEVICE_TABLE(i2c, ltc4215_id); |
335 | 301 | ||
336 | /* This is the driver that will be inserted */ | 302 | /* This is the driver that will be inserted */ |
337 | static struct i2c_driver ltc4215_driver = { | 303 | static struct i2c_driver ltc4215_driver = { |
338 | .class = I2C_CLASS_HWMON, | ||
339 | .driver = { | 304 | .driver = { |
340 | .name = "ltc4215", | 305 | .name = "ltc4215", |
341 | }, | 306 | }, |
342 | .probe = ltc4215_probe, | 307 | .probe = ltc4215_probe, |
343 | .remove = ltc4215_remove, | 308 | .remove = ltc4215_remove, |
344 | .id_table = ltc4215_id, | 309 | .id_table = ltc4215_id, |
345 | .detect = ltc4215_detect, | ||
346 | .address_data = &addr_data, | ||
347 | }; | 310 | }; |
348 | 311 | ||
349 | static int __init ltc4215_init(void) | 312 | static int __init ltc4215_init(void) |
diff --git a/drivers/hwmon/ltc4245.c b/drivers/hwmon/ltc4245.c index e38964333612..65c232a9d0c5 100644 --- a/drivers/hwmon/ltc4245.c +++ b/drivers/hwmon/ltc4245.c | |||
@@ -22,15 +22,6 @@ | |||
22 | #include <linux/hwmon.h> | 22 | #include <linux/hwmon.h> |
23 | #include <linux/hwmon-sysfs.h> | 23 | #include <linux/hwmon-sysfs.h> |
24 | 24 | ||
25 | /* Valid addresses are 0x20 - 0x3f | ||
26 | * | ||
27 | * For now, we do not probe, since some of these addresses | ||
28 | * are known to be unfriendly to probing */ | ||
29 | static const unsigned short normal_i2c[] = { I2C_CLIENT_END }; | ||
30 | |||
31 | /* Insmod parameters */ | ||
32 | I2C_CLIENT_INSMOD_1(ltc4245); | ||
33 | |||
34 | /* Here are names of the chip's registers (a.k.a. commands) */ | 25 | /* Here are names of the chip's registers (a.k.a. commands) */ |
35 | enum ltc4245_cmd { | 26 | enum ltc4245_cmd { |
36 | LTC4245_STATUS = 0x00, /* readonly */ | 27 | LTC4245_STATUS = 0x00, /* readonly */ |
@@ -369,9 +360,13 @@ static const struct attribute_group ltc4245_group = { | |||
369 | static int ltc4245_probe(struct i2c_client *client, | 360 | static int ltc4245_probe(struct i2c_client *client, |
370 | const struct i2c_device_id *id) | 361 | const struct i2c_device_id *id) |
371 | { | 362 | { |
363 | struct i2c_adapter *adapter = client->adapter; | ||
372 | struct ltc4245_data *data; | 364 | struct ltc4245_data *data; |
373 | int ret; | 365 | int ret; |
374 | 366 | ||
367 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | ||
368 | return -ENODEV; | ||
369 | |||
375 | data = kzalloc(sizeof(*data), GFP_KERNEL); | 370 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
376 | if (!data) { | 371 | if (!data) { |
377 | ret = -ENOMEM; | 372 | ret = -ENOMEM; |
@@ -418,136 +413,20 @@ static int ltc4245_remove(struct i2c_client *client) | |||
418 | return 0; | 413 | return 0; |
419 | } | 414 | } |
420 | 415 | ||
421 | /* Check that some bits in a control register appear at all possible | ||
422 | * locations without changing value | ||
423 | * | ||
424 | * @client: the i2c client to use | ||
425 | * @reg: the register to read | ||
426 | * @bits: the bits to check (0xff checks all bits, | ||
427 | * 0x03 checks only the last two bits) | ||
428 | * | ||
429 | * return -ERRNO if the register read failed | ||
430 | * return -ENODEV if the register value doesn't stay constant at all | ||
431 | * possible addresses | ||
432 | * | ||
433 | * return 0 for success | ||
434 | */ | ||
435 | static int ltc4245_check_control_reg(struct i2c_client *client, u8 reg, u8 bits) | ||
436 | { | ||
437 | int i; | ||
438 | s32 v, voff1, voff2; | ||
439 | |||
440 | /* Read register and check for error */ | ||
441 | v = i2c_smbus_read_byte_data(client, reg); | ||
442 | if (v < 0) | ||
443 | return v; | ||
444 | |||
445 | v &= bits; | ||
446 | |||
447 | for (i = 0x00; i < 0xff; i += 0x20) { | ||
448 | |||
449 | voff1 = i2c_smbus_read_byte_data(client, reg + i); | ||
450 | if (voff1 < 0) | ||
451 | return voff1; | ||
452 | |||
453 | voff2 = i2c_smbus_read_byte_data(client, reg + i + 0x08); | ||
454 | if (voff2 < 0) | ||
455 | return voff2; | ||
456 | |||
457 | voff1 &= bits; | ||
458 | voff2 &= bits; | ||
459 | |||
460 | if (v != voff1 || v != voff2) | ||
461 | return -ENODEV; | ||
462 | } | ||
463 | |||
464 | return 0; | ||
465 | } | ||
466 | |||
467 | static int ltc4245_detect(struct i2c_client *client, | ||
468 | int kind, | ||
469 | struct i2c_board_info *info) | ||
470 | { | ||
471 | struct i2c_adapter *adapter = client->adapter; | ||
472 | |||
473 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | ||
474 | return -ENODEV; | ||
475 | |||
476 | if (kind < 0) { /* probed detection - check the chip type */ | ||
477 | s32 v; /* 8 bits from the chip, or -ERRNO */ | ||
478 | |||
479 | /* Chip registers 0x00-0x07 are control registers | ||
480 | * Chip registers 0x10-0x1f are data registers | ||
481 | * | ||
482 | * Address bits b7-b5 are ignored. This makes the chip "repeat" | ||
483 | * in steps of 0x20. Any control registers should appear with | ||
484 | * the same values across all duplicated addresses. | ||
485 | * | ||
486 | * Register 0x02 bit b2 is reserved, expect 0 | ||
487 | * Register 0x07 bits b7 to b4 are reserved, expect 0 | ||
488 | * | ||
489 | * Registers 0x01, 0x02 are control registers and should not | ||
490 | * change on their own. | ||
491 | * | ||
492 | * Register 0x06 bits b6 and b7 are control bits, and should | ||
493 | * not change on their own. | ||
494 | * | ||
495 | * Register 0x07 bits b3 to b0 are control bits, and should | ||
496 | * not change on their own. | ||
497 | */ | ||
498 | |||
499 | /* read register 0x02 reserved bit, expect 0 */ | ||
500 | v = i2c_smbus_read_byte_data(client, LTC4245_CONTROL); | ||
501 | if (v < 0 || (v & 0x04) != 0) | ||
502 | return -ENODEV; | ||
503 | |||
504 | /* read register 0x07 reserved bits, expect 0 */ | ||
505 | v = i2c_smbus_read_byte_data(client, LTC4245_ADCADR); | ||
506 | if (v < 0 || (v & 0xf0) != 0) | ||
507 | return -ENODEV; | ||
508 | |||
509 | /* check that the alert register appears at all locations */ | ||
510 | if (ltc4245_check_control_reg(client, LTC4245_ALERT, 0xff)) | ||
511 | return -ENODEV; | ||
512 | |||
513 | /* check that the control register appears at all locations */ | ||
514 | if (ltc4245_check_control_reg(client, LTC4245_CONTROL, 0xff)) | ||
515 | return -ENODEV; | ||
516 | |||
517 | /* check that register 0x06 bits b6 and b7 stay constant */ | ||
518 | if (ltc4245_check_control_reg(client, LTC4245_GPIO, 0xc0)) | ||
519 | return -ENODEV; | ||
520 | |||
521 | /* check that register 0x07 bits b3-b0 stay constant */ | ||
522 | if (ltc4245_check_control_reg(client, LTC4245_ADCADR, 0x0f)) | ||
523 | return -ENODEV; | ||
524 | } | ||
525 | |||
526 | strlcpy(info->type, "ltc4245", I2C_NAME_SIZE); | ||
527 | dev_info(&adapter->dev, "ltc4245 %s at address 0x%02x\n", | ||
528 | kind < 0 ? "probed" : "forced", | ||
529 | client->addr); | ||
530 | |||
531 | return 0; | ||
532 | } | ||
533 | |||
534 | static const struct i2c_device_id ltc4245_id[] = { | 416 | static const struct i2c_device_id ltc4245_id[] = { |
535 | { "ltc4245", ltc4245 }, | 417 | { "ltc4245", 0 }, |
536 | { } | 418 | { } |
537 | }; | 419 | }; |
538 | MODULE_DEVICE_TABLE(i2c, ltc4245_id); | 420 | MODULE_DEVICE_TABLE(i2c, ltc4245_id); |
539 | 421 | ||
540 | /* This is the driver that will be inserted */ | 422 | /* This is the driver that will be inserted */ |
541 | static struct i2c_driver ltc4245_driver = { | 423 | static struct i2c_driver ltc4245_driver = { |
542 | .class = I2C_CLASS_HWMON, | ||
543 | .driver = { | 424 | .driver = { |
544 | .name = "ltc4245", | 425 | .name = "ltc4245", |
545 | }, | 426 | }, |
546 | .probe = ltc4245_probe, | 427 | .probe = ltc4245_probe, |
547 | .remove = ltc4245_remove, | 428 | .remove = ltc4245_remove, |
548 | .id_table = ltc4245_id, | 429 | .id_table = ltc4245_id, |
549 | .detect = ltc4245_detect, | ||
550 | .address_data = &addr_data, | ||
551 | }; | 430 | }; |
552 | 431 | ||
553 | static int __init ltc4245_init(void) | 432 | static int __init ltc4245_init(void) |
diff --git a/drivers/i2c/busses/i2c-amd756.c b/drivers/i2c/busses/i2c-amd756.c index f7d6fe9c49ba..8f0b90ef8c76 100644 --- a/drivers/i2c/busses/i2c-amd756.c +++ b/drivers/i2c/busses/i2c-amd756.c | |||
@@ -364,7 +364,7 @@ static int __devinit amd756_probe(struct pci_dev *pdev, | |||
364 | error = acpi_check_region(amd756_ioport, SMB_IOSIZE, | 364 | error = acpi_check_region(amd756_ioport, SMB_IOSIZE, |
365 | amd756_driver.name); | 365 | amd756_driver.name); |
366 | if (error) | 366 | if (error) |
367 | return error; | 367 | return -ENODEV; |
368 | 368 | ||
369 | if (!request_region(amd756_ioport, SMB_IOSIZE, amd756_driver.name)) { | 369 | if (!request_region(amd756_ioport, SMB_IOSIZE, amd756_driver.name)) { |
370 | dev_err(&pdev->dev, "SMB region 0x%x already in use!\n", | 370 | dev_err(&pdev->dev, "SMB region 0x%x already in use!\n", |
diff --git a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c index a7c59908c457..5b4ad86ca166 100644 --- a/drivers/i2c/busses/i2c-amd8111.c +++ b/drivers/i2c/busses/i2c-amd8111.c | |||
@@ -376,8 +376,10 @@ static int __devinit amd8111_probe(struct pci_dev *dev, | |||
376 | smbus->size = pci_resource_len(dev, 0); | 376 | smbus->size = pci_resource_len(dev, 0); |
377 | 377 | ||
378 | error = acpi_check_resource_conflict(&dev->resource[0]); | 378 | error = acpi_check_resource_conflict(&dev->resource[0]); |
379 | if (error) | 379 | if (error) { |
380 | error = -ENODEV; | ||
380 | goto out_kfree; | 381 | goto out_kfree; |
382 | } | ||
381 | 383 | ||
382 | if (!request_region(smbus->base, smbus->size, amd8111_driver.name)) { | 384 | if (!request_region(smbus->base, smbus->size, amd8111_driver.name)) { |
383 | error = -EBUSY; | 385 | error = -EBUSY; |
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c index 9d2c5adf5d4f..55edcfe5b851 100644 --- a/drivers/i2c/busses/i2c-i801.c +++ b/drivers/i2c/busses/i2c-i801.c | |||
@@ -732,8 +732,10 @@ static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id | |||
732 | } | 732 | } |
733 | 733 | ||
734 | err = acpi_check_resource_conflict(&dev->resource[SMBBAR]); | 734 | err = acpi_check_resource_conflict(&dev->resource[SMBBAR]); |
735 | if (err) | 735 | if (err) { |
736 | err = -ENODEV; | ||
736 | goto exit; | 737 | goto exit; |
738 | } | ||
737 | 739 | ||
738 | err = pci_request_region(dev, SMBBAR, i801_driver.name); | 740 | err = pci_request_region(dev, SMBBAR, i801_driver.name); |
739 | if (err) { | 741 | if (err) { |
diff --git a/drivers/i2c/busses/i2c-isch.c b/drivers/i2c/busses/i2c-isch.c index 9f6b8e0f8632..dba6eb053e2f 100644 --- a/drivers/i2c/busses/i2c-isch.c +++ b/drivers/i2c/busses/i2c-isch.c | |||
@@ -281,7 +281,7 @@ static int __devinit sch_probe(struct pci_dev *dev, | |||
281 | return -ENODEV; | 281 | return -ENODEV; |
282 | } | 282 | } |
283 | if (acpi_check_region(sch_smba, SMBIOSIZE, sch_driver.name)) | 283 | if (acpi_check_region(sch_smba, SMBIOSIZE, sch_driver.name)) |
284 | return -EBUSY; | 284 | return -ENODEV; |
285 | if (!request_region(sch_smba, SMBIOSIZE, sch_driver.name)) { | 285 | if (!request_region(sch_smba, SMBIOSIZE, sch_driver.name)) { |
286 | dev_err(&dev->dev, "SMBus region 0x%x already in use!\n", | 286 | dev_err(&dev->dev, "SMBus region 0x%x already in use!\n", |
287 | sch_smba); | 287 | sch_smba); |
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c index a782c7a08f9e..d26a972aacaa 100644 --- a/drivers/i2c/busses/i2c-piix4.c +++ b/drivers/i2c/busses/i2c-piix4.c | |||
@@ -169,7 +169,7 @@ static int __devinit piix4_setup(struct pci_dev *PIIX4_dev, | |||
169 | } | 169 | } |
170 | 170 | ||
171 | if (acpi_check_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) | 171 | if (acpi_check_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) |
172 | return -EBUSY; | 172 | return -ENODEV; |
173 | 173 | ||
174 | if (!request_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) { | 174 | if (!request_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) { |
175 | dev_err(&PIIX4_dev->dev, "SMBus region 0x%x already in use!\n", | 175 | dev_err(&PIIX4_dev->dev, "SMBus region 0x%x already in use!\n", |
@@ -260,7 +260,7 @@ static int __devinit piix4_setup_sb800(struct pci_dev *PIIX4_dev, | |||
260 | 260 | ||
261 | piix4_smba = ((smba_en_hi << 8) | smba_en_lo) & 0xffe0; | 261 | piix4_smba = ((smba_en_hi << 8) | smba_en_lo) & 0xffe0; |
262 | if (acpi_check_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) | 262 | if (acpi_check_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) |
263 | return -EBUSY; | 263 | return -ENODEV; |
264 | 264 | ||
265 | if (!request_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) { | 265 | if (!request_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) { |
266 | dev_err(&PIIX4_dev->dev, "SMBus region 0x%x already in use!\n", | 266 | dev_err(&PIIX4_dev->dev, "SMBus region 0x%x already in use!\n", |
diff --git a/drivers/i2c/busses/i2c-sis96x.c b/drivers/i2c/busses/i2c-sis96x.c index 8295885b2fdb..1649963b00dc 100644 --- a/drivers/i2c/busses/i2c-sis96x.c +++ b/drivers/i2c/busses/i2c-sis96x.c | |||
@@ -280,7 +280,7 @@ static int __devinit sis96x_probe(struct pci_dev *dev, | |||
280 | 280 | ||
281 | retval = acpi_check_resource_conflict(&dev->resource[SIS96x_BAR]); | 281 | retval = acpi_check_resource_conflict(&dev->resource[SIS96x_BAR]); |
282 | if (retval) | 282 | if (retval) |
283 | return retval; | 283 | return -ENODEV; |
284 | 284 | ||
285 | /* Everything is happy, let's grab the memory and set things up. */ | 285 | /* Everything is happy, let's grab the memory and set things up. */ |
286 | if (!request_region(sis96x_smbus_base, SMB_IOSIZE, | 286 | if (!request_region(sis96x_smbus_base, SMB_IOSIZE, |
diff --git a/drivers/i2c/busses/i2c-viapro.c b/drivers/i2c/busses/i2c-viapro.c index 54d810a4d00f..e4b1543015af 100644 --- a/drivers/i2c/busses/i2c-viapro.c +++ b/drivers/i2c/busses/i2c-viapro.c | |||
@@ -365,7 +365,7 @@ static int __devinit vt596_probe(struct pci_dev *pdev, | |||
365 | found: | 365 | found: |
366 | error = acpi_check_region(vt596_smba, 8, vt596_driver.name); | 366 | error = acpi_check_region(vt596_smba, 8, vt596_driver.name); |
367 | if (error) | 367 | if (error) |
368 | return error; | 368 | return -ENODEV; |
369 | 369 | ||
370 | if (!request_region(vt596_smba, 8, vt596_driver.name)) { | 370 | if (!request_region(vt596_smba, 8, vt596_driver.name)) { |
371 | dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n", | 371 | dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n", |
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c index 28d09a5d8450..017c09540c2f 100644 --- a/drivers/ide/ide-proc.c +++ b/drivers/ide/ide-proc.c | |||
@@ -273,14 +273,8 @@ static const struct ide_proc_devset ide_generic_settings[] = { | |||
273 | 273 | ||
274 | static void proc_ide_settings_warn(void) | 274 | static void proc_ide_settings_warn(void) |
275 | { | 275 | { |
276 | static int warned; | 276 | printk_once(KERN_WARNING "Warning: /proc/ide/hd?/settings interface is " |
277 | |||
278 | if (warned) | ||
279 | return; | ||
280 | |||
281 | printk(KERN_WARNING "Warning: /proc/ide/hd?/settings interface is " | ||
282 | "obsolete, and will be removed soon!\n"); | 277 | "obsolete, and will be removed soon!\n"); |
283 | warned = 1; | ||
284 | } | 278 | } |
285 | 279 | ||
286 | static int ide_settings_proc_show(struct seq_file *m, void *v) | 280 | static int ide_settings_proc_show(struct seq_file *m, void *v) |
diff --git a/drivers/ide/sis5513.c b/drivers/ide/sis5513.c index afca22beaadf..3b88eba04c9c 100644 --- a/drivers/ide/sis5513.c +++ b/drivers/ide/sis5513.c | |||
@@ -2,7 +2,7 @@ | |||
2 | * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org> | 2 | * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org> |
3 | * Copyright (C) 2002 Lionel Bouton <Lionel.Bouton@inet6.fr>, Maintainer | 3 | * Copyright (C) 2002 Lionel Bouton <Lionel.Bouton@inet6.fr>, Maintainer |
4 | * Copyright (C) 2003 Vojtech Pavlik <vojtech@suse.cz> | 4 | * Copyright (C) 2003 Vojtech Pavlik <vojtech@suse.cz> |
5 | * Copyright (C) 2007 Bartlomiej Zolnierkiewicz | 5 | * Copyright (C) 2007-2009 Bartlomiej Zolnierkiewicz |
6 | * | 6 | * |
7 | * May be copied or modified under the terms of the GNU General Public License | 7 | * May be copied or modified under the terms of the GNU General Public License |
8 | * | 8 | * |
@@ -281,11 +281,13 @@ static void config_drive_art_rwp(ide_drive_t *drive) | |||
281 | 281 | ||
282 | pci_read_config_byte(dev, 0x4b, ®4bh); | 282 | pci_read_config_byte(dev, 0x4b, ®4bh); |
283 | 283 | ||
284 | rw_prefetch = reg4bh & ~(0x11 << drive->dn); | ||
285 | |||
284 | if (drive->media == ide_disk) | 286 | if (drive->media == ide_disk) |
285 | rw_prefetch = 0x11 << drive->dn; | 287 | rw_prefetch |= 0x11 << drive->dn; |
286 | 288 | ||
287 | if ((reg4bh & (0x11 << drive->dn)) != rw_prefetch) | 289 | if (reg4bh != rw_prefetch) |
288 | pci_write_config_byte(dev, 0x4b, reg4bh|rw_prefetch); | 290 | pci_write_config_byte(dev, 0x4b, rw_prefetch); |
289 | } | 291 | } |
290 | 292 | ||
291 | static void sis_set_pio_mode(ide_drive_t *drive, const u8 pio) | 293 | static void sis_set_pio_mode(ide_drive_t *drive, const u8 pio) |
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c index 51bd9669cb1f..f504c9b00c1b 100644 --- a/drivers/infiniband/core/ucm.c +++ b/drivers/infiniband/core/ucm.c | |||
@@ -38,6 +38,7 @@ | |||
38 | #include <linux/device.h> | 38 | #include <linux/device.h> |
39 | #include <linux/err.h> | 39 | #include <linux/err.h> |
40 | #include <linux/poll.h> | 40 | #include <linux/poll.h> |
41 | #include <linux/sched.h> | ||
41 | #include <linux/file.h> | 42 | #include <linux/file.h> |
42 | #include <linux/mount.h> | 43 | #include <linux/mount.h> |
43 | #include <linux/cdev.h> | 44 | #include <linux/cdev.h> |
diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c index 8c46f2257098..7de02969ed7d 100644 --- a/drivers/infiniband/core/user_mad.c +++ b/drivers/infiniband/core/user_mad.c | |||
@@ -44,6 +44,7 @@ | |||
44 | #include <linux/mutex.h> | 44 | #include <linux/mutex.h> |
45 | #include <linux/kref.h> | 45 | #include <linux/kref.h> |
46 | #include <linux/compat.h> | 46 | #include <linux/compat.h> |
47 | #include <linux/sched.h> | ||
47 | #include <linux/semaphore.h> | 48 | #include <linux/semaphore.h> |
48 | 49 | ||
49 | #include <asm/uaccess.h> | 50 | #include <asm/uaccess.h> |
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c index d3fff9e008a3..aec0fbdfe7f0 100644 --- a/drivers/infiniband/core/uverbs_main.c +++ b/drivers/infiniband/core/uverbs_main.c | |||
@@ -40,6 +40,7 @@ | |||
40 | #include <linux/err.h> | 40 | #include <linux/err.h> |
41 | #include <linux/fs.h> | 41 | #include <linux/fs.h> |
42 | #include <linux/poll.h> | 42 | #include <linux/poll.h> |
43 | #include <linux/sched.h> | ||
43 | #include <linux/file.h> | 44 | #include <linux/file.h> |
44 | #include <linux/mount.h> | 45 | #include <linux/mount.h> |
45 | #include <linux/cdev.h> | 46 | #include <linux/cdev.h> |
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c index 1148140d08a1..dee6706038aa 100644 --- a/drivers/input/evdev.c +++ b/drivers/input/evdev.c | |||
@@ -13,6 +13,7 @@ | |||
13 | #define EVDEV_BUFFER_SIZE 64 | 13 | #define EVDEV_BUFFER_SIZE 64 |
14 | 14 | ||
15 | #include <linux/poll.h> | 15 | #include <linux/poll.h> |
16 | #include <linux/sched.h> | ||
16 | #include <linux/slab.h> | 17 | #include <linux/slab.h> |
17 | #include <linux/module.h> | 18 | #include <linux/module.h> |
18 | #include <linux/init.h> | 19 | #include <linux/init.h> |
diff --git a/drivers/input/input.c b/drivers/input/input.c index e828aab7dace..c6f88ebb40c7 100644 --- a/drivers/input/input.c +++ b/drivers/input/input.c | |||
@@ -17,6 +17,7 @@ | |||
17 | #include <linux/random.h> | 17 | #include <linux/random.h> |
18 | #include <linux/major.h> | 18 | #include <linux/major.h> |
19 | #include <linux/proc_fs.h> | 19 | #include <linux/proc_fs.h> |
20 | #include <linux/sched.h> | ||
20 | #include <linux/seq_file.h> | 21 | #include <linux/seq_file.h> |
21 | #include <linux/poll.h> | 22 | #include <linux/poll.h> |
22 | #include <linux/device.h> | 23 | #include <linux/device.h> |
@@ -1273,6 +1274,7 @@ static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env) | |||
1273 | } \ | 1274 | } \ |
1274 | } while (0) | 1275 | } while (0) |
1275 | 1276 | ||
1277 | #ifdef CONFIG_PM | ||
1276 | static void input_dev_reset(struct input_dev *dev, bool activate) | 1278 | static void input_dev_reset(struct input_dev *dev, bool activate) |
1277 | { | 1279 | { |
1278 | if (!dev->event) | 1280 | if (!dev->event) |
@@ -1287,7 +1289,6 @@ static void input_dev_reset(struct input_dev *dev, bool activate) | |||
1287 | } | 1289 | } |
1288 | } | 1290 | } |
1289 | 1291 | ||
1290 | #ifdef CONFIG_PM | ||
1291 | static int input_dev_suspend(struct device *dev) | 1292 | static int input_dev_suspend(struct device *dev) |
1292 | { | 1293 | { |
1293 | struct input_dev *input_dev = to_input_dev(dev); | 1294 | struct input_dev *input_dev = to_input_dev(dev); |
diff --git a/drivers/input/joydev.c b/drivers/input/joydev.c index 901b2525993e..b1bd6dd32286 100644 --- a/drivers/input/joydev.c +++ b/drivers/input/joydev.c | |||
@@ -18,6 +18,7 @@ | |||
18 | #include <linux/input.h> | 18 | #include <linux/input.h> |
19 | #include <linux/kernel.h> | 19 | #include <linux/kernel.h> |
20 | #include <linux/major.h> | 20 | #include <linux/major.h> |
21 | #include <linux/sched.h> | ||
21 | #include <linux/slab.h> | 22 | #include <linux/slab.h> |
22 | #include <linux/mm.h> | 23 | #include <linux/mm.h> |
23 | #include <linux/miscdevice.h> | 24 | #include <linux/miscdevice.h> |
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c index c5a49aba418f..d3f57245420a 100644 --- a/drivers/input/misc/uinput.c +++ b/drivers/input/misc/uinput.c | |||
@@ -30,6 +30,7 @@ | |||
30 | * - first public version | 30 | * - first public version |
31 | */ | 31 | */ |
32 | #include <linux/poll.h> | 32 | #include <linux/poll.h> |
33 | #include <linux/sched.h> | ||
33 | #include <linux/slab.h> | 34 | #include <linux/slab.h> |
34 | #include <linux/module.h> | 35 | #include <linux/module.h> |
35 | #include <linux/init.h> | 36 | #include <linux/init.h> |
diff --git a/drivers/input/mousedev.c b/drivers/input/mousedev.c index 966b8868f792..a13d80f7da17 100644 --- a/drivers/input/mousedev.c +++ b/drivers/input/mousedev.c | |||
@@ -13,6 +13,7 @@ | |||
13 | #define MOUSEDEV_MINORS 32 | 13 | #define MOUSEDEV_MINORS 32 |
14 | #define MOUSEDEV_MIX 31 | 14 | #define MOUSEDEV_MIX 31 |
15 | 15 | ||
16 | #include <linux/sched.h> | ||
16 | #include <linux/slab.h> | 17 | #include <linux/slab.h> |
17 | #include <linux/smp_lock.h> | 18 | #include <linux/smp_lock.h> |
18 | #include <linux/poll.h> | 19 | #include <linux/poll.h> |
diff --git a/drivers/isdn/capi/capi.c b/drivers/isdn/capi/capi.c index 2d8352419c0d..65bf91e16a42 100644 --- a/drivers/isdn/capi/capi.c +++ b/drivers/isdn/capi/capi.c | |||
@@ -603,7 +603,7 @@ static void capi_recv_message(struct capi20_appl *ap, struct sk_buff *skb) | |||
603 | 603 | ||
604 | if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_CONF) { | 604 | if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_CONF) { |
605 | u16 info = CAPIMSG_U16(skb->data, 12); // Info field | 605 | u16 info = CAPIMSG_U16(skb->data, 12); // Info field |
606 | if (info == 0) { | 606 | if ((info & 0xff00) == 0) { |
607 | mutex_lock(&cdev->ncci_list_mtx); | 607 | mutex_lock(&cdev->ncci_list_mtx); |
608 | capincci_alloc(cdev, CAPIMSG_NCCI(skb->data)); | 608 | capincci_alloc(cdev, CAPIMSG_NCCI(skb->data)); |
609 | mutex_unlock(&cdev->ncci_list_mtx); | 609 | mutex_unlock(&cdev->ncci_list_mtx); |
diff --git a/drivers/isdn/capi/capidrv.c b/drivers/isdn/capi/capidrv.c index 650120261abf..3e6d17f42a98 100644 --- a/drivers/isdn/capi/capidrv.c +++ b/drivers/isdn/capi/capidrv.c | |||
@@ -40,7 +40,7 @@ static int debugmode = 0; | |||
40 | MODULE_DESCRIPTION("CAPI4Linux: Interface to ISDN4Linux"); | 40 | MODULE_DESCRIPTION("CAPI4Linux: Interface to ISDN4Linux"); |
41 | MODULE_AUTHOR("Carsten Paeth"); | 41 | MODULE_AUTHOR("Carsten Paeth"); |
42 | MODULE_LICENSE("GPL"); | 42 | MODULE_LICENSE("GPL"); |
43 | module_param(debugmode, uint, 0); | 43 | module_param(debugmode, uint, S_IRUGO|S_IWUSR); |
44 | 44 | ||
45 | /* -------- type definitions ----------------------------------------- */ | 45 | /* -------- type definitions ----------------------------------------- */ |
46 | 46 | ||
@@ -671,8 +671,8 @@ static void n0(capidrv_contr * card, capidrv_ncci * ncci) | |||
671 | NULL, /* Useruserdata */ /* $$$$ */ | 671 | NULL, /* Useruserdata */ /* $$$$ */ |
672 | NULL /* Facilitydataarray */ | 672 | NULL /* Facilitydataarray */ |
673 | ); | 673 | ); |
674 | send_message(card, &cmsg); | ||
675 | plci_change_state(card, ncci->plcip, EV_PLCI_DISCONNECT_REQ); | 674 | plci_change_state(card, ncci->plcip, EV_PLCI_DISCONNECT_REQ); |
675 | send_message(card, &cmsg); | ||
676 | 676 | ||
677 | cmd.command = ISDN_STAT_BHUP; | 677 | cmd.command = ISDN_STAT_BHUP; |
678 | cmd.driver = card->myid; | 678 | cmd.driver = card->myid; |
@@ -924,8 +924,8 @@ static void handle_incoming_call(capidrv_contr * card, _cmsg * cmsg) | |||
924 | */ | 924 | */ |
925 | capi_cmsg_answer(cmsg); | 925 | capi_cmsg_answer(cmsg); |
926 | cmsg->Reject = 1; /* ignore */ | 926 | cmsg->Reject = 1; /* ignore */ |
927 | send_message(card, cmsg); | ||
928 | plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT); | 927 | plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT); |
928 | send_message(card, cmsg); | ||
929 | printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s ignored\n", | 929 | printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s ignored\n", |
930 | card->contrnr, | 930 | card->contrnr, |
931 | cmd.parm.setup.phone, | 931 | cmd.parm.setup.phone, |
@@ -974,8 +974,8 @@ static void handle_incoming_call(capidrv_contr * card, _cmsg * cmsg) | |||
974 | case 2: /* Call will be rejected. */ | 974 | case 2: /* Call will be rejected. */ |
975 | capi_cmsg_answer(cmsg); | 975 | capi_cmsg_answer(cmsg); |
976 | cmsg->Reject = 2; /* reject call, normal call clearing */ | 976 | cmsg->Reject = 2; /* reject call, normal call clearing */ |
977 | send_message(card, cmsg); | ||
978 | plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT); | 977 | plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT); |
978 | send_message(card, cmsg); | ||
979 | break; | 979 | break; |
980 | 980 | ||
981 | default: | 981 | default: |
@@ -983,8 +983,8 @@ static void handle_incoming_call(capidrv_contr * card, _cmsg * cmsg) | |||
983 | capi_cmsg_answer(cmsg); | 983 | capi_cmsg_answer(cmsg); |
984 | cmsg->Reject = 8; /* reject call, | 984 | cmsg->Reject = 8; /* reject call, |
985 | destination out of order */ | 985 | destination out of order */ |
986 | send_message(card, cmsg); | ||
987 | plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT); | 986 | plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT); |
987 | send_message(card, cmsg); | ||
988 | break; | 988 | break; |
989 | } | 989 | } |
990 | return; | 990 | return; |
@@ -1020,8 +1020,8 @@ static void handle_plci(_cmsg * cmsg) | |||
1020 | card->bchans[plcip->chan].disconnecting = 1; | 1020 | card->bchans[plcip->chan].disconnecting = 1; |
1021 | plci_change_state(card, plcip, EV_PLCI_DISCONNECT_IND); | 1021 | plci_change_state(card, plcip, EV_PLCI_DISCONNECT_IND); |
1022 | capi_cmsg_answer(cmsg); | 1022 | capi_cmsg_answer(cmsg); |
1023 | send_message(card, cmsg); | ||
1024 | plci_change_state(card, plcip, EV_PLCI_DISCONNECT_RESP); | 1023 | plci_change_state(card, plcip, EV_PLCI_DISCONNECT_RESP); |
1024 | send_message(card, cmsg); | ||
1025 | break; | 1025 | break; |
1026 | 1026 | ||
1027 | case CAPI_DISCONNECT_CONF: /* plci */ | 1027 | case CAPI_DISCONNECT_CONF: /* plci */ |
@@ -1078,8 +1078,8 @@ static void handle_plci(_cmsg * cmsg) | |||
1078 | 1078 | ||
1079 | if (card->bchans[plcip->chan].incoming) { | 1079 | if (card->bchans[plcip->chan].incoming) { |
1080 | capi_cmsg_answer(cmsg); | 1080 | capi_cmsg_answer(cmsg); |
1081 | send_message(card, cmsg); | ||
1082 | plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND); | 1081 | plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND); |
1082 | send_message(card, cmsg); | ||
1083 | } else { | 1083 | } else { |
1084 | capidrv_ncci *nccip; | 1084 | capidrv_ncci *nccip; |
1085 | capi_cmsg_answer(cmsg); | 1085 | capi_cmsg_answer(cmsg); |
@@ -1098,13 +1098,14 @@ static void handle_plci(_cmsg * cmsg) | |||
1098 | NULL /* NCPI */ | 1098 | NULL /* NCPI */ |
1099 | ); | 1099 | ); |
1100 | nccip->msgid = cmsg->Messagenumber; | 1100 | nccip->msgid = cmsg->Messagenumber; |
1101 | plci_change_state(card, plcip, | ||
1102 | EV_PLCI_CONNECT_ACTIVE_IND); | ||
1103 | ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_REQ); | ||
1101 | send_message(card, cmsg); | 1104 | send_message(card, cmsg); |
1102 | cmd.command = ISDN_STAT_DCONN; | 1105 | cmd.command = ISDN_STAT_DCONN; |
1103 | cmd.driver = card->myid; | 1106 | cmd.driver = card->myid; |
1104 | cmd.arg = plcip->chan; | 1107 | cmd.arg = plcip->chan; |
1105 | card->interface.statcallb(&cmd); | 1108 | card->interface.statcallb(&cmd); |
1106 | plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND); | ||
1107 | ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_REQ); | ||
1108 | } | 1109 | } |
1109 | break; | 1110 | break; |
1110 | 1111 | ||
@@ -1193,8 +1194,8 @@ static void handle_ncci(_cmsg * cmsg) | |||
1193 | goto notfound; | 1194 | goto notfound; |
1194 | 1195 | ||
1195 | capi_cmsg_answer(cmsg); | 1196 | capi_cmsg_answer(cmsg); |
1196 | send_message(card, cmsg); | ||
1197 | ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_ACTIVE_IND); | 1197 | ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_ACTIVE_IND); |
1198 | send_message(card, cmsg); | ||
1198 | 1199 | ||
1199 | cmd.command = ISDN_STAT_BCONN; | 1200 | cmd.command = ISDN_STAT_BCONN; |
1200 | cmd.driver = card->myid; | 1201 | cmd.driver = card->myid; |
@@ -1222,8 +1223,8 @@ static void handle_ncci(_cmsg * cmsg) | |||
1222 | 0, /* Reject */ | 1223 | 0, /* Reject */ |
1223 | NULL /* NCPI */ | 1224 | NULL /* NCPI */ |
1224 | ); | 1225 | ); |
1225 | send_message(card, cmsg); | ||
1226 | ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_RESP); | 1226 | ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_RESP); |
1227 | send_message(card, cmsg); | ||
1227 | break; | 1228 | break; |
1228 | } | 1229 | } |
1229 | printk(KERN_ERR "capidrv-%d: no mem for ncci, sorry\n", card->contrnr); | 1230 | printk(KERN_ERR "capidrv-%d: no mem for ncci, sorry\n", card->contrnr); |
@@ -1299,8 +1300,8 @@ static void handle_ncci(_cmsg * cmsg) | |||
1299 | card->bchans[nccip->chan].disconnecting = 1; | 1300 | card->bchans[nccip->chan].disconnecting = 1; |
1300 | ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_IND); | 1301 | ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_IND); |
1301 | capi_cmsg_answer(cmsg); | 1302 | capi_cmsg_answer(cmsg); |
1302 | send_message(card, cmsg); | ||
1303 | ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_RESP); | 1303 | ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_RESP); |
1304 | send_message(card, cmsg); | ||
1304 | break; | 1305 | break; |
1305 | 1306 | ||
1306 | case CAPI_DISCONNECT_B3_CONF: /* ncci */ | 1307 | case CAPI_DISCONNECT_B3_CONF: /* ncci */ |
@@ -2014,8 +2015,8 @@ static void send_listen(capidrv_contr *card) | |||
2014 | card->cipmask, | 2015 | card->cipmask, |
2015 | card->cipmask2, | 2016 | card->cipmask2, |
2016 | NULL, NULL); | 2017 | NULL, NULL); |
2017 | send_message(card, &cmdcmsg); | ||
2018 | listen_change_state(card, EV_LISTEN_REQ); | 2018 | listen_change_state(card, EV_LISTEN_REQ); |
2019 | send_message(card, &cmdcmsg); | ||
2019 | } | 2020 | } |
2020 | 2021 | ||
2021 | static void listentimerfunc(unsigned long x) | 2022 | static void listentimerfunc(unsigned long x) |
diff --git a/drivers/isdn/divert/divert_procfs.c b/drivers/isdn/divert/divert_procfs.c index 8b256a617c8a..3697c409bec6 100644 --- a/drivers/isdn/divert/divert_procfs.c +++ b/drivers/isdn/divert/divert_procfs.c | |||
@@ -16,6 +16,7 @@ | |||
16 | #else | 16 | #else |
17 | #include <linux/fs.h> | 17 | #include <linux/fs.h> |
18 | #endif | 18 | #endif |
19 | #include <linux/sched.h> | ||
19 | #include <linux/isdnif.h> | 20 | #include <linux/isdnif.h> |
20 | #include <net/net_namespace.h> | 21 | #include <net/net_namespace.h> |
21 | #include "isdn_divert.h" | 22 | #include "isdn_divert.h" |
diff --git a/drivers/isdn/gigaset/asyncdata.c b/drivers/isdn/gigaset/asyncdata.c index 234cc5d53312..44a58e6f8f65 100644 --- a/drivers/isdn/gigaset/asyncdata.c +++ b/drivers/isdn/gigaset/asyncdata.c | |||
@@ -334,7 +334,14 @@ static inline int iraw_loop(unsigned char c, unsigned char *src, int numbytes, | |||
334 | return startbytes - numbytes; | 334 | return startbytes - numbytes; |
335 | } | 335 | } |
336 | 336 | ||
337 | /* process a block of data received from the device | 337 | /** |
338 | * gigaset_m10x_input() - process a block of data received from the device | ||
339 | * @inbuf: received data and device descriptor structure. | ||
340 | * | ||
341 | * Called by hardware module {ser,usb}_gigaset with a block of received | ||
342 | * bytes. Separates the bytes received over the serial data channel into | ||
343 | * user data and command replies (locked/unlocked) according to the | ||
344 | * current state of the interface. | ||
338 | */ | 345 | */ |
339 | void gigaset_m10x_input(struct inbuf_t *inbuf) | 346 | void gigaset_m10x_input(struct inbuf_t *inbuf) |
340 | { | 347 | { |
@@ -543,16 +550,17 @@ static struct sk_buff *iraw_encode(struct sk_buff *skb, int head, int tail) | |||
543 | return iraw_skb; | 550 | return iraw_skb; |
544 | } | 551 | } |
545 | 552 | ||
546 | /* gigaset_send_skb | 553 | /** |
547 | * called by common.c to queue an skb for sending | 554 | * gigaset_m10x_send_skb() - queue an skb for sending |
548 | * and start transmission if necessary | 555 | * @bcs: B channel descriptor structure. |
549 | * parameters: | 556 | * @skb: data to send. |
550 | * B Channel control structure | 557 | * |
551 | * skb | 558 | * Called by i4l.c to encode and queue an skb for sending, and start |
559 | * transmission if necessary. | ||
560 | * | ||
552 | * Return value: | 561 | * Return value: |
553 | * number of bytes accepted for sending | 562 | * number of bytes accepted for sending (skb->len) if ok, |
554 | * (skb->len if ok, 0 if out of buffer space) | 563 | * error code < 0 (eg. -ENOMEM) on error |
555 | * or error code (< 0, eg. -EINVAL) | ||
556 | */ | 564 | */ |
557 | int gigaset_m10x_send_skb(struct bc_state *bcs, struct sk_buff *skb) | 565 | int gigaset_m10x_send_skb(struct bc_state *bcs, struct sk_buff *skb) |
558 | { | 566 | { |
diff --git a/drivers/isdn/gigaset/bas-gigaset.c b/drivers/isdn/gigaset/bas-gigaset.c index 781c4041f7b0..5ed1d99eb9f3 100644 --- a/drivers/isdn/gigaset/bas-gigaset.c +++ b/drivers/isdn/gigaset/bas-gigaset.c | |||
@@ -134,6 +134,7 @@ struct bas_cardstate { | |||
134 | #define BS_ATRDPEND 0x040 /* urb_cmd_in in use */ | 134 | #define BS_ATRDPEND 0x040 /* urb_cmd_in in use */ |
135 | #define BS_ATWRPEND 0x080 /* urb_cmd_out in use */ | 135 | #define BS_ATWRPEND 0x080 /* urb_cmd_out in use */ |
136 | #define BS_SUSPEND 0x100 /* USB port suspended */ | 136 | #define BS_SUSPEND 0x100 /* USB port suspended */ |
137 | #define BS_RESETTING 0x200 /* waiting for HD_RESET_INTERRUPT_PIPE_ACK */ | ||
137 | 138 | ||
138 | 139 | ||
139 | static struct gigaset_driver *driver = NULL; | 140 | static struct gigaset_driver *driver = NULL; |
@@ -319,6 +320,21 @@ static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag) | |||
319 | return -EINVAL; | 320 | return -EINVAL; |
320 | } | 321 | } |
321 | 322 | ||
323 | /* set/clear bits in base connection state, return previous state | ||
324 | */ | ||
325 | static inline int update_basstate(struct bas_cardstate *ucs, | ||
326 | int set, int clear) | ||
327 | { | ||
328 | unsigned long flags; | ||
329 | int state; | ||
330 | |||
331 | spin_lock_irqsave(&ucs->lock, flags); | ||
332 | state = ucs->basstate; | ||
333 | ucs->basstate = (state & ~clear) | set; | ||
334 | spin_unlock_irqrestore(&ucs->lock, flags); | ||
335 | return state; | ||
336 | } | ||
337 | |||
322 | /* error_hangup | 338 | /* error_hangup |
323 | * hang up any existing connection because of an unrecoverable error | 339 | * hang up any existing connection because of an unrecoverable error |
324 | * This function may be called from any context and takes care of scheduling | 340 | * This function may be called from any context and takes care of scheduling |
@@ -350,12 +366,9 @@ static inline void error_hangup(struct bc_state *bcs) | |||
350 | */ | 366 | */ |
351 | static inline void error_reset(struct cardstate *cs) | 367 | static inline void error_reset(struct cardstate *cs) |
352 | { | 368 | { |
353 | /* close AT command channel to recover (ignore errors) */ | 369 | /* reset interrupt pipe to recover (ignore errors) */ |
354 | req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT); | 370 | update_basstate(cs->hw.bas, BS_RESETTING, 0); |
355 | 371 | req_submit(cs->bcs, HD_RESET_INTERRUPT_PIPE, 0, BAS_TIMEOUT); | |
356 | //FIXME try to recover without bothering the user | ||
357 | dev_err(cs->dev, | ||
358 | "unrecoverable error - please disconnect Gigaset base to reset\n"); | ||
359 | } | 372 | } |
360 | 373 | ||
361 | /* check_pending | 374 | /* check_pending |
@@ -398,8 +411,13 @@ static void check_pending(struct bas_cardstate *ucs) | |||
398 | case HD_DEVICE_INIT_ACK: /* no reply expected */ | 411 | case HD_DEVICE_INIT_ACK: /* no reply expected */ |
399 | ucs->pending = 0; | 412 | ucs->pending = 0; |
400 | break; | 413 | break; |
401 | /* HD_READ_ATMESSAGE, HD_WRITE_ATMESSAGE, HD_RESET_INTERRUPTPIPE | 414 | case HD_RESET_INTERRUPT_PIPE: |
402 | * are handled separately and should never end up here | 415 | if (!(ucs->basstate & BS_RESETTING)) |
416 | ucs->pending = 0; | ||
417 | break; | ||
418 | /* | ||
419 | * HD_READ_ATMESSAGE and HD_WRITE_ATMESSAGE are handled separately | ||
420 | * and should never end up here | ||
403 | */ | 421 | */ |
404 | default: | 422 | default: |
405 | dev_warn(&ucs->interface->dev, | 423 | dev_warn(&ucs->interface->dev, |
@@ -449,21 +467,6 @@ static void cmd_in_timeout(unsigned long data) | |||
449 | error_reset(cs); | 467 | error_reset(cs); |
450 | } | 468 | } |
451 | 469 | ||
452 | /* set/clear bits in base connection state, return previous state | ||
453 | */ | ||
454 | inline static int update_basstate(struct bas_cardstate *ucs, | ||
455 | int set, int clear) | ||
456 | { | ||
457 | unsigned long flags; | ||
458 | int state; | ||
459 | |||
460 | spin_lock_irqsave(&ucs->lock, flags); | ||
461 | state = ucs->basstate; | ||
462 | ucs->basstate = (state & ~clear) | set; | ||
463 | spin_unlock_irqrestore(&ucs->lock, flags); | ||
464 | return state; | ||
465 | } | ||
466 | |||
467 | /* read_ctrl_callback | 470 | /* read_ctrl_callback |
468 | * USB completion handler for control pipe input | 471 | * USB completion handler for control pipe input |
469 | * called by the USB subsystem in interrupt context | 472 | * called by the USB subsystem in interrupt context |
@@ -762,7 +765,8 @@ static void read_int_callback(struct urb *urb) | |||
762 | break; | 765 | break; |
763 | 766 | ||
764 | case HD_RESET_INTERRUPT_PIPE_ACK: | 767 | case HD_RESET_INTERRUPT_PIPE_ACK: |
765 | gig_dbg(DEBUG_USBREQ, "HD_RESET_INTERRUPT_PIPE_ACK"); | 768 | update_basstate(ucs, 0, BS_RESETTING); |
769 | dev_notice(cs->dev, "interrupt pipe reset\n"); | ||
766 | break; | 770 | break; |
767 | 771 | ||
768 | case HD_SUSPEND_END: | 772 | case HD_SUSPEND_END: |
@@ -1331,28 +1335,24 @@ static void read_iso_tasklet(unsigned long data) | |||
1331 | rcvbuf = urb->transfer_buffer; | 1335 | rcvbuf = urb->transfer_buffer; |
1332 | totleft = urb->actual_length; | 1336 | totleft = urb->actual_length; |
1333 | for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) { | 1337 | for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) { |
1334 | if (unlikely(urb->iso_frame_desc[frame].status)) { | 1338 | numbytes = urb->iso_frame_desc[frame].actual_length; |
1339 | if (unlikely(urb->iso_frame_desc[frame].status)) | ||
1335 | dev_warn(cs->dev, | 1340 | dev_warn(cs->dev, |
1336 | "isochronous read: frame %d: %s\n", | 1341 | "isochronous read: frame %d[%d]: %s\n", |
1337 | frame, | 1342 | frame, numbytes, |
1338 | get_usb_statmsg( | 1343 | get_usb_statmsg( |
1339 | urb->iso_frame_desc[frame].status)); | 1344 | urb->iso_frame_desc[frame].status)); |
1340 | break; | 1345 | if (unlikely(numbytes > BAS_MAXFRAME)) |
1341 | } | ||
1342 | numbytes = urb->iso_frame_desc[frame].actual_length; | ||
1343 | if (unlikely(numbytes > BAS_MAXFRAME)) { | ||
1344 | dev_warn(cs->dev, | 1346 | dev_warn(cs->dev, |
1345 | "isochronous read: frame %d: " | 1347 | "isochronous read: frame %d: " |
1346 | "numbytes (%d) > BAS_MAXFRAME\n", | 1348 | "numbytes (%d) > BAS_MAXFRAME\n", |
1347 | frame, numbytes); | 1349 | frame, numbytes); |
1348 | break; | ||
1349 | } | ||
1350 | if (unlikely(numbytes > totleft)) { | 1350 | if (unlikely(numbytes > totleft)) { |
1351 | dev_warn(cs->dev, | 1351 | dev_warn(cs->dev, |
1352 | "isochronous read: frame %d: " | 1352 | "isochronous read: frame %d: " |
1353 | "numbytes (%d) > totleft (%d)\n", | 1353 | "numbytes (%d) > totleft (%d)\n", |
1354 | frame, numbytes, totleft); | 1354 | frame, numbytes, totleft); |
1355 | break; | 1355 | numbytes = totleft; |
1356 | } | 1356 | } |
1357 | offset = urb->iso_frame_desc[frame].offset; | 1357 | offset = urb->iso_frame_desc[frame].offset; |
1358 | if (unlikely(offset + numbytes > BAS_INBUFSIZE)) { | 1358 | if (unlikely(offset + numbytes > BAS_INBUFSIZE)) { |
@@ -1361,7 +1361,7 @@ static void read_iso_tasklet(unsigned long data) | |||
1361 | "offset (%d) + numbytes (%d) " | 1361 | "offset (%d) + numbytes (%d) " |
1362 | "> BAS_INBUFSIZE\n", | 1362 | "> BAS_INBUFSIZE\n", |
1363 | frame, offset, numbytes); | 1363 | frame, offset, numbytes); |
1364 | break; | 1364 | numbytes = BAS_INBUFSIZE - offset; |
1365 | } | 1365 | } |
1366 | gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs); | 1366 | gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs); |
1367 | totleft -= numbytes; | 1367 | totleft -= numbytes; |
@@ -1433,6 +1433,7 @@ static void req_timeout(unsigned long data) | |||
1433 | 1433 | ||
1434 | case HD_CLOSE_ATCHANNEL: | 1434 | case HD_CLOSE_ATCHANNEL: |
1435 | dev_err(bcs->cs->dev, "timeout closing AT channel\n"); | 1435 | dev_err(bcs->cs->dev, "timeout closing AT channel\n"); |
1436 | error_reset(bcs->cs); | ||
1436 | break; | 1437 | break; |
1437 | 1438 | ||
1438 | case HD_CLOSE_B2CHANNEL: | 1439 | case HD_CLOSE_B2CHANNEL: |
@@ -1442,6 +1443,13 @@ static void req_timeout(unsigned long data) | |||
1442 | error_reset(bcs->cs); | 1443 | error_reset(bcs->cs); |
1443 | break; | 1444 | break; |
1444 | 1445 | ||
1446 | case HD_RESET_INTERRUPT_PIPE: | ||
1447 | /* error recovery escalation */ | ||
1448 | dev_err(bcs->cs->dev, | ||
1449 | "reset interrupt pipe timeout, attempting USB reset\n"); | ||
1450 | usb_queue_reset_device(bcs->cs->hw.bas->interface); | ||
1451 | break; | ||
1452 | |||
1445 | default: | 1453 | default: |
1446 | dev_warn(bcs->cs->dev, "request 0x%02x timed out, clearing\n", | 1454 | dev_warn(bcs->cs->dev, "request 0x%02x timed out, clearing\n", |
1447 | pending); | 1455 | pending); |
@@ -1934,6 +1942,15 @@ static int gigaset_write_cmd(struct cardstate *cs, | |||
1934 | goto notqueued; | 1942 | goto notqueued; |
1935 | } | 1943 | } |
1936 | 1944 | ||
1945 | /* translate "+++" escape sequence sent as a single separate command | ||
1946 | * into "close AT channel" command for error recovery | ||
1947 | * The next command will reopen the AT channel automatically. | ||
1948 | */ | ||
1949 | if (len == 3 && !memcmp(buf, "+++", 3)) { | ||
1950 | rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT); | ||
1951 | goto notqueued; | ||
1952 | } | ||
1953 | |||
1937 | if (len > IF_WRITEBUF) | 1954 | if (len > IF_WRITEBUF) |
1938 | len = IF_WRITEBUF; | 1955 | len = IF_WRITEBUF; |
1939 | if (!(cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC))) { | 1956 | if (!(cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC))) { |
diff --git a/drivers/isdn/gigaset/common.c b/drivers/isdn/gigaset/common.c index e4141bf8b2f3..33dcd8d72b7c 100644 --- a/drivers/isdn/gigaset/common.c +++ b/drivers/isdn/gigaset/common.c | |||
@@ -22,6 +22,12 @@ | |||
22 | #define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Tilman Schmidt <tilman@imap.cc>, Stefan Eilers" | 22 | #define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Tilman Schmidt <tilman@imap.cc>, Stefan Eilers" |
23 | #define DRIVER_DESC "Driver for Gigaset 307x" | 23 | #define DRIVER_DESC "Driver for Gigaset 307x" |
24 | 24 | ||
25 | #ifdef CONFIG_GIGASET_DEBUG | ||
26 | #define DRIVER_DESC_DEBUG " (debug build)" | ||
27 | #else | ||
28 | #define DRIVER_DESC_DEBUG "" | ||
29 | #endif | ||
30 | |||
25 | /* Module parameters */ | 31 | /* Module parameters */ |
26 | int gigaset_debuglevel = DEBUG_DEFAULT; | 32 | int gigaset_debuglevel = DEBUG_DEFAULT; |
27 | EXPORT_SYMBOL_GPL(gigaset_debuglevel); | 33 | EXPORT_SYMBOL_GPL(gigaset_debuglevel); |
@@ -32,6 +38,17 @@ MODULE_PARM_DESC(debug, "debug level"); | |||
32 | #define VALID_MINOR 0x01 | 38 | #define VALID_MINOR 0x01 |
33 | #define VALID_ID 0x02 | 39 | #define VALID_ID 0x02 |
34 | 40 | ||
41 | /** | ||
42 | * gigaset_dbg_buffer() - dump data in ASCII and hex for debugging | ||
43 | * @level: debugging level. | ||
44 | * @msg: message prefix. | ||
45 | * @len: number of bytes to dump. | ||
46 | * @buf: data to dump. | ||
47 | * | ||
48 | * If the current debugging level includes one of the bits set in @level, | ||
49 | * @len bytes starting at @buf are logged to dmesg at KERN_DEBUG prio, | ||
50 | * prefixed by the text @msg. | ||
51 | */ | ||
35 | void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg, | 52 | void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg, |
36 | size_t len, const unsigned char *buf) | 53 | size_t len, const unsigned char *buf) |
37 | { | 54 | { |
@@ -274,6 +291,20 @@ static void clear_events(struct cardstate *cs) | |||
274 | spin_unlock_irqrestore(&cs->ev_lock, flags); | 291 | spin_unlock_irqrestore(&cs->ev_lock, flags); |
275 | } | 292 | } |
276 | 293 | ||
294 | /** | ||
295 | * gigaset_add_event() - add event to device event queue | ||
296 | * @cs: device descriptor structure. | ||
297 | * @at_state: connection state structure. | ||
298 | * @type: event type. | ||
299 | * @ptr: pointer parameter for event. | ||
300 | * @parameter: integer parameter for event. | ||
301 | * @arg: pointer parameter for event. | ||
302 | * | ||
303 | * Allocate an event queue entry from the device's event queue, and set it up | ||
304 | * with the parameters given. | ||
305 | * | ||
306 | * Return value: added event | ||
307 | */ | ||
277 | struct event_t *gigaset_add_event(struct cardstate *cs, | 308 | struct event_t *gigaset_add_event(struct cardstate *cs, |
278 | struct at_state_t *at_state, int type, | 309 | struct at_state_t *at_state, int type, |
279 | void *ptr, int parameter, void *arg) | 310 | void *ptr, int parameter, void *arg) |
@@ -398,6 +429,15 @@ static void make_invalid(struct cardstate *cs, unsigned mask) | |||
398 | spin_unlock_irqrestore(&drv->lock, flags); | 429 | spin_unlock_irqrestore(&drv->lock, flags); |
399 | } | 430 | } |
400 | 431 | ||
432 | /** | ||
433 | * gigaset_freecs() - free all associated ressources of a device | ||
434 | * @cs: device descriptor structure. | ||
435 | * | ||
436 | * Stops all tasklets and timers, unregisters the device from all | ||
437 | * subsystems it was registered to, deallocates the device structure | ||
438 | * @cs and all structures referenced from it. | ||
439 | * Operations on the device should be stopped before calling this. | ||
440 | */ | ||
401 | void gigaset_freecs(struct cardstate *cs) | 441 | void gigaset_freecs(struct cardstate *cs) |
402 | { | 442 | { |
403 | int i; | 443 | int i; |
@@ -506,7 +546,12 @@ static void gigaset_inbuf_init(struct inbuf_t *inbuf, struct bc_state *bcs, | |||
506 | inbuf->inputstate = inputstate; | 546 | inbuf->inputstate = inputstate; |
507 | } | 547 | } |
508 | 548 | ||
509 | /* append received bytes to inbuf */ | 549 | /** |
550 | * gigaset_fill_inbuf() - append received data to input buffer | ||
551 | * @inbuf: buffer structure. | ||
552 | * @src: received data. | ||
553 | * @numbytes: number of bytes received. | ||
554 | */ | ||
510 | int gigaset_fill_inbuf(struct inbuf_t *inbuf, const unsigned char *src, | 555 | int gigaset_fill_inbuf(struct inbuf_t *inbuf, const unsigned char *src, |
511 | unsigned numbytes) | 556 | unsigned numbytes) |
512 | { | 557 | { |
@@ -606,20 +651,22 @@ static struct bc_state *gigaset_initbcs(struct bc_state *bcs, | |||
606 | return NULL; | 651 | return NULL; |
607 | } | 652 | } |
608 | 653 | ||
609 | /* gigaset_initcs | 654 | /** |
655 | * gigaset_initcs() - initialize device structure | ||
656 | * @drv: hardware driver the device belongs to | ||
657 | * @channels: number of B channels supported by device | ||
658 | * @onechannel: !=0 if B channel data and AT commands share one | ||
659 | * communication channel (M10x), | ||
660 | * ==0 if B channels have separate communication channels (base) | ||
661 | * @ignoreframes: number of frames to ignore after setting up B channel | ||
662 | * @cidmode: !=0: start in CallID mode | ||
663 | * @modulename: name of driver module for LL registration | ||
664 | * | ||
610 | * Allocate and initialize cardstate structure for Gigaset driver | 665 | * Allocate and initialize cardstate structure for Gigaset driver |
611 | * Calls hardware dependent gigaset_initcshw() function | 666 | * Calls hardware dependent gigaset_initcshw() function |
612 | * Calls B channel initialization function gigaset_initbcs() for each B channel | 667 | * Calls B channel initialization function gigaset_initbcs() for each B channel |
613 | * parameters: | 668 | * |
614 | * drv hardware driver the device belongs to | 669 | * Return value: |
615 | * channels number of B channels supported by device | ||
616 | * onechannel !=0: B channel data and AT commands share one | ||
617 | * communication channel | ||
618 | * ==0: B channels have separate communication channels | ||
619 | * ignoreframes number of frames to ignore after setting up B channel | ||
620 | * cidmode !=0: start in CallID mode | ||
621 | * modulename name of driver module (used for I4L registration) | ||
622 | * return value: | ||
623 | * pointer to cardstate structure | 670 | * pointer to cardstate structure |
624 | */ | 671 | */ |
625 | struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels, | 672 | struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels, |
@@ -837,6 +884,17 @@ static void cleanup_cs(struct cardstate *cs) | |||
837 | } | 884 | } |
838 | 885 | ||
839 | 886 | ||
887 | /** | ||
888 | * gigaset_start() - start device operations | ||
889 | * @cs: device descriptor structure. | ||
890 | * | ||
891 | * Prepares the device for use by setting up communication parameters, | ||
892 | * scheduling an EV_START event to initiate device initialization, and | ||
893 | * waiting for completion of the initialization. | ||
894 | * | ||
895 | * Return value: | ||
896 | * 1 - success, 0 - error | ||
897 | */ | ||
840 | int gigaset_start(struct cardstate *cs) | 898 | int gigaset_start(struct cardstate *cs) |
841 | { | 899 | { |
842 | unsigned long flags; | 900 | unsigned long flags; |
@@ -879,9 +937,15 @@ error: | |||
879 | } | 937 | } |
880 | EXPORT_SYMBOL_GPL(gigaset_start); | 938 | EXPORT_SYMBOL_GPL(gigaset_start); |
881 | 939 | ||
882 | /* gigaset_shutdown | 940 | /** |
883 | * check if a device is associated to the cardstate structure and stop it | 941 | * gigaset_shutdown() - shut down device operations |
884 | * return value: 0 if ok, -1 if no device was associated | 942 | * @cs: device descriptor structure. |
943 | * | ||
944 | * Deactivates the device by scheduling an EV_SHUTDOWN event and | ||
945 | * waiting for completion of the shutdown. | ||
946 | * | ||
947 | * Return value: | ||
948 | * 0 - success, -1 - error (no device associated) | ||
885 | */ | 949 | */ |
886 | int gigaset_shutdown(struct cardstate *cs) | 950 | int gigaset_shutdown(struct cardstate *cs) |
887 | { | 951 | { |
@@ -912,6 +976,13 @@ exit: | |||
912 | } | 976 | } |
913 | EXPORT_SYMBOL_GPL(gigaset_shutdown); | 977 | EXPORT_SYMBOL_GPL(gigaset_shutdown); |
914 | 978 | ||
979 | /** | ||
980 | * gigaset_stop() - stop device operations | ||
981 | * @cs: device descriptor structure. | ||
982 | * | ||
983 | * Stops operations on the device by scheduling an EV_STOP event and | ||
984 | * waiting for completion of the shutdown. | ||
985 | */ | ||
915 | void gigaset_stop(struct cardstate *cs) | 986 | void gigaset_stop(struct cardstate *cs) |
916 | { | 987 | { |
917 | mutex_lock(&cs->mutex); | 988 | mutex_lock(&cs->mutex); |
@@ -1020,6 +1091,14 @@ struct cardstate *gigaset_get_cs_by_tty(struct tty_struct *tty) | |||
1020 | return gigaset_get_cs_by_minor(tty->index + tty->driver->minor_start); | 1091 | return gigaset_get_cs_by_minor(tty->index + tty->driver->minor_start); |
1021 | } | 1092 | } |
1022 | 1093 | ||
1094 | /** | ||
1095 | * gigaset_freedriver() - free all associated ressources of a driver | ||
1096 | * @drv: driver descriptor structure. | ||
1097 | * | ||
1098 | * Unregisters the driver from the system and deallocates the driver | ||
1099 | * structure @drv and all structures referenced from it. | ||
1100 | * All devices should be shut down before calling this. | ||
1101 | */ | ||
1023 | void gigaset_freedriver(struct gigaset_driver *drv) | 1102 | void gigaset_freedriver(struct gigaset_driver *drv) |
1024 | { | 1103 | { |
1025 | unsigned long flags; | 1104 | unsigned long flags; |
@@ -1035,14 +1114,16 @@ void gigaset_freedriver(struct gigaset_driver *drv) | |||
1035 | } | 1114 | } |
1036 | EXPORT_SYMBOL_GPL(gigaset_freedriver); | 1115 | EXPORT_SYMBOL_GPL(gigaset_freedriver); |
1037 | 1116 | ||
1038 | /* gigaset_initdriver | 1117 | /** |
1118 | * gigaset_initdriver() - initialize driver structure | ||
1119 | * @minor: First minor number | ||
1120 | * @minors: Number of minors this driver can handle | ||
1121 | * @procname: Name of the driver | ||
1122 | * @devname: Name of the device files (prefix without minor number) | ||
1123 | * | ||
1039 | * Allocate and initialize gigaset_driver structure. Initialize interface. | 1124 | * Allocate and initialize gigaset_driver structure. Initialize interface. |
1040 | * parameters: | 1125 | * |
1041 | * minor First minor number | 1126 | * Return value: |
1042 | * minors Number of minors this driver can handle | ||
1043 | * procname Name of the driver | ||
1044 | * devname Name of the device files (prefix without minor number) | ||
1045 | * return value: | ||
1046 | * Pointer to the gigaset_driver structure on success, NULL on failure. | 1127 | * Pointer to the gigaset_driver structure on success, NULL on failure. |
1047 | */ | 1128 | */ |
1048 | struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors, | 1129 | struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors, |
@@ -1095,6 +1176,13 @@ error: | |||
1095 | } | 1176 | } |
1096 | EXPORT_SYMBOL_GPL(gigaset_initdriver); | 1177 | EXPORT_SYMBOL_GPL(gigaset_initdriver); |
1097 | 1178 | ||
1179 | /** | ||
1180 | * gigaset_blockdriver() - block driver | ||
1181 | * @drv: driver descriptor structure. | ||
1182 | * | ||
1183 | * Prevents the driver from attaching new devices, in preparation for | ||
1184 | * deregistration. | ||
1185 | */ | ||
1098 | void gigaset_blockdriver(struct gigaset_driver *drv) | 1186 | void gigaset_blockdriver(struct gigaset_driver *drv) |
1099 | { | 1187 | { |
1100 | drv->blocked = 1; | 1188 | drv->blocked = 1; |
@@ -1110,7 +1198,7 @@ static int __init gigaset_init_module(void) | |||
1110 | if (gigaset_debuglevel == 1) | 1198 | if (gigaset_debuglevel == 1) |
1111 | gigaset_debuglevel = DEBUG_DEFAULT; | 1199 | gigaset_debuglevel = DEBUG_DEFAULT; |
1112 | 1200 | ||
1113 | pr_info(DRIVER_DESC "\n"); | 1201 | pr_info(DRIVER_DESC DRIVER_DESC_DEBUG "\n"); |
1114 | return 0; | 1202 | return 0; |
1115 | } | 1203 | } |
1116 | 1204 | ||
diff --git a/drivers/isdn/gigaset/ev-layer.c b/drivers/isdn/gigaset/ev-layer.c index 2d91049571a4..cc768caa38f5 100644 --- a/drivers/isdn/gigaset/ev-layer.c +++ b/drivers/isdn/gigaset/ev-layer.c | |||
@@ -207,7 +207,6 @@ struct reply_t gigaset_tab_nocid[] = | |||
207 | /* leave dle mode */ | 207 | /* leave dle mode */ |
208 | {RSP_INIT, 0, 0,SEQ_DLE0, 201, 5, {0}, "^SDLE=0\r"}, | 208 | {RSP_INIT, 0, 0,SEQ_DLE0, 201, 5, {0}, "^SDLE=0\r"}, |
209 | {RSP_OK, 201,201, -1, 202,-1}, | 209 | {RSP_OK, 201,201, -1, 202,-1}, |
210 | //{RSP_ZDLE, 202,202, 0, 202, 0, {ACT_ERROR}},//DELETE | ||
211 | {RSP_ZDLE, 202,202, 0, 0, 0, {ACT_DLE0}}, | 210 | {RSP_ZDLE, 202,202, 0, 0, 0, {ACT_DLE0}}, |
212 | {RSP_NODEV, 200,249, -1, 0, 0, {ACT_FAKEDLE0}}, | 211 | {RSP_NODEV, 200,249, -1, 0, 0, {ACT_FAKEDLE0}}, |
213 | {RSP_ERROR, 200,249, -1, 0, 0, {ACT_FAILDLE0}}, | 212 | {RSP_ERROR, 200,249, -1, 0, 0, {ACT_FAILDLE0}}, |
@@ -265,6 +264,7 @@ struct reply_t gigaset_tab_nocid[] = | |||
265 | {EV_SHUTDOWN, -1, -1, -1, -1,-1, {ACT_SHUTDOWN}}, //FIXME | 264 | {EV_SHUTDOWN, -1, -1, -1, -1,-1, {ACT_SHUTDOWN}}, //FIXME |
266 | 265 | ||
267 | /* misc. */ | 266 | /* misc. */ |
267 | {RSP_ERROR, -1, -1, -1, -1, -1, {ACT_ERROR} }, | ||
268 | {RSP_EMPTY, -1, -1, -1, -1,-1, {ACT_DEBUG}}, //FIXME | 268 | {RSP_EMPTY, -1, -1, -1, -1,-1, {ACT_DEBUG}}, //FIXME |
269 | {RSP_ZCFGT, -1, -1, -1, -1,-1, {ACT_DEBUG}}, //FIXME | 269 | {RSP_ZCFGT, -1, -1, -1, -1,-1, {ACT_DEBUG}}, //FIXME |
270 | {RSP_ZCFG, -1, -1, -1, -1,-1, {ACT_DEBUG}}, //FIXME | 270 | {RSP_ZCFG, -1, -1, -1, -1,-1, {ACT_DEBUG}}, //FIXME |
@@ -328,10 +328,9 @@ struct reply_t gigaset_tab_cid[] = | |||
328 | {RSP_INIT, -1, -1,SEQ_HUP, 401, 5, {0}, "+VLS=0\r"}, /* hang up */ //-1,-1? | 328 | {RSP_INIT, -1, -1,SEQ_HUP, 401, 5, {0}, "+VLS=0\r"}, /* hang up */ //-1,-1? |
329 | {RSP_OK, 401,401, -1, 402, 5}, | 329 | {RSP_OK, 401,401, -1, 402, 5}, |
330 | {RSP_ZVLS, 402,402, 0, 403, 5}, | 330 | {RSP_ZVLS, 402,402, 0, 403, 5}, |
331 | {RSP_ZSAU, 403,403,ZSAU_DISCONNECT_REQ, -1,-1, {ACT_DEBUG}}, /* if not remote hup */ | 331 | {RSP_ZSAU, 403, 403, ZSAU_DISCONNECT_REQ, -1, -1, {ACT_DEBUG} }, |
332 | //{RSP_ZSAU, 403,403,ZSAU_NULL, 401, 0, {ACT_ERROR}}, //DELETE//FIXME -> DLE0 // should we do this _before_ hanging up for base driver? | 332 | {RSP_ZSAU, 403, 403, ZSAU_NULL, 0, 0, {ACT_DISCONNECT} }, |
333 | {RSP_ZSAU, 403,403,ZSAU_NULL, 0, 0, {ACT_DISCONNECT}}, //FIXME -> DLE0 // should we do this _before_ hanging up for base driver? | 333 | {RSP_NODEV, 401, 403, -1, 0, 0, {ACT_FAKEHUP} }, |
334 | {RSP_NODEV, 401,403, -1, 0, 0, {ACT_FAKEHUP}}, //FIXME -> DLE0 // should we do this _before_ hanging up for base driver? | ||
335 | {RSP_ERROR, 401,401, -1, 0, 0, {ACT_ABORTHUP}}, | 334 | {RSP_ERROR, 401,401, -1, 0, 0, {ACT_ABORTHUP}}, |
336 | {EV_TIMEOUT, 401,403, -1, 0, 0, {ACT_ABORTHUP}}, | 335 | {EV_TIMEOUT, 401,403, -1, 0, 0, {ACT_ABORTHUP}}, |
337 | 336 | ||
@@ -474,8 +473,13 @@ static int cid_of_response(char *s) | |||
474 | //FIXME is ;<digit>+ at end of non-CID response really impossible? | 473 | //FIXME is ;<digit>+ at end of non-CID response really impossible? |
475 | } | 474 | } |
476 | 475 | ||
477 | /* This function will be called via task queue from the callback handler. | 476 | /** |
478 | * We received a modem response and have to handle it.. | 477 | * gigaset_handle_modem_response() - process received modem response |
478 | * @cs: device descriptor structure. | ||
479 | * | ||
480 | * Called by asyncdata/isocdata if a block of data received from the | ||
481 | * device must be processed as a modem command response. The data is | ||
482 | * already in the cs structure. | ||
479 | */ | 483 | */ |
480 | void gigaset_handle_modem_response(struct cardstate *cs) | 484 | void gigaset_handle_modem_response(struct cardstate *cs) |
481 | { | 485 | { |
@@ -707,6 +711,11 @@ static void disconnect(struct at_state_t **at_state_p) | |||
707 | if (bcs) { | 711 | if (bcs) { |
708 | /* B channel assigned: invoke hardware specific handler */ | 712 | /* B channel assigned: invoke hardware specific handler */ |
709 | cs->ops->close_bchannel(bcs); | 713 | cs->ops->close_bchannel(bcs); |
714 | /* notify LL */ | ||
715 | if (bcs->chstate & (CHS_D_UP | CHS_NOTIFY_LL)) { | ||
716 | bcs->chstate &= ~(CHS_D_UP | CHS_NOTIFY_LL); | ||
717 | gigaset_i4l_channel_cmd(bcs, ISDN_STAT_DHUP); | ||
718 | } | ||
710 | } else { | 719 | } else { |
711 | /* no B channel assigned: just deallocate */ | 720 | /* no B channel assigned: just deallocate */ |
712 | spin_lock_irqsave(&cs->lock, flags); | 721 | spin_lock_irqsave(&cs->lock, flags); |
@@ -1429,11 +1438,12 @@ static void do_action(int action, struct cardstate *cs, | |||
1429 | cs->gotfwver = -1; | 1438 | cs->gotfwver = -1; |
1430 | dev_err(cs->dev, "could not read firmware version.\n"); | 1439 | dev_err(cs->dev, "could not read firmware version.\n"); |
1431 | break; | 1440 | break; |
1432 | #ifdef CONFIG_GIGASET_DEBUG | ||
1433 | case ACT_ERROR: | 1441 | case ACT_ERROR: |
1434 | *p_genresp = 1; | 1442 | gig_dbg(DEBUG_ANY, "%s: ERROR response in ConState %d", |
1435 | *p_resp_code = RSP_ERROR; | 1443 | __func__, at_state->ConState); |
1444 | cs->cur_at_seq = SEQ_NONE; | ||
1436 | break; | 1445 | break; |
1446 | #ifdef CONFIG_GIGASET_DEBUG | ||
1437 | case ACT_TEST: | 1447 | case ACT_TEST: |
1438 | { | 1448 | { |
1439 | static int count = 3; //2; //1; | 1449 | static int count = 3; //2; //1; |
diff --git a/drivers/isdn/gigaset/i4l.c b/drivers/isdn/gigaset/i4l.c index 9b22f9cf2f33..654489d836cd 100644 --- a/drivers/isdn/gigaset/i4l.c +++ b/drivers/isdn/gigaset/i4l.c | |||
@@ -51,6 +51,12 @@ static int writebuf_from_LL(int driverID, int channel, int ack, | |||
51 | return -ENODEV; | 51 | return -ENODEV; |
52 | } | 52 | } |
53 | bcs = &cs->bcs[channel]; | 53 | bcs = &cs->bcs[channel]; |
54 | |||
55 | /* can only handle linear sk_buffs */ | ||
56 | if (skb_linearize(skb) < 0) { | ||
57 | dev_err(cs->dev, "%s: skb_linearize failed\n", __func__); | ||
58 | return -ENOMEM; | ||
59 | } | ||
54 | len = skb->len; | 60 | len = skb->len; |
55 | 61 | ||
56 | gig_dbg(DEBUG_LLDATA, | 62 | gig_dbg(DEBUG_LLDATA, |
@@ -79,6 +85,14 @@ static int writebuf_from_LL(int driverID, int channel, int ack, | |||
79 | return cs->ops->send_skb(bcs, skb); | 85 | return cs->ops->send_skb(bcs, skb); |
80 | } | 86 | } |
81 | 87 | ||
88 | /** | ||
89 | * gigaset_skb_sent() - acknowledge sending an skb | ||
90 | * @bcs: B channel descriptor structure. | ||
91 | * @skb: sent data. | ||
92 | * | ||
93 | * Called by hardware module {bas,ser,usb}_gigaset when the data in a | ||
94 | * skb has been successfully sent, for signalling completion to the LL. | ||
95 | */ | ||
82 | void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *skb) | 96 | void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *skb) |
83 | { | 97 | { |
84 | unsigned len; | 98 | unsigned len; |
@@ -455,6 +469,15 @@ int gigaset_isdn_setup_accept(struct at_state_t *at_state) | |||
455 | return 0; | 469 | return 0; |
456 | } | 470 | } |
457 | 471 | ||
472 | /** | ||
473 | * gigaset_isdn_icall() - signal incoming call | ||
474 | * @at_state: connection state structure. | ||
475 | * | ||
476 | * Called by main module to notify the LL that an incoming call has been | ||
477 | * received. @at_state contains the parameters of the call. | ||
478 | * | ||
479 | * Return value: call disposition (ICALL_*) | ||
480 | */ | ||
458 | int gigaset_isdn_icall(struct at_state_t *at_state) | 481 | int gigaset_isdn_icall(struct at_state_t *at_state) |
459 | { | 482 | { |
460 | struct cardstate *cs = at_state->cs; | 483 | struct cardstate *cs = at_state->cs; |
diff --git a/drivers/isdn/gigaset/interface.c b/drivers/isdn/gigaset/interface.c index f33ac27de643..6a8e1384e7bd 100644 --- a/drivers/isdn/gigaset/interface.c +++ b/drivers/isdn/gigaset/interface.c | |||
@@ -616,6 +616,15 @@ void gigaset_if_free(struct cardstate *cs) | |||
616 | tty_unregister_device(drv->tty, cs->minor_index); | 616 | tty_unregister_device(drv->tty, cs->minor_index); |
617 | } | 617 | } |
618 | 618 | ||
619 | /** | ||
620 | * gigaset_if_receive() - pass a received block of data to the tty device | ||
621 | * @cs: device descriptor structure. | ||
622 | * @buffer: received data. | ||
623 | * @len: number of bytes received. | ||
624 | * | ||
625 | * Called by asyncdata/isocdata if a block of data received from the | ||
626 | * device must be sent to userspace through the ttyG* device. | ||
627 | */ | ||
619 | void gigaset_if_receive(struct cardstate *cs, | 628 | void gigaset_if_receive(struct cardstate *cs, |
620 | unsigned char *buffer, size_t len) | 629 | unsigned char *buffer, size_t len) |
621 | { | 630 | { |
diff --git a/drivers/isdn/gigaset/isocdata.c b/drivers/isdn/gigaset/isocdata.c index bed38fcc432b..9f3ef7b4248c 100644 --- a/drivers/isdn/gigaset/isocdata.c +++ b/drivers/isdn/gigaset/isocdata.c | |||
@@ -429,7 +429,7 @@ static inline int hdlc_buildframe(struct isowbuf_t *iwb, | |||
429 | return -EAGAIN; | 429 | return -EAGAIN; |
430 | } | 430 | } |
431 | 431 | ||
432 | dump_bytes(DEBUG_STREAM, "snd data", in, count); | 432 | dump_bytes(DEBUG_STREAM_DUMP, "snd data", in, count); |
433 | 433 | ||
434 | /* bitstuff and checksum input data */ | 434 | /* bitstuff and checksum input data */ |
435 | fcs = PPP_INITFCS; | 435 | fcs = PPP_INITFCS; |
@@ -448,7 +448,6 @@ static inline int hdlc_buildframe(struct isowbuf_t *iwb, | |||
448 | /* put closing flag and repeat byte for flag idle */ | 448 | /* put closing flag and repeat byte for flag idle */ |
449 | isowbuf_putflag(iwb); | 449 | isowbuf_putflag(iwb); |
450 | end = isowbuf_donewrite(iwb); | 450 | end = isowbuf_donewrite(iwb); |
451 | dump_bytes(DEBUG_STREAM_DUMP, "isowbuf", iwb->data, end + 1); | ||
452 | return end; | 451 | return end; |
453 | } | 452 | } |
454 | 453 | ||
@@ -482,6 +481,8 @@ static inline int trans_buildframe(struct isowbuf_t *iwb, | |||
482 | } | 481 | } |
483 | 482 | ||
484 | gig_dbg(DEBUG_STREAM, "put %d bytes", count); | 483 | gig_dbg(DEBUG_STREAM, "put %d bytes", count); |
484 | dump_bytes(DEBUG_STREAM_DUMP, "snd data", in, count); | ||
485 | |||
485 | write = iwb->write; | 486 | write = iwb->write; |
486 | do { | 487 | do { |
487 | c = bitrev8(*in++); | 488 | c = bitrev8(*in++); |
@@ -583,7 +584,7 @@ static inline void hdlc_done(struct bc_state *bcs) | |||
583 | procskb->tail -= 2; | 584 | procskb->tail -= 2; |
584 | gig_dbg(DEBUG_ISO, "%s: good frame (%d octets)", | 585 | gig_dbg(DEBUG_ISO, "%s: good frame (%d octets)", |
585 | __func__, procskb->len); | 586 | __func__, procskb->len); |
586 | dump_bytes(DEBUG_STREAM, | 587 | dump_bytes(DEBUG_STREAM_DUMP, |
587 | "rcv data", procskb->data, procskb->len); | 588 | "rcv data", procskb->data, procskb->len); |
588 | bcs->hw.bas->goodbytes += procskb->len; | 589 | bcs->hw.bas->goodbytes += procskb->len; |
589 | gigaset_rcv_skb(procskb, bcs->cs, bcs); | 590 | gigaset_rcv_skb(procskb, bcs->cs, bcs); |
@@ -878,6 +879,8 @@ static inline void trans_receive(unsigned char *src, unsigned count, | |||
878 | dobytes--; | 879 | dobytes--; |
879 | } | 880 | } |
880 | if (dobytes == 0) { | 881 | if (dobytes == 0) { |
882 | dump_bytes(DEBUG_STREAM_DUMP, | ||
883 | "rcv data", skb->data, skb->len); | ||
881 | gigaset_rcv_skb(skb, bcs->cs, bcs); | 884 | gigaset_rcv_skb(skb, bcs->cs, bcs); |
882 | bcs->skb = skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN); | 885 | bcs->skb = skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN); |
883 | if (!skb) { | 886 | if (!skb) { |
@@ -973,16 +976,17 @@ void gigaset_isoc_input(struct inbuf_t *inbuf) | |||
973 | 976 | ||
974 | /* == data output ========================================================== */ | 977 | /* == data output ========================================================== */ |
975 | 978 | ||
976 | /* gigaset_send_skb | 979 | /** |
977 | * called by common.c to queue an skb for sending | 980 | * gigaset_isoc_send_skb() - queue an skb for sending |
978 | * and start transmission if necessary | 981 | * @bcs: B channel descriptor structure. |
979 | * parameters: | 982 | * @skb: data to send. |
980 | * B Channel control structure | 983 | * |
981 | * skb | 984 | * Called by i4l.c to queue an skb for sending, and start transmission if |
982 | * return value: | 985 | * necessary. |
983 | * number of bytes accepted for sending | 986 | * |
984 | * (skb->len if ok, 0 if out of buffer space) | 987 | * Return value: |
985 | * or error code (< 0, eg. -EINVAL) | 988 | * number of bytes accepted for sending (skb->len) if ok, |
989 | * error code < 0 (eg. -ENODEV) on error | ||
986 | */ | 990 | */ |
987 | int gigaset_isoc_send_skb(struct bc_state *bcs, struct sk_buff *skb) | 991 | int gigaset_isoc_send_skb(struct bc_state *bcs, struct sk_buff *skb) |
988 | { | 992 | { |
diff --git a/drivers/isdn/mISDN/socket.c b/drivers/isdn/mISDN/socket.c index c36f52137456..feb0fa45b664 100644 --- a/drivers/isdn/mISDN/socket.c +++ b/drivers/isdn/mISDN/socket.c | |||
@@ -415,7 +415,7 @@ data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) | |||
415 | } | 415 | } |
416 | 416 | ||
417 | static int data_sock_setsockopt(struct socket *sock, int level, int optname, | 417 | static int data_sock_setsockopt(struct socket *sock, int level, int optname, |
418 | char __user *optval, int len) | 418 | char __user *optval, unsigned int len) |
419 | { | 419 | { |
420 | struct sock *sk = sock->sk; | 420 | struct sock *sk = sock->sk; |
421 | int err = 0, opt = 0; | 421 | int err = 0, opt = 0; |
diff --git a/drivers/leds/leds-pca9532.c b/drivers/leds/leds-pca9532.c index 708a8017c21d..adc561eb59d2 100644 --- a/drivers/leds/leds-pca9532.c +++ b/drivers/leds/leds-pca9532.c | |||
@@ -19,9 +19,6 @@ | |||
19 | #include <linux/workqueue.h> | 19 | #include <linux/workqueue.h> |
20 | #include <linux/leds-pca9532.h> | 20 | #include <linux/leds-pca9532.h> |
21 | 21 | ||
22 | static const unsigned short normal_i2c[] = { /*0x60,*/ I2C_CLIENT_END}; | ||
23 | I2C_CLIENT_INSMOD_1(pca9532); | ||
24 | |||
25 | #define PCA9532_REG_PSC(i) (0x2+(i)*2) | 22 | #define PCA9532_REG_PSC(i) (0x2+(i)*2) |
26 | #define PCA9532_REG_PWM(i) (0x3+(i)*2) | 23 | #define PCA9532_REG_PWM(i) (0x3+(i)*2) |
27 | #define PCA9532_REG_LS0 0x6 | 24 | #define PCA9532_REG_LS0 0x6 |
diff --git a/drivers/lguest/lguest_user.c b/drivers/lguest/lguest_user.c index b4d3f7ca554f..bd1632388e4a 100644 --- a/drivers/lguest/lguest_user.c +++ b/drivers/lguest/lguest_user.c | |||
@@ -508,7 +508,7 @@ static int close(struct inode *inode, struct file *file) | |||
508 | * uses: reading and writing a character device called /dev/lguest. All the | 508 | * uses: reading and writing a character device called /dev/lguest. All the |
509 | * work happens in the read(), write() and close() routines: | 509 | * work happens in the read(), write() and close() routines: |
510 | */ | 510 | */ |
511 | static struct file_operations lguest_fops = { | 511 | static const struct file_operations lguest_fops = { |
512 | .owner = THIS_MODULE, | 512 | .owner = THIS_MODULE, |
513 | .release = close, | 513 | .release = close, |
514 | .write = write, | 514 | .write = write, |
diff --git a/drivers/macintosh/therm_adt746x.c b/drivers/macintosh/therm_adt746x.c index fde377c60cca..556f0feaa4df 100644 --- a/drivers/macintosh/therm_adt746x.c +++ b/drivers/macintosh/therm_adt746x.c | |||
@@ -124,6 +124,8 @@ read_reg(struct thermostat* th, int reg) | |||
124 | return data; | 124 | return data; |
125 | } | 125 | } |
126 | 126 | ||
127 | static struct i2c_driver thermostat_driver; | ||
128 | |||
127 | static int | 129 | static int |
128 | attach_thermostat(struct i2c_adapter *adapter) | 130 | attach_thermostat(struct i2c_adapter *adapter) |
129 | { | 131 | { |
@@ -148,7 +150,7 @@ attach_thermostat(struct i2c_adapter *adapter) | |||
148 | * Let i2c-core delete that device on driver removal. | 150 | * Let i2c-core delete that device on driver removal. |
149 | * This is safe because i2c-core holds the core_lock mutex for us. | 151 | * This is safe because i2c-core holds the core_lock mutex for us. |
150 | */ | 152 | */ |
151 | list_add_tail(&client->detected, &client->driver->clients); | 153 | list_add_tail(&client->detected, &thermostat_driver.clients); |
152 | return 0; | 154 | return 0; |
153 | } | 155 | } |
154 | 156 | ||
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c index a028598af2d3..ea32c7e5a9af 100644 --- a/drivers/macintosh/therm_pm72.c +++ b/drivers/macintosh/therm_pm72.c | |||
@@ -286,6 +286,8 @@ struct fcu_fan_table fcu_fans[] = { | |||
286 | }, | 286 | }, |
287 | }; | 287 | }; |
288 | 288 | ||
289 | static struct i2c_driver therm_pm72_driver; | ||
290 | |||
289 | /* | 291 | /* |
290 | * Utility function to create an i2c_client structure and | 292 | * Utility function to create an i2c_client structure and |
291 | * attach it to one of u3 adapters | 293 | * attach it to one of u3 adapters |
@@ -318,7 +320,7 @@ static struct i2c_client *attach_i2c_chip(int id, const char *name) | |||
318 | * Let i2c-core delete that device on driver removal. | 320 | * Let i2c-core delete that device on driver removal. |
319 | * This is safe because i2c-core holds the core_lock mutex for us. | 321 | * This is safe because i2c-core holds the core_lock mutex for us. |
320 | */ | 322 | */ |
321 | list_add_tail(&clt->detected, &clt->driver->clients); | 323 | list_add_tail(&clt->detected, &therm_pm72_driver.clients); |
322 | return clt; | 324 | return clt; |
323 | } | 325 | } |
324 | 326 | ||
diff --git a/drivers/macintosh/windfarm_lm75_sensor.c b/drivers/macintosh/windfarm_lm75_sensor.c index 529886c7a826..ed6426a10773 100644 --- a/drivers/macintosh/windfarm_lm75_sensor.c +++ b/drivers/macintosh/windfarm_lm75_sensor.c | |||
@@ -115,6 +115,8 @@ static int wf_lm75_probe(struct i2c_client *client, | |||
115 | return rc; | 115 | return rc; |
116 | } | 116 | } |
117 | 117 | ||
118 | static struct i2c_driver wf_lm75_driver; | ||
119 | |||
118 | static struct i2c_client *wf_lm75_create(struct i2c_adapter *adapter, | 120 | static struct i2c_client *wf_lm75_create(struct i2c_adapter *adapter, |
119 | u8 addr, int ds1775, | 121 | u8 addr, int ds1775, |
120 | const char *loc) | 122 | const char *loc) |
@@ -157,7 +159,7 @@ static struct i2c_client *wf_lm75_create(struct i2c_adapter *adapter, | |||
157 | * Let i2c-core delete that device on driver removal. | 159 | * Let i2c-core delete that device on driver removal. |
158 | * This is safe because i2c-core holds the core_lock mutex for us. | 160 | * This is safe because i2c-core holds the core_lock mutex for us. |
159 | */ | 161 | */ |
160 | list_add_tail(&client->detected, &client->driver->clients); | 162 | list_add_tail(&client->detected, &wf_lm75_driver.clients); |
161 | return client; | 163 | return client; |
162 | fail: | 164 | fail: |
163 | return NULL; | 165 | return NULL; |
diff --git a/drivers/macintosh/windfarm_max6690_sensor.c b/drivers/macintosh/windfarm_max6690_sensor.c index e2a55ecda2b2..a67b349319e9 100644 --- a/drivers/macintosh/windfarm_max6690_sensor.c +++ b/drivers/macintosh/windfarm_max6690_sensor.c | |||
@@ -88,6 +88,8 @@ static int wf_max6690_probe(struct i2c_client *client, | |||
88 | return rc; | 88 | return rc; |
89 | } | 89 | } |
90 | 90 | ||
91 | static struct i2c_driver wf_max6690_driver; | ||
92 | |||
91 | static struct i2c_client *wf_max6690_create(struct i2c_adapter *adapter, | 93 | static struct i2c_client *wf_max6690_create(struct i2c_adapter *adapter, |
92 | u8 addr, const char *loc) | 94 | u8 addr, const char *loc) |
93 | { | 95 | { |
@@ -119,7 +121,7 @@ static struct i2c_client *wf_max6690_create(struct i2c_adapter *adapter, | |||
119 | * Let i2c-core delete that device on driver removal. | 121 | * Let i2c-core delete that device on driver removal. |
120 | * This is safe because i2c-core holds the core_lock mutex for us. | 122 | * This is safe because i2c-core holds the core_lock mutex for us. |
121 | */ | 123 | */ |
122 | list_add_tail(&client->detected, &client->driver->clients); | 124 | list_add_tail(&client->detected, &wf_max6690_driver.clients); |
123 | return client; | 125 | return client; |
124 | 126 | ||
125 | fail: | 127 | fail: |
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c index 5da729e58f99..e20330a28959 100644 --- a/drivers/macintosh/windfarm_smu_sat.c +++ b/drivers/macintosh/windfarm_smu_sat.c | |||
@@ -194,6 +194,8 @@ static struct wf_sensor_ops wf_sat_ops = { | |||
194 | .owner = THIS_MODULE, | 194 | .owner = THIS_MODULE, |
195 | }; | 195 | }; |
196 | 196 | ||
197 | static struct i2c_driver wf_sat_driver; | ||
198 | |||
197 | static void wf_sat_create(struct i2c_adapter *adapter, struct device_node *dev) | 199 | static void wf_sat_create(struct i2c_adapter *adapter, struct device_node *dev) |
198 | { | 200 | { |
199 | struct i2c_board_info info; | 201 | struct i2c_board_info info; |
@@ -222,7 +224,7 @@ static void wf_sat_create(struct i2c_adapter *adapter, struct device_node *dev) | |||
222 | * Let i2c-core delete that device on driver removal. | 224 | * Let i2c-core delete that device on driver removal. |
223 | * This is safe because i2c-core holds the core_lock mutex for us. | 225 | * This is safe because i2c-core holds the core_lock mutex for us. |
224 | */ | 226 | */ |
225 | list_add_tail(&client->detected, &client->driver->clients); | 227 | list_add_tail(&client->detected, &wf_sat_driver.clients); |
226 | } | 228 | } |
227 | 229 | ||
228 | static int wf_sat_probe(struct i2c_client *client, | 230 | static int wf_sat_probe(struct i2c_client *client, |
diff --git a/drivers/md/dm-log-userspace-transfer.c b/drivers/md/dm-log-userspace-transfer.c index ba0edad2d048..54abf9e303b7 100644 --- a/drivers/md/dm-log-userspace-transfer.c +++ b/drivers/md/dm-log-userspace-transfer.c | |||
@@ -129,11 +129,13 @@ static int fill_pkg(struct cn_msg *msg, struct dm_ulog_request *tfr) | |||
129 | * This is the connector callback that delivers data | 129 | * This is the connector callback that delivers data |
130 | * that was sent from userspace. | 130 | * that was sent from userspace. |
131 | */ | 131 | */ |
132 | static void cn_ulog_callback(void *data) | 132 | static void cn_ulog_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) |
133 | { | 133 | { |
134 | struct cn_msg *msg = (struct cn_msg *)data; | ||
135 | struct dm_ulog_request *tfr = (struct dm_ulog_request *)(msg + 1); | 134 | struct dm_ulog_request *tfr = (struct dm_ulog_request *)(msg + 1); |
136 | 135 | ||
136 | if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN)) | ||
137 | return; | ||
138 | |||
137 | spin_lock(&receiving_list_lock); | 139 | spin_lock(&receiving_list_lock); |
138 | if (msg->len == 0) | 140 | if (msg->len == 0) |
139 | fill_pkg(msg, NULL); | 141 | fill_pkg(msg, NULL); |
diff --git a/drivers/md/dm.c b/drivers/md/dm.c index 376f1ab48a24..23e76fe0d359 100644 --- a/drivers/md/dm.c +++ b/drivers/md/dm.c | |||
@@ -130,7 +130,7 @@ struct mapped_device { | |||
130 | /* | 130 | /* |
131 | * A list of ios that arrived while we were suspended. | 131 | * A list of ios that arrived while we were suspended. |
132 | */ | 132 | */ |
133 | atomic_t pending[2]; | 133 | atomic_t pending; |
134 | wait_queue_head_t wait; | 134 | wait_queue_head_t wait; |
135 | struct work_struct work; | 135 | struct work_struct work; |
136 | struct bio_list deferred; | 136 | struct bio_list deferred; |
@@ -453,14 +453,13 @@ static void start_io_acct(struct dm_io *io) | |||
453 | { | 453 | { |
454 | struct mapped_device *md = io->md; | 454 | struct mapped_device *md = io->md; |
455 | int cpu; | 455 | int cpu; |
456 | int rw = bio_data_dir(io->bio); | ||
457 | 456 | ||
458 | io->start_time = jiffies; | 457 | io->start_time = jiffies; |
459 | 458 | ||
460 | cpu = part_stat_lock(); | 459 | cpu = part_stat_lock(); |
461 | part_round_stats(cpu, &dm_disk(md)->part0); | 460 | part_round_stats(cpu, &dm_disk(md)->part0); |
462 | part_stat_unlock(); | 461 | part_stat_unlock(); |
463 | dm_disk(md)->part0.in_flight[rw] = atomic_inc_return(&md->pending[rw]); | 462 | dm_disk(md)->part0.in_flight = atomic_inc_return(&md->pending); |
464 | } | 463 | } |
465 | 464 | ||
466 | static void end_io_acct(struct dm_io *io) | 465 | static void end_io_acct(struct dm_io *io) |
@@ -480,9 +479,8 @@ static void end_io_acct(struct dm_io *io) | |||
480 | * After this is decremented the bio must not be touched if it is | 479 | * After this is decremented the bio must not be touched if it is |
481 | * a barrier. | 480 | * a barrier. |
482 | */ | 481 | */ |
483 | dm_disk(md)->part0.in_flight[rw] = pending = | 482 | dm_disk(md)->part0.in_flight = pending = |
484 | atomic_dec_return(&md->pending[rw]); | 483 | atomic_dec_return(&md->pending); |
485 | pending += atomic_read(&md->pending[rw^0x1]); | ||
486 | 484 | ||
487 | /* nudge anyone waiting on suspend queue */ | 485 | /* nudge anyone waiting on suspend queue */ |
488 | if (!pending) | 486 | if (!pending) |
@@ -1787,8 +1785,7 @@ static struct mapped_device *alloc_dev(int minor) | |||
1787 | if (!md->disk) | 1785 | if (!md->disk) |
1788 | goto bad_disk; | 1786 | goto bad_disk; |
1789 | 1787 | ||
1790 | atomic_set(&md->pending[0], 0); | 1788 | atomic_set(&md->pending, 0); |
1791 | atomic_set(&md->pending[1], 0); | ||
1792 | init_waitqueue_head(&md->wait); | 1789 | init_waitqueue_head(&md->wait); |
1793 | INIT_WORK(&md->work, dm_wq_work); | 1790 | INIT_WORK(&md->work, dm_wq_work); |
1794 | init_waitqueue_head(&md->eventq); | 1791 | init_waitqueue_head(&md->eventq); |
@@ -2091,8 +2088,7 @@ static int dm_wait_for_completion(struct mapped_device *md, int interruptible) | |||
2091 | break; | 2088 | break; |
2092 | } | 2089 | } |
2093 | spin_unlock_irqrestore(q->queue_lock, flags); | 2090 | spin_unlock_irqrestore(q->queue_lock, flags); |
2094 | } else if (!atomic_read(&md->pending[0]) && | 2091 | } else if (!atomic_read(&md->pending)) |
2095 | !atomic_read(&md->pending[1])) | ||
2096 | break; | 2092 | break; |
2097 | 2093 | ||
2098 | if (interruptible == TASK_INTERRUPTIBLE && | 2094 | if (interruptible == TASK_INTERRUPTIBLE && |
diff --git a/drivers/media/dvb/dvb-core/dmxdev.c b/drivers/media/dvb/dvb-core/dmxdev.c index 3750ff48cba1..c37790ad92d0 100644 --- a/drivers/media/dvb/dvb-core/dmxdev.c +++ b/drivers/media/dvb/dvb-core/dmxdev.c | |||
@@ -20,6 +20,7 @@ | |||
20 | * | 20 | * |
21 | */ | 21 | */ |
22 | 22 | ||
23 | #include <linux/sched.h> | ||
23 | #include <linux/spinlock.h> | 24 | #include <linux/spinlock.h> |
24 | #include <linux/slab.h> | 25 | #include <linux/slab.h> |
25 | #include <linux/vmalloc.h> | 26 | #include <linux/vmalloc.h> |
@@ -1203,7 +1204,7 @@ static unsigned int dvb_dvr_poll(struct file *file, poll_table *wait) | |||
1203 | return mask; | 1204 | return mask; |
1204 | } | 1205 | } |
1205 | 1206 | ||
1206 | static struct file_operations dvb_dvr_fops = { | 1207 | static const struct file_operations dvb_dvr_fops = { |
1207 | .owner = THIS_MODULE, | 1208 | .owner = THIS_MODULE, |
1208 | .read = dvb_dvr_read, | 1209 | .read = dvb_dvr_read, |
1209 | .write = dvb_dvr_write, | 1210 | .write = dvb_dvr_write, |
diff --git a/drivers/media/dvb/dvb-core/dvb_demux.c b/drivers/media/dvb/dvb-core/dvb_demux.c index eef6d3616626..91c537bca8ad 100644 --- a/drivers/media/dvb/dvb-core/dvb_demux.c +++ b/drivers/media/dvb/dvb-core/dvb_demux.c | |||
@@ -21,6 +21,7 @@ | |||
21 | * | 21 | * |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <linux/sched.h> | ||
24 | #include <linux/spinlock.h> | 25 | #include <linux/spinlock.h> |
25 | #include <linux/slab.h> | 26 | #include <linux/slab.h> |
26 | #include <linux/vmalloc.h> | 27 | #include <linux/vmalloc.h> |
diff --git a/drivers/media/dvb/firewire/firedtv-ci.c b/drivers/media/dvb/firewire/firedtv-ci.c index eeb80d0ea3ff..853e04b7cb36 100644 --- a/drivers/media/dvb/firewire/firedtv-ci.c +++ b/drivers/media/dvb/firewire/firedtv-ci.c | |||
@@ -215,7 +215,7 @@ static unsigned int fdtv_ca_io_poll(struct file *file, poll_table *wait) | |||
215 | return POLLIN; | 215 | return POLLIN; |
216 | } | 216 | } |
217 | 217 | ||
218 | static struct file_operations fdtv_ca_fops = { | 218 | static const struct file_operations fdtv_ca_fops = { |
219 | .owner = THIS_MODULE, | 219 | .owner = THIS_MODULE, |
220 | .ioctl = dvb_generic_ioctl, | 220 | .ioctl = dvb_generic_ioctl, |
221 | .open = dvb_generic_open, | 221 | .open = dvb_generic_open, |
diff --git a/drivers/media/radio/radio-cadet.c b/drivers/media/radio/radio-cadet.c index 8b1440136c45..482d0f3be5ff 100644 --- a/drivers/media/radio/radio-cadet.c +++ b/drivers/media/radio/radio-cadet.c | |||
@@ -38,6 +38,7 @@ | |||
38 | #include <linux/videodev2.h> /* V4L2 API defs */ | 38 | #include <linux/videodev2.h> /* V4L2 API defs */ |
39 | #include <linux/param.h> | 39 | #include <linux/param.h> |
40 | #include <linux/pnp.h> | 40 | #include <linux/pnp.h> |
41 | #include <linux/sched.h> | ||
41 | #include <linux/io.h> /* outb, outb_p */ | 42 | #include <linux/io.h> /* outb, outb_p */ |
42 | #include <media/v4l2-device.h> | 43 | #include <media/v4l2-device.h> |
43 | #include <media/v4l2-ioctl.h> | 44 | #include <media/v4l2-ioctl.h> |
diff --git a/drivers/media/video/cpia.c b/drivers/media/video/cpia.c index 43ab0adf3b61..2377313c041a 100644 --- a/drivers/media/video/cpia.c +++ b/drivers/media/video/cpia.c | |||
@@ -31,6 +31,7 @@ | |||
31 | #include <linux/init.h> | 31 | #include <linux/init.h> |
32 | #include <linux/fs.h> | 32 | #include <linux/fs.h> |
33 | #include <linux/vmalloc.h> | 33 | #include <linux/vmalloc.h> |
34 | #include <linux/sched.h> | ||
34 | #include <linux/slab.h> | 35 | #include <linux/slab.h> |
35 | #include <linux/proc_fs.h> | 36 | #include <linux/proc_fs.h> |
36 | #include <linux/ctype.h> | 37 | #include <linux/ctype.h> |
diff --git a/drivers/mfd/ab3100-core.c b/drivers/mfd/ab3100-core.c index 5447da16a170..613481028272 100644 --- a/drivers/mfd/ab3100-core.c +++ b/drivers/mfd/ab3100-core.c | |||
@@ -57,8 +57,6 @@ | |||
57 | * The AB3100 is usually assigned address 0x48 (7-bit) | 57 | * The AB3100 is usually assigned address 0x48 (7-bit) |
58 | * The chip is defined in the platform i2c_board_data section. | 58 | * The chip is defined in the platform i2c_board_data section. |
59 | */ | 59 | */ |
60 | static unsigned short normal_i2c[] = { 0x48, I2C_CLIENT_END }; | ||
61 | I2C_CLIENT_INSMOD_1(ab3100); | ||
62 | 60 | ||
63 | u8 ab3100_get_chip_type(struct ab3100 *ab3100) | 61 | u8 ab3100_get_chip_type(struct ab3100 *ab3100) |
64 | { | 62 | { |
@@ -966,7 +964,7 @@ static int __exit ab3100_remove(struct i2c_client *client) | |||
966 | } | 964 | } |
967 | 965 | ||
968 | static const struct i2c_device_id ab3100_id[] = { | 966 | static const struct i2c_device_id ab3100_id[] = { |
969 | { "ab3100", ab3100 }, | 967 | { "ab3100", 0 }, |
970 | { } | 968 | { } |
971 | }; | 969 | }; |
972 | MODULE_DEVICE_TABLE(i2c, ab3100_id); | 970 | MODULE_DEVICE_TABLE(i2c, ab3100_id); |
diff --git a/drivers/mfd/ucb1400_core.c b/drivers/mfd/ucb1400_core.c index 2afc08006e6d..fa294b6d600a 100644 --- a/drivers/mfd/ucb1400_core.c +++ b/drivers/mfd/ucb1400_core.c | |||
@@ -21,6 +21,7 @@ | |||
21 | */ | 21 | */ |
22 | 22 | ||
23 | #include <linux/module.h> | 23 | #include <linux/module.h> |
24 | #include <linux/sched.h> | ||
24 | #include <linux/ucb1400.h> | 25 | #include <linux/ucb1400.h> |
25 | 26 | ||
26 | unsigned int ucb1400_adc_read(struct snd_ac97 *ac97, u16 adc_channel, | 27 | unsigned int ucb1400_adc_read(struct snd_ac97 *ac97, u16 adc_channel, |
diff --git a/drivers/misc/eeprom/max6875.c b/drivers/misc/eeprom/max6875.c index 3c0c58eed347..5a6b2bce8ad5 100644 --- a/drivers/misc/eeprom/max6875.c +++ b/drivers/misc/eeprom/max6875.c | |||
@@ -33,12 +33,6 @@ | |||
33 | #include <linux/i2c.h> | 33 | #include <linux/i2c.h> |
34 | #include <linux/mutex.h> | 34 | #include <linux/mutex.h> |
35 | 35 | ||
36 | /* Do not scan - the MAX6875 access method will write to some EEPROM chips */ | ||
37 | static const unsigned short normal_i2c[] = { I2C_CLIENT_END }; | ||
38 | |||
39 | /* Insmod parameters */ | ||
40 | I2C_CLIENT_INSMOD_1(max6875); | ||
41 | |||
42 | /* The MAX6875 can only read/write 16 bytes at a time */ | 36 | /* The MAX6875 can only read/write 16 bytes at a time */ |
43 | #define SLICE_SIZE 16 | 37 | #define SLICE_SIZE 16 |
44 | #define SLICE_BITS 4 | 38 | #define SLICE_BITS 4 |
@@ -146,31 +140,21 @@ static struct bin_attribute user_eeprom_attr = { | |||
146 | .read = max6875_read, | 140 | .read = max6875_read, |
147 | }; | 141 | }; |
148 | 142 | ||
149 | /* Return 0 if detection is successful, -ENODEV otherwise */ | 143 | static int max6875_probe(struct i2c_client *client, |
150 | static int max6875_detect(struct i2c_client *client, int kind, | 144 | const struct i2c_device_id *id) |
151 | struct i2c_board_info *info) | ||
152 | { | 145 | { |
153 | struct i2c_adapter *adapter = client->adapter; | 146 | struct i2c_adapter *adapter = client->adapter; |
147 | struct max6875_data *data; | ||
148 | int err; | ||
154 | 149 | ||
155 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE_DATA | 150 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
156 | | I2C_FUNC_SMBUS_READ_BYTE)) | 151 | | I2C_FUNC_SMBUS_READ_BYTE)) |
157 | return -ENODEV; | 152 | return -ENODEV; |
158 | 153 | ||
159 | /* Only check even addresses */ | 154 | /* Only bind to even addresses */ |
160 | if (client->addr & 1) | 155 | if (client->addr & 1) |
161 | return -ENODEV; | 156 | return -ENODEV; |
162 | 157 | ||
163 | strlcpy(info->type, "max6875", I2C_NAME_SIZE); | ||
164 | |||
165 | return 0; | ||
166 | } | ||
167 | |||
168 | static int max6875_probe(struct i2c_client *client, | ||
169 | const struct i2c_device_id *id) | ||
170 | { | ||
171 | struct max6875_data *data; | ||
172 | int err; | ||
173 | |||
174 | if (!(data = kzalloc(sizeof(struct max6875_data), GFP_KERNEL))) | 158 | if (!(data = kzalloc(sizeof(struct max6875_data), GFP_KERNEL))) |
175 | return -ENOMEM; | 159 | return -ENOMEM; |
176 | 160 | ||
@@ -222,9 +206,6 @@ static struct i2c_driver max6875_driver = { | |||
222 | .probe = max6875_probe, | 206 | .probe = max6875_probe, |
223 | .remove = max6875_remove, | 207 | .remove = max6875_remove, |
224 | .id_table = max6875_id, | 208 | .id_table = max6875_id, |
225 | |||
226 | .detect = max6875_detect, | ||
227 | .address_data = &addr_data, | ||
228 | }; | 209 | }; |
229 | 210 | ||
230 | static int __init max6875_init(void) | 211 | static int __init max6875_init(void) |
diff --git a/drivers/misc/phantom.c b/drivers/misc/phantom.c index fa57b67593ae..90a95ce8dc34 100644 --- a/drivers/misc/phantom.c +++ b/drivers/misc/phantom.c | |||
@@ -271,7 +271,7 @@ static unsigned int phantom_poll(struct file *file, poll_table *wait) | |||
271 | return mask; | 271 | return mask; |
272 | } | 272 | } |
273 | 273 | ||
274 | static struct file_operations phantom_file_ops = { | 274 | static const struct file_operations phantom_file_ops = { |
275 | .open = phantom_open, | 275 | .open = phantom_open, |
276 | .release = phantom_release, | 276 | .release = phantom_release, |
277 | .unlocked_ioctl = phantom_ioctl, | 277 | .unlocked_ioctl = phantom_ioctl, |
diff --git a/drivers/misc/sgi-gru/grufile.c b/drivers/misc/sgi-gru/grufile.c index 300e7ba391a0..41c8fe2a928c 100644 --- a/drivers/misc/sgi-gru/grufile.c +++ b/drivers/misc/sgi-gru/grufile.c | |||
@@ -53,7 +53,6 @@ struct gru_stats_s gru_stats; | |||
53 | /* Guaranteed user available resources on each node */ | 53 | /* Guaranteed user available resources on each node */ |
54 | static int max_user_cbrs, max_user_dsr_bytes; | 54 | static int max_user_cbrs, max_user_dsr_bytes; |
55 | 55 | ||
56 | static struct file_operations gru_fops; | ||
57 | static struct miscdevice gru_miscdev; | 56 | static struct miscdevice gru_miscdev; |
58 | 57 | ||
59 | 58 | ||
@@ -426,7 +425,7 @@ static void __exit gru_exit(void) | |||
426 | gru_proc_exit(); | 425 | gru_proc_exit(); |
427 | } | 426 | } |
428 | 427 | ||
429 | static struct file_operations gru_fops = { | 428 | static const struct file_operations gru_fops = { |
430 | .owner = THIS_MODULE, | 429 | .owner = THIS_MODULE, |
431 | .unlocked_ioctl = gru_file_unlocked_ioctl, | 430 | .unlocked_ioctl = gru_file_unlocked_ioctl, |
432 | .mmap = gru_file_mmap, | 431 | .mmap = gru_file_mmap, |
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c index 610dbd1fcc82..96d10f40fb23 100644 --- a/drivers/mmc/core/debugfs.c +++ b/drivers/mmc/core/debugfs.c | |||
@@ -240,7 +240,7 @@ static int mmc_ext_csd_release(struct inode *inode, struct file *file) | |||
240 | return 0; | 240 | return 0; |
241 | } | 241 | } |
242 | 242 | ||
243 | static struct file_operations mmc_dbg_ext_csd_fops = { | 243 | static const struct file_operations mmc_dbg_ext_csd_fops = { |
244 | .open = mmc_ext_csd_open, | 244 | .open = mmc_ext_csd_open, |
245 | .read = mmc_ext_csd_read, | 245 | .read = mmc_ext_csd_read, |
246 | .release = mmc_ext_csd_release, | 246 | .release = mmc_ext_csd_release, |
diff --git a/drivers/mmc/core/sdio_cis.c b/drivers/mmc/core/sdio_cis.c index 6636354b48ce..f85dcd536508 100644 --- a/drivers/mmc/core/sdio_cis.c +++ b/drivers/mmc/core/sdio_cis.c | |||
@@ -29,6 +29,8 @@ static int cistpl_vers_1(struct mmc_card *card, struct sdio_func *func, | |||
29 | unsigned i, nr_strings; | 29 | unsigned i, nr_strings; |
30 | char **buffer, *string; | 30 | char **buffer, *string; |
31 | 31 | ||
32 | /* Find all null-terminated (including zero length) strings in | ||
33 | the TPLLV1_INFO field. Trailing garbage is ignored. */ | ||
32 | buf += 2; | 34 | buf += 2; |
33 | size -= 2; | 35 | size -= 2; |
34 | 36 | ||
@@ -39,11 +41,8 @@ static int cistpl_vers_1(struct mmc_card *card, struct sdio_func *func, | |||
39 | if (buf[i] == 0) | 41 | if (buf[i] == 0) |
40 | nr_strings++; | 42 | nr_strings++; |
41 | } | 43 | } |
42 | 44 | if (nr_strings == 0) | |
43 | if (nr_strings < 4) { | ||
44 | printk(KERN_WARNING "SDIO: ignoring broken CISTPL_VERS_1\n"); | ||
45 | return 0; | 45 | return 0; |
46 | } | ||
47 | 46 | ||
48 | size = i; | 47 | size = i; |
49 | 48 | ||
@@ -98,6 +97,22 @@ static const unsigned char speed_val[16] = | |||
98 | static const unsigned int speed_unit[8] = | 97 | static const unsigned int speed_unit[8] = |
99 | { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 }; | 98 | { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 }; |
100 | 99 | ||
100 | /* FUNCE tuples with these types get passed to SDIO drivers */ | ||
101 | static const unsigned char funce_type_whitelist[] = { | ||
102 | 4 /* CISTPL_FUNCE_LAN_NODE_ID used in Broadcom cards */ | ||
103 | }; | ||
104 | |||
105 | static int cistpl_funce_whitelisted(unsigned char type) | ||
106 | { | ||
107 | int i; | ||
108 | |||
109 | for (i = 0; i < ARRAY_SIZE(funce_type_whitelist); i++) { | ||
110 | if (funce_type_whitelist[i] == type) | ||
111 | return 1; | ||
112 | } | ||
113 | return 0; | ||
114 | } | ||
115 | |||
101 | static int cistpl_funce_common(struct mmc_card *card, | 116 | static int cistpl_funce_common(struct mmc_card *card, |
102 | const unsigned char *buf, unsigned size) | 117 | const unsigned char *buf, unsigned size) |
103 | { | 118 | { |
@@ -120,6 +135,10 @@ static int cistpl_funce_func(struct sdio_func *func, | |||
120 | unsigned vsn; | 135 | unsigned vsn; |
121 | unsigned min_size; | 136 | unsigned min_size; |
122 | 137 | ||
138 | /* let SDIO drivers take care of whitelisted FUNCE tuples */ | ||
139 | if (cistpl_funce_whitelisted(buf[0])) | ||
140 | return -EILSEQ; | ||
141 | |||
123 | vsn = func->card->cccr.sdio_vsn; | 142 | vsn = func->card->cccr.sdio_vsn; |
124 | min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42; | 143 | min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42; |
125 | 144 | ||
@@ -154,13 +173,12 @@ static int cistpl_funce(struct mmc_card *card, struct sdio_func *func, | |||
154 | else | 173 | else |
155 | ret = cistpl_funce_common(card, buf, size); | 174 | ret = cistpl_funce_common(card, buf, size); |
156 | 175 | ||
157 | if (ret) { | 176 | if (ret && ret != -EILSEQ) { |
158 | printk(KERN_ERR "%s: bad CISTPL_FUNCE size %u " | 177 | printk(KERN_ERR "%s: bad CISTPL_FUNCE size %u " |
159 | "type %u\n", mmc_hostname(card->host), size, buf[0]); | 178 | "type %u\n", mmc_hostname(card->host), size, buf[0]); |
160 | return ret; | ||
161 | } | 179 | } |
162 | 180 | ||
163 | return 0; | 181 | return ret; |
164 | } | 182 | } |
165 | 183 | ||
166 | typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *, | 184 | typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *, |
@@ -253,21 +271,12 @@ static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func) | |||
253 | for (i = 0; i < ARRAY_SIZE(cis_tpl_list); i++) | 271 | for (i = 0; i < ARRAY_SIZE(cis_tpl_list); i++) |
254 | if (cis_tpl_list[i].code == tpl_code) | 272 | if (cis_tpl_list[i].code == tpl_code) |
255 | break; | 273 | break; |
256 | if (i >= ARRAY_SIZE(cis_tpl_list)) { | 274 | if (i < ARRAY_SIZE(cis_tpl_list)) { |
257 | /* this tuple is unknown to the core */ | ||
258 | this->next = NULL; | ||
259 | this->code = tpl_code; | ||
260 | this->size = tpl_link; | ||
261 | *prev = this; | ||
262 | prev = &this->next; | ||
263 | printk(KERN_DEBUG | ||
264 | "%s: queuing CIS tuple 0x%02x length %u\n", | ||
265 | mmc_hostname(card->host), tpl_code, tpl_link); | ||
266 | } else { | ||
267 | const struct cis_tpl *tpl = cis_tpl_list + i; | 275 | const struct cis_tpl *tpl = cis_tpl_list + i; |
268 | if (tpl_link < tpl->min_size) { | 276 | if (tpl_link < tpl->min_size) { |
269 | printk(KERN_ERR | 277 | printk(KERN_ERR |
270 | "%s: bad CIS tuple 0x%02x (length = %u, expected >= %u)\n", | 278 | "%s: bad CIS tuple 0x%02x" |
279 | " (length = %u, expected >= %u)\n", | ||
271 | mmc_hostname(card->host), | 280 | mmc_hostname(card->host), |
272 | tpl_code, tpl_link, tpl->min_size); | 281 | tpl_code, tpl_link, tpl->min_size); |
273 | ret = -EINVAL; | 282 | ret = -EINVAL; |
@@ -275,7 +284,30 @@ static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func) | |||
275 | ret = tpl->parse(card, func, | 284 | ret = tpl->parse(card, func, |
276 | this->data, tpl_link); | 285 | this->data, tpl_link); |
277 | } | 286 | } |
278 | kfree(this); | 287 | /* |
288 | * We don't need the tuple anymore if it was | ||
289 | * successfully parsed by the SDIO core or if it is | ||
290 | * not going to be parsed by SDIO drivers. | ||
291 | */ | ||
292 | if (!ret || ret != -EILSEQ) | ||
293 | kfree(this); | ||
294 | } else { | ||
295 | /* unknown tuple */ | ||
296 | ret = -EILSEQ; | ||
297 | } | ||
298 | |||
299 | if (ret == -EILSEQ) { | ||
300 | /* this tuple is unknown to the core or whitelisted */ | ||
301 | this->next = NULL; | ||
302 | this->code = tpl_code; | ||
303 | this->size = tpl_link; | ||
304 | *prev = this; | ||
305 | prev = &this->next; | ||
306 | printk(KERN_DEBUG | ||
307 | "%s: queuing CIS tuple 0x%02x length %u\n", | ||
308 | mmc_hostname(card->host), tpl_code, tpl_link); | ||
309 | /* keep on analyzing tuples */ | ||
310 | ret = 0; | ||
279 | } | 311 | } |
280 | 312 | ||
281 | ptr += tpl_link; | 313 | ptr += tpl_link; |
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig index 7cb057f3f883..432ae8358c86 100644 --- a/drivers/mmc/host/Kconfig +++ b/drivers/mmc/host/Kconfig | |||
@@ -276,6 +276,47 @@ config MMC_S3C | |||
276 | 276 | ||
277 | If unsure, say N. | 277 | If unsure, say N. |
278 | 278 | ||
279 | config MMC_S3C_HW_SDIO_IRQ | ||
280 | bool "Hardware support for SDIO IRQ" | ||
281 | depends on MMC_S3C | ||
282 | help | ||
283 | Enable the hardware support for SDIO interrupts instead of using | ||
284 | the generic polling code. | ||
285 | |||
286 | choice | ||
287 | prompt "Samsung S3C SD/MMC transfer code" | ||
288 | depends on MMC_S3C | ||
289 | |||
290 | config MMC_S3C_PIO | ||
291 | bool "Use PIO transfers only" | ||
292 | help | ||
293 | Use PIO to transfer data between memory and the hardware. | ||
294 | |||
295 | PIO is slower than DMA as it requires CPU instructions to | ||
296 | move the data. This has been the traditional default for | ||
297 | the S3C MCI driver. | ||
298 | |||
299 | config MMC_S3C_DMA | ||
300 | bool "Use DMA transfers only (EXPERIMENTAL)" | ||
301 | depends on EXPERIMENTAL | ||
302 | help | ||
303 | Use DMA to transfer data between memory and the hardare. | ||
304 | |||
305 | Currently, the DMA support in this driver seems to not be | ||
306 | working properly and needs to be debugged before this | ||
307 | option is useful. | ||
308 | |||
309 | config MMC_S3C_PIODMA | ||
310 | bool "Support for both PIO and DMA (EXPERIMENTAL)" | ||
311 | help | ||
312 | Compile both the PIO and DMA transfer routines into the | ||
313 | driver and let the platform select at run-time which one | ||
314 | is best. | ||
315 | |||
316 | See notes for the DMA option. | ||
317 | |||
318 | endchoice | ||
319 | |||
279 | config MMC_SDRICOH_CS | 320 | config MMC_SDRICOH_CS |
280 | tristate "MMC/SD driver for Ricoh Bay1Controllers (EXPERIMENTAL)" | 321 | tristate "MMC/SD driver for Ricoh Bay1Controllers (EXPERIMENTAL)" |
281 | depends on EXPERIMENTAL && PCI && PCMCIA | 322 | depends on EXPERIMENTAL && PCI && PCMCIA |
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c index 3d1e5329da12..705a5894a6bb 100644 --- a/drivers/mmc/host/mmci.c +++ b/drivers/mmc/host/mmci.c | |||
@@ -678,7 +678,6 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id) | |||
678 | writel(0, host->base + MMCIMASK1); | 678 | writel(0, host->base + MMCIMASK1); |
679 | writel(0xfff, host->base + MMCICLEAR); | 679 | writel(0xfff, host->base + MMCICLEAR); |
680 | 680 | ||
681 | #ifdef CONFIG_GPIOLIB | ||
682 | if (gpio_is_valid(plat->gpio_cd)) { | 681 | if (gpio_is_valid(plat->gpio_cd)) { |
683 | ret = gpio_request(plat->gpio_cd, DRIVER_NAME " (cd)"); | 682 | ret = gpio_request(plat->gpio_cd, DRIVER_NAME " (cd)"); |
684 | if (ret == 0) | 683 | if (ret == 0) |
@@ -697,7 +696,6 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id) | |||
697 | else if (ret != -ENOSYS) | 696 | else if (ret != -ENOSYS) |
698 | goto err_gpio_wp; | 697 | goto err_gpio_wp; |
699 | } | 698 | } |
700 | #endif | ||
701 | 699 | ||
702 | ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host); | 700 | ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host); |
703 | if (ret) | 701 | if (ret) |
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c index 8c08cd7efa7f..99b74a351020 100644 --- a/drivers/mmc/host/s3cmci.c +++ b/drivers/mmc/host/s3cmci.c | |||
@@ -17,6 +17,8 @@ | |||
17 | #include <linux/mmc/host.h> | 17 | #include <linux/mmc/host.h> |
18 | #include <linux/platform_device.h> | 18 | #include <linux/platform_device.h> |
19 | #include <linux/cpufreq.h> | 19 | #include <linux/cpufreq.h> |
20 | #include <linux/debugfs.h> | ||
21 | #include <linux/seq_file.h> | ||
20 | #include <linux/gpio.h> | 22 | #include <linux/gpio.h> |
21 | #include <linux/irq.h> | 23 | #include <linux/irq.h> |
22 | #include <linux/io.h> | 24 | #include <linux/io.h> |
@@ -58,8 +60,6 @@ static const int dbgmap_debug = dbg_err | dbg_debug; | |||
58 | dev_dbg(&host->pdev->dev, args); \ | 60 | dev_dbg(&host->pdev->dev, args); \ |
59 | } while (0) | 61 | } while (0) |
60 | 62 | ||
61 | #define RESSIZE(ressource) (((ressource)->end - (ressource)->start)+1) | ||
62 | |||
63 | static struct s3c2410_dma_client s3cmci_dma_client = { | 63 | static struct s3c2410_dma_client s3cmci_dma_client = { |
64 | .name = "s3c-mci", | 64 | .name = "s3c-mci", |
65 | }; | 65 | }; |
@@ -164,6 +164,40 @@ static void dbg_dumpregs(struct s3cmci_host *host, char *prefix) { } | |||
164 | 164 | ||
165 | #endif /* CONFIG_MMC_DEBUG */ | 165 | #endif /* CONFIG_MMC_DEBUG */ |
166 | 166 | ||
167 | /** | ||
168 | * s3cmci_host_usedma - return whether the host is using dma or pio | ||
169 | * @host: The host state | ||
170 | * | ||
171 | * Return true if the host is using DMA to transfer data, else false | ||
172 | * to use PIO mode. Will return static data depending on the driver | ||
173 | * configuration. | ||
174 | */ | ||
175 | static inline bool s3cmci_host_usedma(struct s3cmci_host *host) | ||
176 | { | ||
177 | #ifdef CONFIG_MMC_S3C_PIO | ||
178 | return false; | ||
179 | #elif defined(CONFIG_MMC_S3C_DMA) | ||
180 | return true; | ||
181 | #else | ||
182 | return host->dodma; | ||
183 | #endif | ||
184 | } | ||
185 | |||
186 | /** | ||
187 | * s3cmci_host_canpio - return true if host has pio code available | ||
188 | * | ||
189 | * Return true if the driver has been compiled with the PIO support code | ||
190 | * available. | ||
191 | */ | ||
192 | static inline bool s3cmci_host_canpio(void) | ||
193 | { | ||
194 | #ifdef CONFIG_MMC_S3C_PIO | ||
195 | return true; | ||
196 | #else | ||
197 | return false; | ||
198 | #endif | ||
199 | } | ||
200 | |||
167 | static inline u32 enable_imask(struct s3cmci_host *host, u32 imask) | 201 | static inline u32 enable_imask(struct s3cmci_host *host, u32 imask) |
168 | { | 202 | { |
169 | u32 newmask; | 203 | u32 newmask; |
@@ -190,7 +224,33 @@ static inline u32 disable_imask(struct s3cmci_host *host, u32 imask) | |||
190 | 224 | ||
191 | static inline void clear_imask(struct s3cmci_host *host) | 225 | static inline void clear_imask(struct s3cmci_host *host) |
192 | { | 226 | { |
193 | writel(0, host->base + host->sdiimsk); | 227 | u32 mask = readl(host->base + host->sdiimsk); |
228 | |||
229 | /* preserve the SDIO IRQ mask state */ | ||
230 | mask &= S3C2410_SDIIMSK_SDIOIRQ; | ||
231 | writel(mask, host->base + host->sdiimsk); | ||
232 | } | ||
233 | |||
234 | /** | ||
235 | * s3cmci_check_sdio_irq - test whether the SDIO IRQ is being signalled | ||
236 | * @host: The host to check. | ||
237 | * | ||
238 | * Test to see if the SDIO interrupt is being signalled in case the | ||
239 | * controller has failed to re-detect a card interrupt. Read GPE8 and | ||
240 | * see if it is low and if so, signal a SDIO interrupt. | ||
241 | * | ||
242 | * This is currently called if a request is finished (we assume that the | ||
243 | * bus is now idle) and when the SDIO IRQ is enabled in case the IRQ is | ||
244 | * already being indicated. | ||
245 | */ | ||
246 | static void s3cmci_check_sdio_irq(struct s3cmci_host *host) | ||
247 | { | ||
248 | if (host->sdio_irqen) { | ||
249 | if (gpio_get_value(S3C2410_GPE(8)) == 0) { | ||
250 | printk(KERN_DEBUG "%s: signalling irq\n", __func__); | ||
251 | mmc_signal_sdio_irq(host->mmc); | ||
252 | } | ||
253 | } | ||
194 | } | 254 | } |
195 | 255 | ||
196 | static inline int get_data_buffer(struct s3cmci_host *host, | 256 | static inline int get_data_buffer(struct s3cmci_host *host, |
@@ -238,6 +298,64 @@ static inline u32 fifo_free(struct s3cmci_host *host) | |||
238 | return 63 - fifostat; | 298 | return 63 - fifostat; |
239 | } | 299 | } |
240 | 300 | ||
301 | /** | ||
302 | * s3cmci_enable_irq - enable IRQ, after having disabled it. | ||
303 | * @host: The device state. | ||
304 | * @more: True if more IRQs are expected from transfer. | ||
305 | * | ||
306 | * Enable the main IRQ if needed after it has been disabled. | ||
307 | * | ||
308 | * The IRQ can be one of the following states: | ||
309 | * - disabled during IDLE | ||
310 | * - disabled whilst processing data | ||
311 | * - enabled during transfer | ||
312 | * - enabled whilst awaiting SDIO interrupt detection | ||
313 | */ | ||
314 | static void s3cmci_enable_irq(struct s3cmci_host *host, bool more) | ||
315 | { | ||
316 | unsigned long flags; | ||
317 | bool enable = false; | ||
318 | |||
319 | local_irq_save(flags); | ||
320 | |||
321 | host->irq_enabled = more; | ||
322 | host->irq_disabled = false; | ||
323 | |||
324 | enable = more | host->sdio_irqen; | ||
325 | |||
326 | if (host->irq_state != enable) { | ||
327 | host->irq_state = enable; | ||
328 | |||
329 | if (enable) | ||
330 | enable_irq(host->irq); | ||
331 | else | ||
332 | disable_irq(host->irq); | ||
333 | } | ||
334 | |||
335 | local_irq_restore(flags); | ||
336 | } | ||
337 | |||
338 | /** | ||
339 | * | ||
340 | */ | ||
341 | static void s3cmci_disable_irq(struct s3cmci_host *host, bool transfer) | ||
342 | { | ||
343 | unsigned long flags; | ||
344 | |||
345 | local_irq_save(flags); | ||
346 | |||
347 | //printk(KERN_DEBUG "%s: transfer %d\n", __func__, transfer); | ||
348 | |||
349 | host->irq_disabled = transfer; | ||
350 | |||
351 | if (transfer && host->irq_state) { | ||
352 | host->irq_state = false; | ||
353 | disable_irq(host->irq); | ||
354 | } | ||
355 | |||
356 | local_irq_restore(flags); | ||
357 | } | ||
358 | |||
241 | static void do_pio_read(struct s3cmci_host *host) | 359 | static void do_pio_read(struct s3cmci_host *host) |
242 | { | 360 | { |
243 | int res; | 361 | int res; |
@@ -374,8 +492,7 @@ static void pio_tasklet(unsigned long data) | |||
374 | { | 492 | { |
375 | struct s3cmci_host *host = (struct s3cmci_host *) data; | 493 | struct s3cmci_host *host = (struct s3cmci_host *) data; |
376 | 494 | ||
377 | 495 | s3cmci_disable_irq(host, true); | |
378 | disable_irq(host->irq); | ||
379 | 496 | ||
380 | if (host->pio_active == XFER_WRITE) | 497 | if (host->pio_active == XFER_WRITE) |
381 | do_pio_write(host); | 498 | do_pio_write(host); |
@@ -395,9 +512,10 @@ static void pio_tasklet(unsigned long data) | |||
395 | host->mrq->data->error = -EINVAL; | 512 | host->mrq->data->error = -EINVAL; |
396 | } | 513 | } |
397 | 514 | ||
515 | s3cmci_enable_irq(host, false); | ||
398 | finalize_request(host); | 516 | finalize_request(host); |
399 | } else | 517 | } else |
400 | enable_irq(host->irq); | 518 | s3cmci_enable_irq(host, true); |
401 | } | 519 | } |
402 | 520 | ||
403 | /* | 521 | /* |
@@ -432,17 +550,27 @@ static irqreturn_t s3cmci_irq(int irq, void *dev_id) | |||
432 | struct s3cmci_host *host = dev_id; | 550 | struct s3cmci_host *host = dev_id; |
433 | struct mmc_command *cmd; | 551 | struct mmc_command *cmd; |
434 | u32 mci_csta, mci_dsta, mci_fsta, mci_dcnt, mci_imsk; | 552 | u32 mci_csta, mci_dsta, mci_fsta, mci_dcnt, mci_imsk; |
435 | u32 mci_cclear, mci_dclear; | 553 | u32 mci_cclear = 0, mci_dclear; |
436 | unsigned long iflags; | 554 | unsigned long iflags; |
437 | 555 | ||
556 | mci_dsta = readl(host->base + S3C2410_SDIDSTA); | ||
557 | mci_imsk = readl(host->base + host->sdiimsk); | ||
558 | |||
559 | if (mci_dsta & S3C2410_SDIDSTA_SDIOIRQDETECT) { | ||
560 | if (mci_imsk & S3C2410_SDIIMSK_SDIOIRQ) { | ||
561 | mci_dclear = S3C2410_SDIDSTA_SDIOIRQDETECT; | ||
562 | writel(mci_dclear, host->base + S3C2410_SDIDSTA); | ||
563 | |||
564 | mmc_signal_sdio_irq(host->mmc); | ||
565 | return IRQ_HANDLED; | ||
566 | } | ||
567 | } | ||
568 | |||
438 | spin_lock_irqsave(&host->complete_lock, iflags); | 569 | spin_lock_irqsave(&host->complete_lock, iflags); |
439 | 570 | ||
440 | mci_csta = readl(host->base + S3C2410_SDICMDSTAT); | 571 | mci_csta = readl(host->base + S3C2410_SDICMDSTAT); |
441 | mci_dsta = readl(host->base + S3C2410_SDIDSTA); | ||
442 | mci_dcnt = readl(host->base + S3C2410_SDIDCNT); | 572 | mci_dcnt = readl(host->base + S3C2410_SDIDCNT); |
443 | mci_fsta = readl(host->base + S3C2410_SDIFSTA); | 573 | mci_fsta = readl(host->base + S3C2410_SDIFSTA); |
444 | mci_imsk = readl(host->base + host->sdiimsk); | ||
445 | mci_cclear = 0; | ||
446 | mci_dclear = 0; | 574 | mci_dclear = 0; |
447 | 575 | ||
448 | if ((host->complete_what == COMPLETION_NONE) || | 576 | if ((host->complete_what == COMPLETION_NONE) || |
@@ -466,7 +594,7 @@ static irqreturn_t s3cmci_irq(int irq, void *dev_id) | |||
466 | goto irq_out; | 594 | goto irq_out; |
467 | } | 595 | } |
468 | 596 | ||
469 | if (!host->dodma) { | 597 | if (!s3cmci_host_usedma(host)) { |
470 | if ((host->pio_active == XFER_WRITE) && | 598 | if ((host->pio_active == XFER_WRITE) && |
471 | (mci_fsta & S3C2410_SDIFSTA_TFDET)) { | 599 | (mci_fsta & S3C2410_SDIFSTA_TFDET)) { |
472 | 600 | ||
@@ -673,6 +801,7 @@ static void s3cmci_dma_done_callback(struct s3c2410_dma_chan *dma_ch, | |||
673 | dbg(host, dbg_dma, "DMA FINISHED Size:%i DSTA:%08x DCNT:%08x\n", | 801 | dbg(host, dbg_dma, "DMA FINISHED Size:%i DSTA:%08x DCNT:%08x\n", |
674 | size, mci_dsta, mci_dcnt); | 802 | size, mci_dsta, mci_dcnt); |
675 | 803 | ||
804 | host->dma_complete = 1; | ||
676 | host->complete_what = COMPLETION_FINALIZE; | 805 | host->complete_what = COMPLETION_FINALIZE; |
677 | 806 | ||
678 | out: | 807 | out: |
@@ -683,9 +812,9 @@ out: | |||
683 | fail_request: | 812 | fail_request: |
684 | host->mrq->data->error = -EINVAL; | 813 | host->mrq->data->error = -EINVAL; |
685 | host->complete_what = COMPLETION_FINALIZE; | 814 | host->complete_what = COMPLETION_FINALIZE; |
686 | writel(0, host->base + host->sdiimsk); | 815 | clear_imask(host); |
687 | goto out; | ||
688 | 816 | ||
817 | goto out; | ||
689 | } | 818 | } |
690 | 819 | ||
691 | static void finalize_request(struct s3cmci_host *host) | 820 | static void finalize_request(struct s3cmci_host *host) |
@@ -702,8 +831,9 @@ static void finalize_request(struct s3cmci_host *host) | |||
702 | 831 | ||
703 | if (cmd->data && (cmd->error == 0) && | 832 | if (cmd->data && (cmd->error == 0) && |
704 | (cmd->data->error == 0)) { | 833 | (cmd->data->error == 0)) { |
705 | if (host->dodma && (!host->dma_complete)) { | 834 | if (s3cmci_host_usedma(host) && (!host->dma_complete)) { |
706 | dbg(host, dbg_dma, "DMA Missing!\n"); | 835 | dbg(host, dbg_dma, "DMA Missing (%d)!\n", |
836 | host->dma_complete); | ||
707 | return; | 837 | return; |
708 | } | 838 | } |
709 | } | 839 | } |
@@ -728,7 +858,7 @@ static void finalize_request(struct s3cmci_host *host) | |||
728 | writel(0, host->base + S3C2410_SDICMDARG); | 858 | writel(0, host->base + S3C2410_SDICMDARG); |
729 | writel(S3C2410_SDIDCON_STOP, host->base + S3C2410_SDIDCON); | 859 | writel(S3C2410_SDIDCON_STOP, host->base + S3C2410_SDIDCON); |
730 | writel(0, host->base + S3C2410_SDICMDCON); | 860 | writel(0, host->base + S3C2410_SDICMDCON); |
731 | writel(0, host->base + host->sdiimsk); | 861 | clear_imask(host); |
732 | 862 | ||
733 | if (cmd->data && cmd->error) | 863 | if (cmd->data && cmd->error) |
734 | cmd->data->error = cmd->error; | 864 | cmd->data->error = cmd->error; |
@@ -754,7 +884,7 @@ static void finalize_request(struct s3cmci_host *host) | |||
754 | /* If we had an error while transfering data we flush the | 884 | /* If we had an error while transfering data we flush the |
755 | * DMA channel and the fifo to clear out any garbage. */ | 885 | * DMA channel and the fifo to clear out any garbage. */ |
756 | if (mrq->data->error != 0) { | 886 | if (mrq->data->error != 0) { |
757 | if (host->dodma) | 887 | if (s3cmci_host_usedma(host)) |
758 | s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_FLUSH); | 888 | s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_FLUSH); |
759 | 889 | ||
760 | if (host->is2440) { | 890 | if (host->is2440) { |
@@ -776,6 +906,8 @@ static void finalize_request(struct s3cmci_host *host) | |||
776 | request_done: | 906 | request_done: |
777 | host->complete_what = COMPLETION_NONE; | 907 | host->complete_what = COMPLETION_NONE; |
778 | host->mrq = NULL; | 908 | host->mrq = NULL; |
909 | |||
910 | s3cmci_check_sdio_irq(host); | ||
779 | mmc_request_done(host->mmc, mrq); | 911 | mmc_request_done(host->mmc, mrq); |
780 | } | 912 | } |
781 | 913 | ||
@@ -872,7 +1004,7 @@ static int s3cmci_setup_data(struct s3cmci_host *host, struct mmc_data *data) | |||
872 | 1004 | ||
873 | dcon = data->blocks & S3C2410_SDIDCON_BLKNUM_MASK; | 1005 | dcon = data->blocks & S3C2410_SDIDCON_BLKNUM_MASK; |
874 | 1006 | ||
875 | if (host->dodma) | 1007 | if (s3cmci_host_usedma(host)) |
876 | dcon |= S3C2410_SDIDCON_DMAEN; | 1008 | dcon |= S3C2410_SDIDCON_DMAEN; |
877 | 1009 | ||
878 | if (host->bus_width == MMC_BUS_WIDTH_4) | 1010 | if (host->bus_width == MMC_BUS_WIDTH_4) |
@@ -950,7 +1082,7 @@ static int s3cmci_prepare_pio(struct s3cmci_host *host, struct mmc_data *data) | |||
950 | static int s3cmci_prepare_dma(struct s3cmci_host *host, struct mmc_data *data) | 1082 | static int s3cmci_prepare_dma(struct s3cmci_host *host, struct mmc_data *data) |
951 | { | 1083 | { |
952 | int dma_len, i; | 1084 | int dma_len, i; |
953 | int rw = (data->flags & MMC_DATA_WRITE) ? 1 : 0; | 1085 | int rw = data->flags & MMC_DATA_WRITE; |
954 | 1086 | ||
955 | BUG_ON((data->flags & BOTH_DIR) == BOTH_DIR); | 1087 | BUG_ON((data->flags & BOTH_DIR) == BOTH_DIR); |
956 | 1088 | ||
@@ -958,7 +1090,7 @@ static int s3cmci_prepare_dma(struct s3cmci_host *host, struct mmc_data *data) | |||
958 | s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_FLUSH); | 1090 | s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_FLUSH); |
959 | 1091 | ||
960 | dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len, | 1092 | dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len, |
961 | (rw) ? DMA_TO_DEVICE : DMA_FROM_DEVICE); | 1093 | rw ? DMA_TO_DEVICE : DMA_FROM_DEVICE); |
962 | 1094 | ||
963 | if (dma_len == 0) | 1095 | if (dma_len == 0) |
964 | return -ENOMEM; | 1096 | return -ENOMEM; |
@@ -969,11 +1101,11 @@ static int s3cmci_prepare_dma(struct s3cmci_host *host, struct mmc_data *data) | |||
969 | for (i = 0; i < dma_len; i++) { | 1101 | for (i = 0; i < dma_len; i++) { |
970 | int res; | 1102 | int res; |
971 | 1103 | ||
972 | dbg(host, dbg_dma, "enqueue %i:%u@%u\n", i, | 1104 | dbg(host, dbg_dma, "enqueue %i: %08x@%u\n", i, |
973 | sg_dma_address(&data->sg[i]), | 1105 | sg_dma_address(&data->sg[i]), |
974 | sg_dma_len(&data->sg[i])); | 1106 | sg_dma_len(&data->sg[i])); |
975 | 1107 | ||
976 | res = s3c2410_dma_enqueue(host->dma, (void *) host, | 1108 | res = s3c2410_dma_enqueue(host->dma, host, |
977 | sg_dma_address(&data->sg[i]), | 1109 | sg_dma_address(&data->sg[i]), |
978 | sg_dma_len(&data->sg[i])); | 1110 | sg_dma_len(&data->sg[i])); |
979 | 1111 | ||
@@ -1018,7 +1150,7 @@ static void s3cmci_send_request(struct mmc_host *mmc) | |||
1018 | return; | 1150 | return; |
1019 | } | 1151 | } |
1020 | 1152 | ||
1021 | if (host->dodma) | 1153 | if (s3cmci_host_usedma(host)) |
1022 | res = s3cmci_prepare_dma(host, cmd->data); | 1154 | res = s3cmci_prepare_dma(host, cmd->data); |
1023 | else | 1155 | else |
1024 | res = s3cmci_prepare_pio(host, cmd->data); | 1156 | res = s3cmci_prepare_pio(host, cmd->data); |
@@ -1037,7 +1169,7 @@ static void s3cmci_send_request(struct mmc_host *mmc) | |||
1037 | s3cmci_send_command(host, cmd); | 1169 | s3cmci_send_command(host, cmd); |
1038 | 1170 | ||
1039 | /* Enable Interrupt */ | 1171 | /* Enable Interrupt */ |
1040 | enable_irq(host->irq); | 1172 | s3cmci_enable_irq(host, true); |
1041 | } | 1173 | } |
1042 | 1174 | ||
1043 | static int s3cmci_card_present(struct mmc_host *mmc) | 1175 | static int s3cmci_card_present(struct mmc_host *mmc) |
@@ -1049,7 +1181,7 @@ static int s3cmci_card_present(struct mmc_host *mmc) | |||
1049 | if (pdata->gpio_detect == 0) | 1181 | if (pdata->gpio_detect == 0) |
1050 | return -ENOSYS; | 1182 | return -ENOSYS; |
1051 | 1183 | ||
1052 | ret = s3c2410_gpio_getpin(pdata->gpio_detect) ? 0 : 1; | 1184 | ret = gpio_get_value(pdata->gpio_detect) ? 0 : 1; |
1053 | return ret ^ pdata->detect_invert; | 1185 | return ret ^ pdata->detect_invert; |
1054 | } | 1186 | } |
1055 | 1187 | ||
@@ -1104,12 +1236,12 @@ static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) | |||
1104 | switch (ios->power_mode) { | 1236 | switch (ios->power_mode) { |
1105 | case MMC_POWER_ON: | 1237 | case MMC_POWER_ON: |
1106 | case MMC_POWER_UP: | 1238 | case MMC_POWER_UP: |
1107 | s3c2410_gpio_cfgpin(S3C2410_GPE5, S3C2410_GPE5_SDCLK); | 1239 | s3c2410_gpio_cfgpin(S3C2410_GPE(5), S3C2410_GPE5_SDCLK); |
1108 | s3c2410_gpio_cfgpin(S3C2410_GPE6, S3C2410_GPE6_SDCMD); | 1240 | s3c2410_gpio_cfgpin(S3C2410_GPE(6), S3C2410_GPE6_SDCMD); |
1109 | s3c2410_gpio_cfgpin(S3C2410_GPE7, S3C2410_GPE7_SDDAT0); | 1241 | s3c2410_gpio_cfgpin(S3C2410_GPE(7), S3C2410_GPE7_SDDAT0); |
1110 | s3c2410_gpio_cfgpin(S3C2410_GPE8, S3C2410_GPE8_SDDAT1); | 1242 | s3c2410_gpio_cfgpin(S3C2410_GPE(8), S3C2410_GPE8_SDDAT1); |
1111 | s3c2410_gpio_cfgpin(S3C2410_GPE9, S3C2410_GPE9_SDDAT2); | 1243 | s3c2410_gpio_cfgpin(S3C2410_GPE(9), S3C2410_GPE9_SDDAT2); |
1112 | s3c2410_gpio_cfgpin(S3C2410_GPE10, S3C2410_GPE10_SDDAT3); | 1244 | s3c2410_gpio_cfgpin(S3C2410_GPE(10), S3C2410_GPE10_SDDAT3); |
1113 | 1245 | ||
1114 | if (host->pdata->set_power) | 1246 | if (host->pdata->set_power) |
1115 | host->pdata->set_power(ios->power_mode, ios->vdd); | 1247 | host->pdata->set_power(ios->power_mode, ios->vdd); |
@@ -1121,8 +1253,7 @@ static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) | |||
1121 | 1253 | ||
1122 | case MMC_POWER_OFF: | 1254 | case MMC_POWER_OFF: |
1123 | default: | 1255 | default: |
1124 | s3c2410_gpio_setpin(S3C2410_GPE5, 0); | 1256 | gpio_direction_output(S3C2410_GPE(5), 0); |
1125 | s3c2410_gpio_cfgpin(S3C2410_GPE5, S3C2410_GPIO_OUTPUT); | ||
1126 | 1257 | ||
1127 | if (host->is2440) | 1258 | if (host->is2440) |
1128 | mci_con |= S3C2440_SDICON_SDRESET; | 1259 | mci_con |= S3C2440_SDICON_SDRESET; |
@@ -1168,7 +1299,7 @@ static int s3cmci_get_ro(struct mmc_host *mmc) | |||
1168 | struct s3c24xx_mci_pdata *pdata = host->pdata; | 1299 | struct s3c24xx_mci_pdata *pdata = host->pdata; |
1169 | int ret; | 1300 | int ret; |
1170 | 1301 | ||
1171 | if (pdata->gpio_wprotect == 0) | 1302 | if (pdata->no_wprotect) |
1172 | return 0; | 1303 | return 0; |
1173 | 1304 | ||
1174 | ret = s3c2410_gpio_getpin(pdata->gpio_wprotect); | 1305 | ret = s3c2410_gpio_getpin(pdata->gpio_wprotect); |
@@ -1179,11 +1310,52 @@ static int s3cmci_get_ro(struct mmc_host *mmc) | |||
1179 | return ret; | 1310 | return ret; |
1180 | } | 1311 | } |
1181 | 1312 | ||
1313 | static void s3cmci_enable_sdio_irq(struct mmc_host *mmc, int enable) | ||
1314 | { | ||
1315 | struct s3cmci_host *host = mmc_priv(mmc); | ||
1316 | unsigned long flags; | ||
1317 | u32 con; | ||
1318 | |||
1319 | local_irq_save(flags); | ||
1320 | |||
1321 | con = readl(host->base + S3C2410_SDICON); | ||
1322 | host->sdio_irqen = enable; | ||
1323 | |||
1324 | if (enable == host->sdio_irqen) | ||
1325 | goto same_state; | ||
1326 | |||
1327 | if (enable) { | ||
1328 | con |= S3C2410_SDICON_SDIOIRQ; | ||
1329 | enable_imask(host, S3C2410_SDIIMSK_SDIOIRQ); | ||
1330 | |||
1331 | if (!host->irq_state && !host->irq_disabled) { | ||
1332 | host->irq_state = true; | ||
1333 | enable_irq(host->irq); | ||
1334 | } | ||
1335 | } else { | ||
1336 | disable_imask(host, S3C2410_SDIIMSK_SDIOIRQ); | ||
1337 | con &= ~S3C2410_SDICON_SDIOIRQ; | ||
1338 | |||
1339 | if (!host->irq_enabled && host->irq_state) { | ||
1340 | disable_irq_nosync(host->irq); | ||
1341 | host->irq_state = false; | ||
1342 | } | ||
1343 | } | ||
1344 | |||
1345 | writel(con, host->base + S3C2410_SDICON); | ||
1346 | |||
1347 | same_state: | ||
1348 | local_irq_restore(flags); | ||
1349 | |||
1350 | s3cmci_check_sdio_irq(host); | ||
1351 | } | ||
1352 | |||
1182 | static struct mmc_host_ops s3cmci_ops = { | 1353 | static struct mmc_host_ops s3cmci_ops = { |
1183 | .request = s3cmci_request, | 1354 | .request = s3cmci_request, |
1184 | .set_ios = s3cmci_set_ios, | 1355 | .set_ios = s3cmci_set_ios, |
1185 | .get_ro = s3cmci_get_ro, | 1356 | .get_ro = s3cmci_get_ro, |
1186 | .get_cd = s3cmci_card_present, | 1357 | .get_cd = s3cmci_card_present, |
1358 | .enable_sdio_irq = s3cmci_enable_sdio_irq, | ||
1187 | }; | 1359 | }; |
1188 | 1360 | ||
1189 | static struct s3c24xx_mci_pdata s3cmci_def_pdata = { | 1361 | static struct s3c24xx_mci_pdata s3cmci_def_pdata = { |
@@ -1246,11 +1418,140 @@ static inline void s3cmci_cpufreq_deregister(struct s3cmci_host *host) | |||
1246 | } | 1418 | } |
1247 | #endif | 1419 | #endif |
1248 | 1420 | ||
1249 | static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | 1421 | |
1422 | #ifdef CONFIG_DEBUG_FS | ||
1423 | |||
1424 | static int s3cmci_state_show(struct seq_file *seq, void *v) | ||
1425 | { | ||
1426 | struct s3cmci_host *host = seq->private; | ||
1427 | |||
1428 | seq_printf(seq, "Register base = 0x%08x\n", (u32)host->base); | ||
1429 | seq_printf(seq, "Clock rate = %ld\n", host->clk_rate); | ||
1430 | seq_printf(seq, "Prescale = %d\n", host->prescaler); | ||
1431 | seq_printf(seq, "is2440 = %d\n", host->is2440); | ||
1432 | seq_printf(seq, "IRQ = %d\n", host->irq); | ||
1433 | seq_printf(seq, "IRQ enabled = %d\n", host->irq_enabled); | ||
1434 | seq_printf(seq, "IRQ disabled = %d\n", host->irq_disabled); | ||
1435 | seq_printf(seq, "IRQ state = %d\n", host->irq_state); | ||
1436 | seq_printf(seq, "CD IRQ = %d\n", host->irq_cd); | ||
1437 | seq_printf(seq, "Do DMA = %d\n", s3cmci_host_usedma(host)); | ||
1438 | seq_printf(seq, "SDIIMSK at %d\n", host->sdiimsk); | ||
1439 | seq_printf(seq, "SDIDATA at %d\n", host->sdidata); | ||
1440 | |||
1441 | return 0; | ||
1442 | } | ||
1443 | |||
1444 | static int s3cmci_state_open(struct inode *inode, struct file *file) | ||
1445 | { | ||
1446 | return single_open(file, s3cmci_state_show, inode->i_private); | ||
1447 | } | ||
1448 | |||
1449 | static const struct file_operations s3cmci_fops_state = { | ||
1450 | .owner = THIS_MODULE, | ||
1451 | .open = s3cmci_state_open, | ||
1452 | .read = seq_read, | ||
1453 | .llseek = seq_lseek, | ||
1454 | .release = single_release, | ||
1455 | }; | ||
1456 | |||
1457 | #define DBG_REG(_r) { .addr = S3C2410_SDI##_r, .name = #_r } | ||
1458 | |||
1459 | struct s3cmci_reg { | ||
1460 | unsigned short addr; | ||
1461 | unsigned char *name; | ||
1462 | } debug_regs[] = { | ||
1463 | DBG_REG(CON), | ||
1464 | DBG_REG(PRE), | ||
1465 | DBG_REG(CMDARG), | ||
1466 | DBG_REG(CMDCON), | ||
1467 | DBG_REG(CMDSTAT), | ||
1468 | DBG_REG(RSP0), | ||
1469 | DBG_REG(RSP1), | ||
1470 | DBG_REG(RSP2), | ||
1471 | DBG_REG(RSP3), | ||
1472 | DBG_REG(TIMER), | ||
1473 | DBG_REG(BSIZE), | ||
1474 | DBG_REG(DCON), | ||
1475 | DBG_REG(DCNT), | ||
1476 | DBG_REG(DSTA), | ||
1477 | DBG_REG(FSTA), | ||
1478 | {} | ||
1479 | }; | ||
1480 | |||
1481 | static int s3cmci_regs_show(struct seq_file *seq, void *v) | ||
1482 | { | ||
1483 | struct s3cmci_host *host = seq->private; | ||
1484 | struct s3cmci_reg *rptr = debug_regs; | ||
1485 | |||
1486 | for (; rptr->name; rptr++) | ||
1487 | seq_printf(seq, "SDI%s\t=0x%08x\n", rptr->name, | ||
1488 | readl(host->base + rptr->addr)); | ||
1489 | |||
1490 | seq_printf(seq, "SDIIMSK\t=0x%08x\n", readl(host->base + host->sdiimsk)); | ||
1491 | |||
1492 | return 0; | ||
1493 | } | ||
1494 | |||
1495 | static int s3cmci_regs_open(struct inode *inode, struct file *file) | ||
1496 | { | ||
1497 | return single_open(file, s3cmci_regs_show, inode->i_private); | ||
1498 | } | ||
1499 | |||
1500 | static const struct file_operations s3cmci_fops_regs = { | ||
1501 | .owner = THIS_MODULE, | ||
1502 | .open = s3cmci_regs_open, | ||
1503 | .read = seq_read, | ||
1504 | .llseek = seq_lseek, | ||
1505 | .release = single_release, | ||
1506 | }; | ||
1507 | |||
1508 | static void s3cmci_debugfs_attach(struct s3cmci_host *host) | ||
1509 | { | ||
1510 | struct device *dev = &host->pdev->dev; | ||
1511 | |||
1512 | host->debug_root = debugfs_create_dir(dev_name(dev), NULL); | ||
1513 | if (IS_ERR(host->debug_root)) { | ||
1514 | dev_err(dev, "failed to create debugfs root\n"); | ||
1515 | return; | ||
1516 | } | ||
1517 | |||
1518 | host->debug_state = debugfs_create_file("state", 0444, | ||
1519 | host->debug_root, host, | ||
1520 | &s3cmci_fops_state); | ||
1521 | |||
1522 | if (IS_ERR(host->debug_state)) | ||
1523 | dev_err(dev, "failed to create debug state file\n"); | ||
1524 | |||
1525 | host->debug_regs = debugfs_create_file("regs", 0444, | ||
1526 | host->debug_root, host, | ||
1527 | &s3cmci_fops_regs); | ||
1528 | |||
1529 | if (IS_ERR(host->debug_regs)) | ||
1530 | dev_err(dev, "failed to create debug regs file\n"); | ||
1531 | } | ||
1532 | |||
1533 | static void s3cmci_debugfs_remove(struct s3cmci_host *host) | ||
1534 | { | ||
1535 | debugfs_remove(host->debug_regs); | ||
1536 | debugfs_remove(host->debug_state); | ||
1537 | debugfs_remove(host->debug_root); | ||
1538 | } | ||
1539 | |||
1540 | #else | ||
1541 | static inline void s3cmci_debugfs_attach(struct s3cmci_host *host) { } | ||
1542 | static inline void s3cmci_debugfs_remove(struct s3cmci_host *host) { } | ||
1543 | |||
1544 | #endif /* CONFIG_DEBUG_FS */ | ||
1545 | |||
1546 | static int __devinit s3cmci_probe(struct platform_device *pdev) | ||
1250 | { | 1547 | { |
1251 | struct s3cmci_host *host; | 1548 | struct s3cmci_host *host; |
1252 | struct mmc_host *mmc; | 1549 | struct mmc_host *mmc; |
1253 | int ret; | 1550 | int ret; |
1551 | int is2440; | ||
1552 | int i; | ||
1553 | |||
1554 | is2440 = platform_get_device_id(pdev)->driver_data; | ||
1254 | 1555 | ||
1255 | mmc = mmc_alloc_host(sizeof(struct s3cmci_host), &pdev->dev); | 1556 | mmc = mmc_alloc_host(sizeof(struct s3cmci_host), &pdev->dev); |
1256 | if (!mmc) { | 1557 | if (!mmc) { |
@@ -1258,6 +1559,18 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1258 | goto probe_out; | 1559 | goto probe_out; |
1259 | } | 1560 | } |
1260 | 1561 | ||
1562 | for (i = S3C2410_GPE(5); i <= S3C2410_GPE(10); i++) { | ||
1563 | ret = gpio_request(i, dev_name(&pdev->dev)); | ||
1564 | if (ret) { | ||
1565 | dev_err(&pdev->dev, "failed to get gpio %d\n", i); | ||
1566 | |||
1567 | for (i--; i >= S3C2410_GPE(5); i--) | ||
1568 | gpio_free(i); | ||
1569 | |||
1570 | goto probe_free_host; | ||
1571 | } | ||
1572 | } | ||
1573 | |||
1261 | host = mmc_priv(mmc); | 1574 | host = mmc_priv(mmc); |
1262 | host->mmc = mmc; | 1575 | host->mmc = mmc; |
1263 | host->pdev = pdev; | 1576 | host->pdev = pdev; |
@@ -1282,11 +1595,12 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1282 | host->clk_div = 2; | 1595 | host->clk_div = 2; |
1283 | } | 1596 | } |
1284 | 1597 | ||
1285 | host->dodma = 0; | ||
1286 | host->complete_what = COMPLETION_NONE; | 1598 | host->complete_what = COMPLETION_NONE; |
1287 | host->pio_active = XFER_NONE; | 1599 | host->pio_active = XFER_NONE; |
1288 | 1600 | ||
1289 | host->dma = S3CMCI_DMA; | 1601 | #ifdef CONFIG_MMC_S3C_PIODMA |
1602 | host->dodma = host->pdata->dma; | ||
1603 | #endif | ||
1290 | 1604 | ||
1291 | host->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); | 1605 | host->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
1292 | if (!host->mem) { | 1606 | if (!host->mem) { |
@@ -1294,19 +1608,19 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1294 | "failed to get io memory region resouce.\n"); | 1608 | "failed to get io memory region resouce.\n"); |
1295 | 1609 | ||
1296 | ret = -ENOENT; | 1610 | ret = -ENOENT; |
1297 | goto probe_free_host; | 1611 | goto probe_free_gpio; |
1298 | } | 1612 | } |
1299 | 1613 | ||
1300 | host->mem = request_mem_region(host->mem->start, | 1614 | host->mem = request_mem_region(host->mem->start, |
1301 | RESSIZE(host->mem), pdev->name); | 1615 | resource_size(host->mem), pdev->name); |
1302 | 1616 | ||
1303 | if (!host->mem) { | 1617 | if (!host->mem) { |
1304 | dev_err(&pdev->dev, "failed to request io memory region.\n"); | 1618 | dev_err(&pdev->dev, "failed to request io memory region.\n"); |
1305 | ret = -ENOENT; | 1619 | ret = -ENOENT; |
1306 | goto probe_free_host; | 1620 | goto probe_free_gpio; |
1307 | } | 1621 | } |
1308 | 1622 | ||
1309 | host->base = ioremap(host->mem->start, RESSIZE(host->mem)); | 1623 | host->base = ioremap(host->mem->start, resource_size(host->mem)); |
1310 | if (!host->base) { | 1624 | if (!host->base) { |
1311 | dev_err(&pdev->dev, "failed to ioremap() io memory region.\n"); | 1625 | dev_err(&pdev->dev, "failed to ioremap() io memory region.\n"); |
1312 | ret = -EINVAL; | 1626 | ret = -EINVAL; |
@@ -1331,31 +1645,60 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1331 | * ensure we don't lock the system with un-serviceable requests. */ | 1645 | * ensure we don't lock the system with un-serviceable requests. */ |
1332 | 1646 | ||
1333 | disable_irq(host->irq); | 1647 | disable_irq(host->irq); |
1648 | host->irq_state = false; | ||
1334 | 1649 | ||
1335 | host->irq_cd = s3c2410_gpio_getirq(host->pdata->gpio_detect); | 1650 | if (!host->pdata->no_detect) { |
1336 | 1651 | ret = gpio_request(host->pdata->gpio_detect, "s3cmci detect"); | |
1337 | if (host->irq_cd >= 0) { | 1652 | if (ret) { |
1338 | if (request_irq(host->irq_cd, s3cmci_irq_cd, | 1653 | dev_err(&pdev->dev, "failed to get detect gpio\n"); |
1339 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, | ||
1340 | DRIVER_NAME, host)) { | ||
1341 | dev_err(&pdev->dev, "can't get card detect irq.\n"); | ||
1342 | ret = -ENOENT; | ||
1343 | goto probe_free_irq; | 1654 | goto probe_free_irq; |
1344 | } | 1655 | } |
1345 | } else { | 1656 | |
1346 | dev_warn(&pdev->dev, "host detect has no irq available\n"); | 1657 | host->irq_cd = s3c2410_gpio_getirq(host->pdata->gpio_detect); |
1347 | s3c2410_gpio_cfgpin(host->pdata->gpio_detect, | 1658 | |
1348 | S3C2410_GPIO_INPUT); | 1659 | if (host->irq_cd >= 0) { |
1660 | if (request_irq(host->irq_cd, s3cmci_irq_cd, | ||
1661 | IRQF_TRIGGER_RISING | | ||
1662 | IRQF_TRIGGER_FALLING, | ||
1663 | DRIVER_NAME, host)) { | ||
1664 | dev_err(&pdev->dev, | ||
1665 | "can't get card detect irq.\n"); | ||
1666 | ret = -ENOENT; | ||
1667 | goto probe_free_gpio_cd; | ||
1668 | } | ||
1669 | } else { | ||
1670 | dev_warn(&pdev->dev, | ||
1671 | "host detect has no irq available\n"); | ||
1672 | gpio_direction_input(host->pdata->gpio_detect); | ||
1673 | } | ||
1674 | } else | ||
1675 | host->irq_cd = -1; | ||
1676 | |||
1677 | if (!host->pdata->no_wprotect) { | ||
1678 | ret = gpio_request(host->pdata->gpio_wprotect, "s3cmci wp"); | ||
1679 | if (ret) { | ||
1680 | dev_err(&pdev->dev, "failed to get writeprotect\n"); | ||
1681 | goto probe_free_irq_cd; | ||
1682 | } | ||
1683 | |||
1684 | gpio_direction_input(host->pdata->gpio_wprotect); | ||
1349 | } | 1685 | } |
1350 | 1686 | ||
1351 | if (host->pdata->gpio_wprotect) | 1687 | /* depending on the dma state, get a dma channel to use. */ |
1352 | s3c2410_gpio_cfgpin(host->pdata->gpio_wprotect, | ||
1353 | S3C2410_GPIO_INPUT); | ||
1354 | 1688 | ||
1355 | if (s3c2410_dma_request(S3CMCI_DMA, &s3cmci_dma_client, NULL) < 0) { | 1689 | if (s3cmci_host_usedma(host)) { |
1356 | dev_err(&pdev->dev, "unable to get DMA channel.\n"); | 1690 | host->dma = s3c2410_dma_request(DMACH_SDI, &s3cmci_dma_client, |
1357 | ret = -EBUSY; | 1691 | host); |
1358 | goto probe_free_irq_cd; | 1692 | if (host->dma < 0) { |
1693 | dev_err(&pdev->dev, "cannot get DMA channel.\n"); | ||
1694 | if (!s3cmci_host_canpio()) { | ||
1695 | ret = -EBUSY; | ||
1696 | goto probe_free_gpio_wp; | ||
1697 | } else { | ||
1698 | dev_warn(&pdev->dev, "falling back to PIO.\n"); | ||
1699 | host->dodma = 0; | ||
1700 | } | ||
1701 | } | ||
1359 | } | 1702 | } |
1360 | 1703 | ||
1361 | host->clk = clk_get(&pdev->dev, "sdi"); | 1704 | host->clk = clk_get(&pdev->dev, "sdi"); |
@@ -1363,7 +1706,7 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1363 | dev_err(&pdev->dev, "failed to find clock source.\n"); | 1706 | dev_err(&pdev->dev, "failed to find clock source.\n"); |
1364 | ret = PTR_ERR(host->clk); | 1707 | ret = PTR_ERR(host->clk); |
1365 | host->clk = NULL; | 1708 | host->clk = NULL; |
1366 | goto probe_free_host; | 1709 | goto probe_free_dma; |
1367 | } | 1710 | } |
1368 | 1711 | ||
1369 | ret = clk_enable(host->clk); | 1712 | ret = clk_enable(host->clk); |
@@ -1376,7 +1719,11 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1376 | 1719 | ||
1377 | mmc->ops = &s3cmci_ops; | 1720 | mmc->ops = &s3cmci_ops; |
1378 | mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; | 1721 | mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; |
1722 | #ifdef CONFIG_MMC_S3C_HW_SDIO_IRQ | ||
1723 | mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ; | ||
1724 | #else | ||
1379 | mmc->caps = MMC_CAP_4_BIT_DATA; | 1725 | mmc->caps = MMC_CAP_4_BIT_DATA; |
1726 | #endif | ||
1380 | mmc->f_min = host->clk_rate / (host->clk_div * 256); | 1727 | mmc->f_min = host->clk_rate / (host->clk_div * 256); |
1381 | mmc->f_max = host->clk_rate / host->clk_div; | 1728 | mmc->f_max = host->clk_rate / host->clk_div; |
1382 | 1729 | ||
@@ -1408,8 +1755,12 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1408 | goto free_cpufreq; | 1755 | goto free_cpufreq; |
1409 | } | 1756 | } |
1410 | 1757 | ||
1758 | s3cmci_debugfs_attach(host); | ||
1759 | |||
1411 | platform_set_drvdata(pdev, mmc); | 1760 | platform_set_drvdata(pdev, mmc); |
1412 | dev_info(&pdev->dev, "initialisation done.\n"); | 1761 | dev_info(&pdev->dev, "%s - using %s, %s SDIO IRQ\n", mmc_hostname(mmc), |
1762 | s3cmci_host_usedma(host) ? "dma" : "pio", | ||
1763 | mmc->caps & MMC_CAP_SDIO_IRQ ? "hw" : "sw"); | ||
1413 | 1764 | ||
1414 | return 0; | 1765 | return 0; |
1415 | 1766 | ||
@@ -1422,6 +1773,18 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1422 | clk_free: | 1773 | clk_free: |
1423 | clk_put(host->clk); | 1774 | clk_put(host->clk); |
1424 | 1775 | ||
1776 | probe_free_dma: | ||
1777 | if (s3cmci_host_usedma(host)) | ||
1778 | s3c2410_dma_free(host->dma, &s3cmci_dma_client); | ||
1779 | |||
1780 | probe_free_gpio_wp: | ||
1781 | if (!host->pdata->no_wprotect) | ||
1782 | gpio_free(host->pdata->gpio_wprotect); | ||
1783 | |||
1784 | probe_free_gpio_cd: | ||
1785 | if (!host->pdata->no_detect) | ||
1786 | gpio_free(host->pdata->gpio_detect); | ||
1787 | |||
1425 | probe_free_irq_cd: | 1788 | probe_free_irq_cd: |
1426 | if (host->irq_cd >= 0) | 1789 | if (host->irq_cd >= 0) |
1427 | free_irq(host->irq_cd, host); | 1790 | free_irq(host->irq_cd, host); |
@@ -1433,10 +1796,15 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440) | |||
1433 | iounmap(host->base); | 1796 | iounmap(host->base); |
1434 | 1797 | ||
1435 | probe_free_mem_region: | 1798 | probe_free_mem_region: |
1436 | release_mem_region(host->mem->start, RESSIZE(host->mem)); | 1799 | release_mem_region(host->mem->start, resource_size(host->mem)); |
1800 | |||
1801 | probe_free_gpio: | ||
1802 | for (i = S3C2410_GPE(5); i <= S3C2410_GPE(10); i++) | ||
1803 | gpio_free(i); | ||
1437 | 1804 | ||
1438 | probe_free_host: | 1805 | probe_free_host: |
1439 | mmc_free_host(mmc); | 1806 | mmc_free_host(mmc); |
1807 | |||
1440 | probe_out: | 1808 | probe_out: |
1441 | return ret; | 1809 | return ret; |
1442 | } | 1810 | } |
@@ -1449,6 +1817,7 @@ static void s3cmci_shutdown(struct platform_device *pdev) | |||
1449 | if (host->irq_cd >= 0) | 1817 | if (host->irq_cd >= 0) |
1450 | free_irq(host->irq_cd, host); | 1818 | free_irq(host->irq_cd, host); |
1451 | 1819 | ||
1820 | s3cmci_debugfs_remove(host); | ||
1452 | s3cmci_cpufreq_deregister(host); | 1821 | s3cmci_cpufreq_deregister(host); |
1453 | mmc_remove_host(mmc); | 1822 | mmc_remove_host(mmc); |
1454 | clk_disable(host->clk); | 1823 | clk_disable(host->clk); |
@@ -1458,104 +1827,102 @@ static int __devexit s3cmci_remove(struct platform_device *pdev) | |||
1458 | { | 1827 | { |
1459 | struct mmc_host *mmc = platform_get_drvdata(pdev); | 1828 | struct mmc_host *mmc = platform_get_drvdata(pdev); |
1460 | struct s3cmci_host *host = mmc_priv(mmc); | 1829 | struct s3cmci_host *host = mmc_priv(mmc); |
1830 | struct s3c24xx_mci_pdata *pd = host->pdata; | ||
1831 | int i; | ||
1461 | 1832 | ||
1462 | s3cmci_shutdown(pdev); | 1833 | s3cmci_shutdown(pdev); |
1463 | 1834 | ||
1464 | clk_put(host->clk); | 1835 | clk_put(host->clk); |
1465 | 1836 | ||
1466 | tasklet_disable(&host->pio_tasklet); | 1837 | tasklet_disable(&host->pio_tasklet); |
1467 | s3c2410_dma_free(S3CMCI_DMA, &s3cmci_dma_client); | 1838 | |
1839 | if (s3cmci_host_usedma(host)) | ||
1840 | s3c2410_dma_free(host->dma, &s3cmci_dma_client); | ||
1468 | 1841 | ||
1469 | free_irq(host->irq, host); | 1842 | free_irq(host->irq, host); |
1470 | 1843 | ||
1844 | if (!pd->no_wprotect) | ||
1845 | gpio_free(pd->gpio_wprotect); | ||
1846 | |||
1847 | if (!pd->no_detect) | ||
1848 | gpio_free(pd->gpio_detect); | ||
1849 | |||
1850 | for (i = S3C2410_GPE(5); i <= S3C2410_GPE(10); i++) | ||
1851 | gpio_free(i); | ||
1852 | |||
1853 | |||
1471 | iounmap(host->base); | 1854 | iounmap(host->base); |
1472 | release_mem_region(host->mem->start, RESSIZE(host->mem)); | 1855 | release_mem_region(host->mem->start, resource_size(host->mem)); |
1473 | 1856 | ||
1474 | mmc_free_host(mmc); | 1857 | mmc_free_host(mmc); |
1475 | return 0; | 1858 | return 0; |
1476 | } | 1859 | } |
1477 | 1860 | ||
1478 | static int __devinit s3cmci_2410_probe(struct platform_device *dev) | 1861 | static struct platform_device_id s3cmci_driver_ids[] = { |
1479 | { | 1862 | { |
1480 | return s3cmci_probe(dev, 0); | 1863 | .name = "s3c2410-sdi", |
1481 | } | 1864 | .driver_data = 0, |
1865 | }, { | ||
1866 | .name = "s3c2412-sdi", | ||
1867 | .driver_data = 1, | ||
1868 | }, { | ||
1869 | .name = "s3c2440-sdi", | ||
1870 | .driver_data = 1, | ||
1871 | }, | ||
1872 | { } | ||
1873 | }; | ||
1482 | 1874 | ||
1483 | static int __devinit s3cmci_2412_probe(struct platform_device *dev) | 1875 | MODULE_DEVICE_TABLE(platform, s3cmci_driver_ids); |
1484 | { | ||
1485 | return s3cmci_probe(dev, 1); | ||
1486 | } | ||
1487 | 1876 | ||
1488 | static int __devinit s3cmci_2440_probe(struct platform_device *dev) | ||
1489 | { | ||
1490 | return s3cmci_probe(dev, 1); | ||
1491 | } | ||
1492 | 1877 | ||
1493 | #ifdef CONFIG_PM | 1878 | #ifdef CONFIG_PM |
1494 | 1879 | ||
1495 | static int s3cmci_suspend(struct platform_device *dev, pm_message_t state) | 1880 | static int s3cmci_suspend(struct device *dev) |
1496 | { | 1881 | { |
1497 | struct mmc_host *mmc = platform_get_drvdata(dev); | 1882 | struct mmc_host *mmc = platform_get_drvdata(to_platform_device(dev)); |
1883 | struct pm_message event = { PM_EVENT_SUSPEND }; | ||
1498 | 1884 | ||
1499 | return mmc_suspend_host(mmc, state); | 1885 | return mmc_suspend_host(mmc, event); |
1500 | } | 1886 | } |
1501 | 1887 | ||
1502 | static int s3cmci_resume(struct platform_device *dev) | 1888 | static int s3cmci_resume(struct device *dev) |
1503 | { | 1889 | { |
1504 | struct mmc_host *mmc = platform_get_drvdata(dev); | 1890 | struct mmc_host *mmc = platform_get_drvdata(to_platform_device(dev)); |
1505 | 1891 | ||
1506 | return mmc_resume_host(mmc); | 1892 | return mmc_resume_host(mmc); |
1507 | } | 1893 | } |
1508 | 1894 | ||
1509 | #else /* CONFIG_PM */ | 1895 | static struct dev_pm_ops s3cmci_pm = { |
1510 | #define s3cmci_suspend NULL | ||
1511 | #define s3cmci_resume NULL | ||
1512 | #endif /* CONFIG_PM */ | ||
1513 | |||
1514 | |||
1515 | static struct platform_driver s3cmci_2410_driver = { | ||
1516 | .driver.name = "s3c2410-sdi", | ||
1517 | .driver.owner = THIS_MODULE, | ||
1518 | .probe = s3cmci_2410_probe, | ||
1519 | .remove = __devexit_p(s3cmci_remove), | ||
1520 | .shutdown = s3cmci_shutdown, | ||
1521 | .suspend = s3cmci_suspend, | 1896 | .suspend = s3cmci_suspend, |
1522 | .resume = s3cmci_resume, | 1897 | .resume = s3cmci_resume, |
1523 | }; | 1898 | }; |
1524 | 1899 | ||
1525 | static struct platform_driver s3cmci_2412_driver = { | 1900 | #define s3cmci_pm_ops &s3cmci_pm |
1526 | .driver.name = "s3c2412-sdi", | 1901 | #else /* CONFIG_PM */ |
1527 | .driver.owner = THIS_MODULE, | 1902 | #define s3cmci_pm_ops NULL |
1528 | .probe = s3cmci_2412_probe, | 1903 | #endif /* CONFIG_PM */ |
1529 | .remove = __devexit_p(s3cmci_remove), | ||
1530 | .shutdown = s3cmci_shutdown, | ||
1531 | .suspend = s3cmci_suspend, | ||
1532 | .resume = s3cmci_resume, | ||
1533 | }; | ||
1534 | 1904 | ||
1535 | static struct platform_driver s3cmci_2440_driver = { | 1905 | |
1536 | .driver.name = "s3c2440-sdi", | 1906 | static struct platform_driver s3cmci_driver = { |
1537 | .driver.owner = THIS_MODULE, | 1907 | .driver = { |
1538 | .probe = s3cmci_2440_probe, | 1908 | .name = "s3c-sdi", |
1909 | .owner = THIS_MODULE, | ||
1910 | .pm = s3cmci_pm_ops, | ||
1911 | }, | ||
1912 | .id_table = s3cmci_driver_ids, | ||
1913 | .probe = s3cmci_probe, | ||
1539 | .remove = __devexit_p(s3cmci_remove), | 1914 | .remove = __devexit_p(s3cmci_remove), |
1540 | .shutdown = s3cmci_shutdown, | 1915 | .shutdown = s3cmci_shutdown, |
1541 | .suspend = s3cmci_suspend, | ||
1542 | .resume = s3cmci_resume, | ||
1543 | }; | 1916 | }; |
1544 | 1917 | ||
1545 | |||
1546 | static int __init s3cmci_init(void) | 1918 | static int __init s3cmci_init(void) |
1547 | { | 1919 | { |
1548 | platform_driver_register(&s3cmci_2410_driver); | 1920 | return platform_driver_register(&s3cmci_driver); |
1549 | platform_driver_register(&s3cmci_2412_driver); | ||
1550 | platform_driver_register(&s3cmci_2440_driver); | ||
1551 | return 0; | ||
1552 | } | 1921 | } |
1553 | 1922 | ||
1554 | static void __exit s3cmci_exit(void) | 1923 | static void __exit s3cmci_exit(void) |
1555 | { | 1924 | { |
1556 | platform_driver_unregister(&s3cmci_2410_driver); | 1925 | platform_driver_unregister(&s3cmci_driver); |
1557 | platform_driver_unregister(&s3cmci_2412_driver); | ||
1558 | platform_driver_unregister(&s3cmci_2440_driver); | ||
1559 | } | 1926 | } |
1560 | 1927 | ||
1561 | module_init(s3cmci_init); | 1928 | module_init(s3cmci_init); |
@@ -1564,6 +1931,3 @@ module_exit(s3cmci_exit); | |||
1564 | MODULE_DESCRIPTION("Samsung S3C MMC/SD Card Interface driver"); | 1931 | MODULE_DESCRIPTION("Samsung S3C MMC/SD Card Interface driver"); |
1565 | MODULE_LICENSE("GPL v2"); | 1932 | MODULE_LICENSE("GPL v2"); |
1566 | MODULE_AUTHOR("Thomas Kleffel <tk@maintech.de>, Ben Dooks <ben-linux@fluff.org>"); | 1933 | MODULE_AUTHOR("Thomas Kleffel <tk@maintech.de>, Ben Dooks <ben-linux@fluff.org>"); |
1567 | MODULE_ALIAS("platform:s3c2410-sdi"); | ||
1568 | MODULE_ALIAS("platform:s3c2412-sdi"); | ||
1569 | MODULE_ALIAS("platform:s3c2440-sdi"); | ||
diff --git a/drivers/mmc/host/s3cmci.h b/drivers/mmc/host/s3cmci.h index ca1ba3d58cfd..c76b53dbeb61 100644 --- a/drivers/mmc/host/s3cmci.h +++ b/drivers/mmc/host/s3cmci.h | |||
@@ -8,9 +8,6 @@ | |||
8 | * published by the Free Software Foundation. | 8 | * published by the Free Software Foundation. |
9 | */ | 9 | */ |
10 | 10 | ||
11 | /* FIXME: DMA Resource management ?! */ | ||
12 | #define S3CMCI_DMA 0 | ||
13 | |||
14 | enum s3cmci_waitfor { | 11 | enum s3cmci_waitfor { |
15 | COMPLETION_NONE, | 12 | COMPLETION_NONE, |
16 | COMPLETION_FINALIZE, | 13 | COMPLETION_FINALIZE, |
@@ -42,6 +39,11 @@ struct s3cmci_host { | |||
42 | int dodma; | 39 | int dodma; |
43 | int dmatogo; | 40 | int dmatogo; |
44 | 41 | ||
42 | bool irq_disabled; | ||
43 | bool irq_enabled; | ||
44 | bool irq_state; | ||
45 | int sdio_irqen; | ||
46 | |||
45 | struct mmc_request *mrq; | 47 | struct mmc_request *mrq; |
46 | int cmd_is_stop; | 48 | int cmd_is_stop; |
47 | 49 | ||
@@ -68,6 +70,12 @@ struct s3cmci_host { | |||
68 | unsigned int ccnt, dcnt; | 70 | unsigned int ccnt, dcnt; |
69 | struct tasklet_struct pio_tasklet; | 71 | struct tasklet_struct pio_tasklet; |
70 | 72 | ||
73 | #ifdef CONFIG_DEBUG_FS | ||
74 | struct dentry *debug_root; | ||
75 | struct dentry *debug_state; | ||
76 | struct dentry *debug_regs; | ||
77 | #endif | ||
78 | |||
71 | #ifdef CONFIG_CPU_FREQ | 79 | #ifdef CONFIG_CPU_FREQ |
72 | struct notifier_block freq_transition; | 80 | struct notifier_block freq_transition; |
73 | #endif | 81 | #endif |
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c index 0acbf4f5be50..8ca17a3e96ea 100644 --- a/drivers/mtd/mtd_blkdevs.c +++ b/drivers/mtd/mtd_blkdevs.c | |||
@@ -32,14 +32,6 @@ struct mtd_blkcore_priv { | |||
32 | spinlock_t queue_lock; | 32 | spinlock_t queue_lock; |
33 | }; | 33 | }; |
34 | 34 | ||
35 | static int blktrans_discard_request(struct request_queue *q, | ||
36 | struct request *req) | ||
37 | { | ||
38 | req->cmd_type = REQ_TYPE_LINUX_BLOCK; | ||
39 | req->cmd[0] = REQ_LB_OP_DISCARD; | ||
40 | return 0; | ||
41 | } | ||
42 | |||
43 | static int do_blktrans_request(struct mtd_blktrans_ops *tr, | 35 | static int do_blktrans_request(struct mtd_blktrans_ops *tr, |
44 | struct mtd_blktrans_dev *dev, | 36 | struct mtd_blktrans_dev *dev, |
45 | struct request *req) | 37 | struct request *req) |
@@ -52,10 +44,6 @@ static int do_blktrans_request(struct mtd_blktrans_ops *tr, | |||
52 | 44 | ||
53 | buf = req->buffer; | 45 | buf = req->buffer; |
54 | 46 | ||
55 | if (req->cmd_type == REQ_TYPE_LINUX_BLOCK && | ||
56 | req->cmd[0] == REQ_LB_OP_DISCARD) | ||
57 | return tr->discard(dev, block, nsect); | ||
58 | |||
59 | if (!blk_fs_request(req)) | 47 | if (!blk_fs_request(req)) |
60 | return -EIO; | 48 | return -EIO; |
61 | 49 | ||
@@ -63,6 +51,9 @@ static int do_blktrans_request(struct mtd_blktrans_ops *tr, | |||
63 | get_capacity(req->rq_disk)) | 51 | get_capacity(req->rq_disk)) |
64 | return -EIO; | 52 | return -EIO; |
65 | 53 | ||
54 | if (blk_discard_rq(req)) | ||
55 | return tr->discard(dev, block, nsect); | ||
56 | |||
66 | switch(rq_data_dir(req)) { | 57 | switch(rq_data_dir(req)) { |
67 | case READ: | 58 | case READ: |
68 | for (; nsect > 0; nsect--, block++, buf += tr->blksize) | 59 | for (; nsect > 0; nsect--, block++, buf += tr->blksize) |
@@ -380,8 +371,8 @@ int register_mtd_blktrans(struct mtd_blktrans_ops *tr) | |||
380 | tr->blkcore_priv->rq->queuedata = tr; | 371 | tr->blkcore_priv->rq->queuedata = tr; |
381 | blk_queue_logical_block_size(tr->blkcore_priv->rq, tr->blksize); | 372 | blk_queue_logical_block_size(tr->blkcore_priv->rq, tr->blksize); |
382 | if (tr->discard) | 373 | if (tr->discard) |
383 | blk_queue_set_discard(tr->blkcore_priv->rq, | 374 | queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, |
384 | blktrans_discard_request); | 375 | tr->blkcore_priv->rq); |
385 | 376 | ||
386 | tr->blkshift = ffs(tr->blksize) - 1; | 377 | tr->blkshift = ffs(tr->blksize) - 1; |
387 | 378 | ||
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c index b9eeadf01b74..975e25b19ebe 100644 --- a/drivers/net/3c59x.c +++ b/drivers/net/3c59x.c | |||
@@ -805,52 +805,54 @@ static void poll_vortex(struct net_device *dev) | |||
805 | 805 | ||
806 | #ifdef CONFIG_PM | 806 | #ifdef CONFIG_PM |
807 | 807 | ||
808 | static int vortex_suspend(struct pci_dev *pdev, pm_message_t state) | 808 | static int vortex_suspend(struct device *dev) |
809 | { | 809 | { |
810 | struct net_device *dev = pci_get_drvdata(pdev); | 810 | struct pci_dev *pdev = to_pci_dev(dev); |
811 | struct net_device *ndev = pci_get_drvdata(pdev); | ||
812 | |||
813 | if (!ndev || !netif_running(ndev)) | ||
814 | return 0; | ||
815 | |||
816 | netif_device_detach(ndev); | ||
817 | vortex_down(ndev, 1); | ||
811 | 818 | ||
812 | if (dev && netdev_priv(dev)) { | ||
813 | if (netif_running(dev)) { | ||
814 | netif_device_detach(dev); | ||
815 | vortex_down(dev, 1); | ||
816 | disable_irq(dev->irq); | ||
817 | } | ||
818 | pci_save_state(pdev); | ||
819 | pci_enable_wake(pdev, pci_choose_state(pdev, state), 0); | ||
820 | pci_disable_device(pdev); | ||
821 | pci_set_power_state(pdev, pci_choose_state(pdev, state)); | ||
822 | } | ||
823 | return 0; | 819 | return 0; |
824 | } | 820 | } |
825 | 821 | ||
826 | static int vortex_resume(struct pci_dev *pdev) | 822 | static int vortex_resume(struct device *dev) |
827 | { | 823 | { |
828 | struct net_device *dev = pci_get_drvdata(pdev); | 824 | struct pci_dev *pdev = to_pci_dev(dev); |
829 | struct vortex_private *vp = netdev_priv(dev); | 825 | struct net_device *ndev = pci_get_drvdata(pdev); |
830 | int err; | 826 | int err; |
831 | 827 | ||
832 | if (dev && vp) { | 828 | if (!ndev || !netif_running(ndev)) |
833 | pci_set_power_state(pdev, PCI_D0); | 829 | return 0; |
834 | pci_restore_state(pdev); | 830 | |
835 | err = pci_enable_device(pdev); | 831 | err = vortex_up(ndev); |
836 | if (err) { | 832 | if (err) |
837 | pr_warning("%s: Could not enable device\n", | 833 | return err; |
838 | dev->name); | 834 | |
839 | return err; | 835 | netif_device_attach(ndev); |
840 | } | 836 | |
841 | pci_set_master(pdev); | ||
842 | if (netif_running(dev)) { | ||
843 | err = vortex_up(dev); | ||
844 | if (err) | ||
845 | return err; | ||
846 | enable_irq(dev->irq); | ||
847 | netif_device_attach(dev); | ||
848 | } | ||
849 | } | ||
850 | return 0; | 837 | return 0; |
851 | } | 838 | } |
852 | 839 | ||
853 | #endif /* CONFIG_PM */ | 840 | static struct dev_pm_ops vortex_pm_ops = { |
841 | .suspend = vortex_suspend, | ||
842 | .resume = vortex_resume, | ||
843 | .freeze = vortex_suspend, | ||
844 | .thaw = vortex_resume, | ||
845 | .poweroff = vortex_suspend, | ||
846 | .restore = vortex_resume, | ||
847 | }; | ||
848 | |||
849 | #define VORTEX_PM_OPS (&vortex_pm_ops) | ||
850 | |||
851 | #else /* !CONFIG_PM */ | ||
852 | |||
853 | #define VORTEX_PM_OPS NULL | ||
854 | |||
855 | #endif /* !CONFIG_PM */ | ||
854 | 856 | ||
855 | #ifdef CONFIG_EISA | 857 | #ifdef CONFIG_EISA |
856 | static struct eisa_device_id vortex_eisa_ids[] = { | 858 | static struct eisa_device_id vortex_eisa_ids[] = { |
@@ -3199,10 +3201,7 @@ static struct pci_driver vortex_driver = { | |||
3199 | .probe = vortex_init_one, | 3201 | .probe = vortex_init_one, |
3200 | .remove = __devexit_p(vortex_remove_one), | 3202 | .remove = __devexit_p(vortex_remove_one), |
3201 | .id_table = vortex_pci_tbl, | 3203 | .id_table = vortex_pci_tbl, |
3202 | #ifdef CONFIG_PM | 3204 | .driver.pm = VORTEX_PM_OPS, |
3203 | .suspend = vortex_suspend, | ||
3204 | .resume = vortex_resume, | ||
3205 | #endif | ||
3206 | }; | 3205 | }; |
3207 | 3206 | ||
3208 | 3207 | ||
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig index 2bea67c134f0..712776089b46 100644 --- a/drivers/net/Kconfig +++ b/drivers/net/Kconfig | |||
@@ -1738,6 +1738,13 @@ config KS8851 | |||
1738 | help | 1738 | help |
1739 | SPI driver for Micrel KS8851 SPI attached network chip. | 1739 | SPI driver for Micrel KS8851 SPI attached network chip. |
1740 | 1740 | ||
1741 | config KS8851_MLL | ||
1742 | tristate "Micrel KS8851 MLL" | ||
1743 | depends on HAS_IOMEM | ||
1744 | help | ||
1745 | This platform driver is for Micrel KS8851 Address/data bus | ||
1746 | multiplexed network chip. | ||
1747 | |||
1741 | config VIA_RHINE | 1748 | config VIA_RHINE |
1742 | tristate "VIA Rhine support" | 1749 | tristate "VIA Rhine support" |
1743 | depends on NET_PCI && PCI | 1750 | depends on NET_PCI && PCI |
diff --git a/drivers/net/Makefile b/drivers/net/Makefile index ae8cd30f13d6..d866b8cf65d1 100644 --- a/drivers/net/Makefile +++ b/drivers/net/Makefile | |||
@@ -89,6 +89,7 @@ obj-$(CONFIG_SKY2) += sky2.o | |||
89 | obj-$(CONFIG_SKFP) += skfp/ | 89 | obj-$(CONFIG_SKFP) += skfp/ |
90 | obj-$(CONFIG_KS8842) += ks8842.o | 90 | obj-$(CONFIG_KS8842) += ks8842.o |
91 | obj-$(CONFIG_KS8851) += ks8851.o | 91 | obj-$(CONFIG_KS8851) += ks8851.o |
92 | obj-$(CONFIG_KS8851_MLL) += ks8851_mll.o | ||
92 | obj-$(CONFIG_VIA_RHINE) += via-rhine.o | 93 | obj-$(CONFIG_VIA_RHINE) += via-rhine.o |
93 | obj-$(CONFIG_VIA_VELOCITY) += via-velocity.o | 94 | obj-$(CONFIG_VIA_VELOCITY) += via-velocity.o |
94 | obj-$(CONFIG_ADAPTEC_STARFIRE) += starfire.o | 95 | obj-$(CONFIG_ADAPTEC_STARFIRE) += starfire.o |
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c index fdf5937233fc..04f63c77071d 100644 --- a/drivers/net/au1000_eth.c +++ b/drivers/net/au1000_eth.c | |||
@@ -721,7 +721,7 @@ static inline void update_rx_stats(struct net_device *dev, u32 status) | |||
721 | ps->rx_errors++; | 721 | ps->rx_errors++; |
722 | if (status & RX_MISSED_FRAME) | 722 | if (status & RX_MISSED_FRAME) |
723 | ps->rx_missed_errors++; | 723 | ps->rx_missed_errors++; |
724 | if (status & (RX_OVERLEN | RX_OVERLEN | RX_LEN_ERROR)) | 724 | if (status & (RX_OVERLEN | RX_RUNT | RX_LEN_ERROR)) |
725 | ps->rx_length_errors++; | 725 | ps->rx_length_errors++; |
726 | if (status & RX_CRC_ERROR) | 726 | if (status & RX_CRC_ERROR) |
727 | ps->rx_crc_errors++; | 727 | ps->rx_crc_errors++; |
@@ -794,8 +794,6 @@ static int au1000_rx(struct net_device *dev) | |||
794 | printk("rx len error\n"); | 794 | printk("rx len error\n"); |
795 | if (status & RX_U_CNTRL_FRAME) | 795 | if (status & RX_U_CNTRL_FRAME) |
796 | printk("rx u control frame\n"); | 796 | printk("rx u control frame\n"); |
797 | if (status & RX_MISSED_FRAME) | ||
798 | printk("rx miss\n"); | ||
799 | } | 797 | } |
800 | } | 798 | } |
801 | prxd->buff_stat = (u32)(pDB->dma_addr | RX_DMA_ENABLE); | 799 | prxd->buff_stat = (u32)(pDB->dma_addr | RX_DMA_ENABLE); |
diff --git a/drivers/net/bcm63xx_enet.c b/drivers/net/bcm63xx_enet.c index 09d270913c50..ba29dc319b34 100644 --- a/drivers/net/bcm63xx_enet.c +++ b/drivers/net/bcm63xx_enet.c | |||
@@ -90,7 +90,7 @@ static int do_mdio_op(struct bcm_enet_priv *priv, unsigned int data) | |||
90 | if (enet_readl(priv, ENET_IR_REG) & ENET_IR_MII) | 90 | if (enet_readl(priv, ENET_IR_REG) & ENET_IR_MII) |
91 | break; | 91 | break; |
92 | udelay(1); | 92 | udelay(1); |
93 | } while (limit-- >= 0); | 93 | } while (limit-- > 0); |
94 | 94 | ||
95 | return (limit < 0) ? 1 : 0; | 95 | return (limit < 0) ? 1 : 0; |
96 | } | 96 | } |
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h index 684c6fe24c8d..a80da0e14a52 100644 --- a/drivers/net/benet/be.h +++ b/drivers/net/benet/be.h | |||
@@ -258,6 +258,7 @@ struct be_adapter { | |||
258 | bool link_up; | 258 | bool link_up; |
259 | u32 port_num; | 259 | u32 port_num; |
260 | bool promiscuous; | 260 | bool promiscuous; |
261 | u32 cap; | ||
261 | }; | 262 | }; |
262 | 263 | ||
263 | extern const struct ethtool_ops be_ethtool_ops; | 264 | extern const struct ethtool_ops be_ethtool_ops; |
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c index 3dd76c4170bf..89876ade5e33 100644 --- a/drivers/net/benet/be_cmds.c +++ b/drivers/net/benet/be_cmds.c | |||
@@ -1068,7 +1068,7 @@ int be_cmd_get_flow_control(struct be_adapter *adapter, u32 *tx_fc, u32 *rx_fc) | |||
1068 | } | 1068 | } |
1069 | 1069 | ||
1070 | /* Uses mbox */ | 1070 | /* Uses mbox */ |
1071 | int be_cmd_query_fw_cfg(struct be_adapter *adapter, u32 *port_num) | 1071 | int be_cmd_query_fw_cfg(struct be_adapter *adapter, u32 *port_num, u32 *cap) |
1072 | { | 1072 | { |
1073 | struct be_mcc_wrb *wrb; | 1073 | struct be_mcc_wrb *wrb; |
1074 | struct be_cmd_req_query_fw_cfg *req; | 1074 | struct be_cmd_req_query_fw_cfg *req; |
@@ -1088,6 +1088,7 @@ int be_cmd_query_fw_cfg(struct be_adapter *adapter, u32 *port_num) | |||
1088 | if (!status) { | 1088 | if (!status) { |
1089 | struct be_cmd_resp_query_fw_cfg *resp = embedded_payload(wrb); | 1089 | struct be_cmd_resp_query_fw_cfg *resp = embedded_payload(wrb); |
1090 | *port_num = le32_to_cpu(resp->phys_port); | 1090 | *port_num = le32_to_cpu(resp->phys_port); |
1091 | *cap = le32_to_cpu(resp->function_cap); | ||
1091 | } | 1092 | } |
1092 | 1093 | ||
1093 | spin_unlock(&adapter->mbox_lock); | 1094 | spin_unlock(&adapter->mbox_lock); |
@@ -1128,7 +1129,6 @@ int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd, | |||
1128 | spin_lock_bh(&adapter->mcc_lock); | 1129 | spin_lock_bh(&adapter->mcc_lock); |
1129 | 1130 | ||
1130 | wrb = wrb_from_mccq(adapter); | 1131 | wrb = wrb_from_mccq(adapter); |
1131 | req = embedded_payload(wrb); | ||
1132 | sge = nonembedded_sgl(wrb); | 1132 | sge = nonembedded_sgl(wrb); |
1133 | 1133 | ||
1134 | be_wrb_hdr_prepare(wrb, cmd->size, false, 1); | 1134 | be_wrb_hdr_prepare(wrb, cmd->size, false, 1); |
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h index 93e432f3d926..a86f917f85f4 100644 --- a/drivers/net/benet/be_cmds.h +++ b/drivers/net/benet/be_cmds.h | |||
@@ -62,7 +62,7 @@ enum { | |||
62 | MCC_STATUS_QUEUE_FLUSHING = 0x4, | 62 | MCC_STATUS_QUEUE_FLUSHING = 0x4, |
63 | /* The command is completing with a DMA error */ | 63 | /* The command is completing with a DMA error */ |
64 | MCC_STATUS_DMA_FAILED = 0x5, | 64 | MCC_STATUS_DMA_FAILED = 0x5, |
65 | MCC_STATUS_NOT_SUPPORTED = 0x66 | 65 | MCC_STATUS_NOT_SUPPORTED = 66 |
66 | }; | 66 | }; |
67 | 67 | ||
68 | #define CQE_STATUS_COMPL_MASK 0xFFFF | 68 | #define CQE_STATUS_COMPL_MASK 0xFFFF |
@@ -760,7 +760,8 @@ extern int be_cmd_set_flow_control(struct be_adapter *adapter, | |||
760 | u32 tx_fc, u32 rx_fc); | 760 | u32 tx_fc, u32 rx_fc); |
761 | extern int be_cmd_get_flow_control(struct be_adapter *adapter, | 761 | extern int be_cmd_get_flow_control(struct be_adapter *adapter, |
762 | u32 *tx_fc, u32 *rx_fc); | 762 | u32 *tx_fc, u32 *rx_fc); |
763 | extern int be_cmd_query_fw_cfg(struct be_adapter *adapter, u32 *port_num); | 763 | extern int be_cmd_query_fw_cfg(struct be_adapter *adapter, |
764 | u32 *port_num, u32 *cap); | ||
764 | extern int be_cmd_reset_function(struct be_adapter *adapter); | 765 | extern int be_cmd_reset_function(struct be_adapter *adapter); |
765 | extern int be_process_mcc(struct be_adapter *adapter); | 766 | extern int be_process_mcc(struct be_adapter *adapter); |
766 | extern int be_cmd_write_flashrom(struct be_adapter *adapter, | 767 | extern int be_cmd_write_flashrom(struct be_adapter *adapter, |
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c index 11445df3dbc0..cda5bf2fc50a 100644 --- a/drivers/net/benet/be_ethtool.c +++ b/drivers/net/benet/be_ethtool.c | |||
@@ -358,7 +358,7 @@ const struct ethtool_ops be_ethtool_ops = { | |||
358 | .get_rx_csum = be_get_rx_csum, | 358 | .get_rx_csum = be_get_rx_csum, |
359 | .set_rx_csum = be_set_rx_csum, | 359 | .set_rx_csum = be_set_rx_csum, |
360 | .get_tx_csum = ethtool_op_get_tx_csum, | 360 | .get_tx_csum = ethtool_op_get_tx_csum, |
361 | .set_tx_csum = ethtool_op_set_tx_csum, | 361 | .set_tx_csum = ethtool_op_set_tx_hw_csum, |
362 | .get_sg = ethtool_op_get_sg, | 362 | .get_sg = ethtool_op_get_sg, |
363 | .set_sg = ethtool_op_set_sg, | 363 | .set_sg = ethtool_op_set_sg, |
364 | .get_tso = ethtool_op_get_tso, | 364 | .get_tso = ethtool_op_get_tso, |
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c index 409cf0595903..6d5e81f7046f 100644 --- a/drivers/net/benet/be_main.c +++ b/drivers/net/benet/be_main.c | |||
@@ -197,7 +197,7 @@ void netdev_stats_update(struct be_adapter *adapter) | |||
197 | /* no space available in linux */ | 197 | /* no space available in linux */ |
198 | dev_stats->tx_dropped = 0; | 198 | dev_stats->tx_dropped = 0; |
199 | 199 | ||
200 | dev_stats->multicast = port_stats->tx_multicastframes; | 200 | dev_stats->multicast = port_stats->rx_multicast_frames; |
201 | dev_stats->collisions = 0; | 201 | dev_stats->collisions = 0; |
202 | 202 | ||
203 | /* detailed tx_errors */ | 203 | /* detailed tx_errors */ |
@@ -747,9 +747,16 @@ static void be_rx_compl_process(struct be_adapter *adapter, | |||
747 | struct be_eth_rx_compl *rxcp) | 747 | struct be_eth_rx_compl *rxcp) |
748 | { | 748 | { |
749 | struct sk_buff *skb; | 749 | struct sk_buff *skb; |
750 | u32 vtp, vid; | 750 | u32 vlanf, vid; |
751 | u8 vtm; | ||
751 | 752 | ||
752 | vtp = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp); | 753 | vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp); |
754 | vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp); | ||
755 | |||
756 | /* vlanf could be wrongly set in some cards. | ||
757 | * ignore if vtm is not set */ | ||
758 | if ((adapter->cap == 0x400) && !vtm) | ||
759 | vlanf = 0; | ||
753 | 760 | ||
754 | skb = netdev_alloc_skb(adapter->netdev, BE_HDR_LEN + NET_IP_ALIGN); | 761 | skb = netdev_alloc_skb(adapter->netdev, BE_HDR_LEN + NET_IP_ALIGN); |
755 | if (!skb) { | 762 | if (!skb) { |
@@ -772,7 +779,7 @@ static void be_rx_compl_process(struct be_adapter *adapter, | |||
772 | skb->protocol = eth_type_trans(skb, adapter->netdev); | 779 | skb->protocol = eth_type_trans(skb, adapter->netdev); |
773 | skb->dev = adapter->netdev; | 780 | skb->dev = adapter->netdev; |
774 | 781 | ||
775 | if (vtp) { | 782 | if (vlanf) { |
776 | if (!adapter->vlan_grp || adapter->num_vlans == 0) { | 783 | if (!adapter->vlan_grp || adapter->num_vlans == 0) { |
777 | kfree_skb(skb); | 784 | kfree_skb(skb); |
778 | return; | 785 | return; |
@@ -797,11 +804,18 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter, | |||
797 | struct be_eq_obj *eq_obj = &adapter->rx_eq; | 804 | struct be_eq_obj *eq_obj = &adapter->rx_eq; |
798 | u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len; | 805 | u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len; |
799 | u16 i, rxq_idx = 0, vid, j; | 806 | u16 i, rxq_idx = 0, vid, j; |
807 | u8 vtm; | ||
800 | 808 | ||
801 | num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp); | 809 | num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp); |
802 | pkt_size = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp); | 810 | pkt_size = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp); |
803 | vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp); | 811 | vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp); |
804 | rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp); | 812 | rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp); |
813 | vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp); | ||
814 | |||
815 | /* vlanf could be wrongly set in some cards. | ||
816 | * ignore if vtm is not set */ | ||
817 | if ((adapter->cap == 0x400) && !vtm) | ||
818 | vlanf = 0; | ||
805 | 819 | ||
806 | skb = napi_get_frags(&eq_obj->napi); | 820 | skb = napi_get_frags(&eq_obj->napi); |
807 | if (!skb) { | 821 | if (!skb) { |
@@ -1885,8 +1899,8 @@ static void be_netdev_init(struct net_device *netdev) | |||
1885 | struct be_adapter *adapter = netdev_priv(netdev); | 1899 | struct be_adapter *adapter = netdev_priv(netdev); |
1886 | 1900 | ||
1887 | netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO | | 1901 | netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO | |
1888 | NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_IP_CSUM | | 1902 | NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_HW_CSUM | |
1889 | NETIF_F_IPV6_CSUM | NETIF_F_GRO; | 1903 | NETIF_F_GRO; |
1890 | 1904 | ||
1891 | netdev->flags |= IFF_MULTICAST; | 1905 | netdev->flags |= IFF_MULTICAST; |
1892 | 1906 | ||
@@ -2045,7 +2059,8 @@ static int be_hw_up(struct be_adapter *adapter) | |||
2045 | if (status) | 2059 | if (status) |
2046 | return status; | 2060 | return status; |
2047 | 2061 | ||
2048 | status = be_cmd_query_fw_cfg(adapter, &adapter->port_num); | 2062 | status = be_cmd_query_fw_cfg(adapter, |
2063 | &adapter->port_num, &adapter->cap); | ||
2049 | return status; | 2064 | return status; |
2050 | } | 2065 | } |
2051 | 2066 | ||
diff --git a/drivers/net/bonding/bond_sysfs.c b/drivers/net/bonding/bond_sysfs.c index 6044e12ff9fc..ff449de6f3c0 100644 --- a/drivers/net/bonding/bond_sysfs.c +++ b/drivers/net/bonding/bond_sysfs.c | |||
@@ -1182,6 +1182,7 @@ static ssize_t bonding_store_primary(struct device *d, | |||
1182 | ": %s: Setting %s as primary slave.\n", | 1182 | ": %s: Setting %s as primary slave.\n", |
1183 | bond->dev->name, slave->dev->name); | 1183 | bond->dev->name, slave->dev->name); |
1184 | bond->primary_slave = slave; | 1184 | bond->primary_slave = slave; |
1185 | strcpy(bond->params.primary, slave->dev->name); | ||
1185 | bond_select_active_slave(bond); | 1186 | bond_select_active_slave(bond); |
1186 | goto out; | 1187 | goto out; |
1187 | } | 1188 | } |
diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c index 211c8e9182fc..46c87ec7960c 100644 --- a/drivers/net/cnic.c +++ b/drivers/net/cnic.c | |||
@@ -2733,7 +2733,8 @@ static int cnic_netdev_event(struct notifier_block *this, unsigned long event, | |||
2733 | cnic_ulp_init(dev); | 2733 | cnic_ulp_init(dev); |
2734 | else if (event == NETDEV_UNREGISTER) | 2734 | else if (event == NETDEV_UNREGISTER) |
2735 | cnic_ulp_exit(dev); | 2735 | cnic_ulp_exit(dev); |
2736 | else if (event == NETDEV_UP) { | 2736 | |
2737 | if (event == NETDEV_UP) { | ||
2737 | if (cnic_register_netdev(dev) != 0) { | 2738 | if (cnic_register_netdev(dev) != 0) { |
2738 | cnic_put(dev); | 2739 | cnic_put(dev); |
2739 | goto done; | 2740 | goto done; |
diff --git a/drivers/net/cnic_if.h b/drivers/net/cnic_if.h index a49235739eef..d8b09efdcb52 100644 --- a/drivers/net/cnic_if.h +++ b/drivers/net/cnic_if.h | |||
@@ -12,8 +12,8 @@ | |||
12 | #ifndef CNIC_IF_H | 12 | #ifndef CNIC_IF_H |
13 | #define CNIC_IF_H | 13 | #define CNIC_IF_H |
14 | 14 | ||
15 | #define CNIC_MODULE_VERSION "2.0.0" | 15 | #define CNIC_MODULE_VERSION "2.0.1" |
16 | #define CNIC_MODULE_RELDATE "May 21, 2009" | 16 | #define CNIC_MODULE_RELDATE "Oct 01, 2009" |
17 | 17 | ||
18 | #define CNIC_ULP_RDMA 0 | 18 | #define CNIC_ULP_RDMA 0 |
19 | #define CNIC_ULP_ISCSI 1 | 19 | #define CNIC_ULP_ISCSI 1 |
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c index b53b40ba88a8..d1e0563a67df 100644 --- a/drivers/net/e1000e/82571.c +++ b/drivers/net/e1000e/82571.c | |||
@@ -1803,7 +1803,7 @@ struct e1000_info e1000_82574_info = { | |||
1803 | | FLAG_HAS_AMT | 1803 | | FLAG_HAS_AMT |
1804 | | FLAG_HAS_CTRLEXT_ON_LOAD, | 1804 | | FLAG_HAS_CTRLEXT_ON_LOAD, |
1805 | .pba = 20, | 1805 | .pba = 20, |
1806 | .max_hw_frame_size = ETH_FRAME_LEN + ETH_FCS_LEN, | 1806 | .max_hw_frame_size = DEFAULT_JUMBO, |
1807 | .get_variants = e1000_get_variants_82571, | 1807 | .get_variants = e1000_get_variants_82571, |
1808 | .mac_ops = &e82571_mac_ops, | 1808 | .mac_ops = &e82571_mac_ops, |
1809 | .phy_ops = &e82_phy_ops_bm, | 1809 | .phy_ops = &e82_phy_ops_bm, |
@@ -1820,7 +1820,7 @@ struct e1000_info e1000_82583_info = { | |||
1820 | | FLAG_HAS_AMT | 1820 | | FLAG_HAS_AMT |
1821 | | FLAG_HAS_CTRLEXT_ON_LOAD, | 1821 | | FLAG_HAS_CTRLEXT_ON_LOAD, |
1822 | .pba = 20, | 1822 | .pba = 20, |
1823 | .max_hw_frame_size = DEFAULT_JUMBO, | 1823 | .max_hw_frame_size = ETH_FRAME_LEN + ETH_FCS_LEN, |
1824 | .get_variants = e1000_get_variants_82571, | 1824 | .get_variants = e1000_get_variants_82571, |
1825 | .mac_ops = &e82571_mac_ops, | 1825 | .mac_ops = &e82571_mac_ops, |
1826 | .phy_ops = &e82_phy_ops_bm, | 1826 | .phy_ops = &e82_phy_ops_bm, |
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c index 16c193a6c95c..0687c6aa4e46 100644 --- a/drivers/net/e1000e/netdev.c +++ b/drivers/net/e1000e/netdev.c | |||
@@ -4982,12 +4982,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev, | |||
4982 | goto err_pci_reg; | 4982 | goto err_pci_reg; |
4983 | 4983 | ||
4984 | /* AER (Advanced Error Reporting) hooks */ | 4984 | /* AER (Advanced Error Reporting) hooks */ |
4985 | err = pci_enable_pcie_error_reporting(pdev); | 4985 | pci_enable_pcie_error_reporting(pdev); |
4986 | if (err) { | ||
4987 | dev_err(&pdev->dev, "pci_enable_pcie_error_reporting failed " | ||
4988 | "0x%x\n", err); | ||
4989 | /* non-fatal, continue */ | ||
4990 | } | ||
4991 | 4986 | ||
4992 | pci_set_master(pdev); | 4987 | pci_set_master(pdev); |
4993 | /* PCI config space info */ | 4988 | /* PCI config space info */ |
@@ -5263,7 +5258,6 @@ static void __devexit e1000_remove(struct pci_dev *pdev) | |||
5263 | { | 5258 | { |
5264 | struct net_device *netdev = pci_get_drvdata(pdev); | 5259 | struct net_device *netdev = pci_get_drvdata(pdev); |
5265 | struct e1000_adapter *adapter = netdev_priv(netdev); | 5260 | struct e1000_adapter *adapter = netdev_priv(netdev); |
5266 | int err; | ||
5267 | 5261 | ||
5268 | /* | 5262 | /* |
5269 | * flush_scheduled work may reschedule our watchdog task, so | 5263 | * flush_scheduled work may reschedule our watchdog task, so |
@@ -5299,10 +5293,7 @@ static void __devexit e1000_remove(struct pci_dev *pdev) | |||
5299 | free_netdev(netdev); | 5293 | free_netdev(netdev); |
5300 | 5294 | ||
5301 | /* AER disable */ | 5295 | /* AER disable */ |
5302 | err = pci_disable_pcie_error_reporting(pdev); | 5296 | pci_disable_pcie_error_reporting(pdev); |
5303 | if (err) | ||
5304 | dev_err(&pdev->dev, | ||
5305 | "pci_disable_pcie_error_reporting failed 0x%x\n", err); | ||
5306 | 5297 | ||
5307 | pci_disable_device(pdev); | 5298 | pci_disable_device(pdev); |
5308 | } | 5299 | } |
diff --git a/drivers/net/ethoc.c b/drivers/net/ethoc.c index b7311bc00258..34d0c69e67f7 100644 --- a/drivers/net/ethoc.c +++ b/drivers/net/ethoc.c | |||
@@ -19,6 +19,10 @@ | |||
19 | #include <linux/platform_device.h> | 19 | #include <linux/platform_device.h> |
20 | #include <net/ethoc.h> | 20 | #include <net/ethoc.h> |
21 | 21 | ||
22 | static int buffer_size = 0x8000; /* 32 KBytes */ | ||
23 | module_param(buffer_size, int, 0); | ||
24 | MODULE_PARM_DESC(buffer_size, "DMA buffer allocation size"); | ||
25 | |||
22 | /* register offsets */ | 26 | /* register offsets */ |
23 | #define MODER 0x00 | 27 | #define MODER 0x00 |
24 | #define INT_SOURCE 0x04 | 28 | #define INT_SOURCE 0x04 |
@@ -167,6 +171,7 @@ | |||
167 | * struct ethoc - driver-private device structure | 171 | * struct ethoc - driver-private device structure |
168 | * @iobase: pointer to I/O memory region | 172 | * @iobase: pointer to I/O memory region |
169 | * @membase: pointer to buffer memory region | 173 | * @membase: pointer to buffer memory region |
174 | * @dma_alloc: dma allocated buffer size | ||
170 | * @num_tx: number of send buffers | 175 | * @num_tx: number of send buffers |
171 | * @cur_tx: last send buffer written | 176 | * @cur_tx: last send buffer written |
172 | * @dty_tx: last buffer actually sent | 177 | * @dty_tx: last buffer actually sent |
@@ -185,6 +190,7 @@ | |||
185 | struct ethoc { | 190 | struct ethoc { |
186 | void __iomem *iobase; | 191 | void __iomem *iobase; |
187 | void __iomem *membase; | 192 | void __iomem *membase; |
193 | int dma_alloc; | ||
188 | 194 | ||
189 | unsigned int num_tx; | 195 | unsigned int num_tx; |
190 | unsigned int cur_tx; | 196 | unsigned int cur_tx; |
@@ -284,7 +290,7 @@ static int ethoc_init_ring(struct ethoc *dev) | |||
284 | dev->cur_rx = 0; | 290 | dev->cur_rx = 0; |
285 | 291 | ||
286 | /* setup transmission buffers */ | 292 | /* setup transmission buffers */ |
287 | bd.addr = 0; | 293 | bd.addr = virt_to_phys(dev->membase); |
288 | bd.stat = TX_BD_IRQ | TX_BD_CRC; | 294 | bd.stat = TX_BD_IRQ | TX_BD_CRC; |
289 | 295 | ||
290 | for (i = 0; i < dev->num_tx; i++) { | 296 | for (i = 0; i < dev->num_tx; i++) { |
@@ -295,7 +301,6 @@ static int ethoc_init_ring(struct ethoc *dev) | |||
295 | bd.addr += ETHOC_BUFSIZ; | 301 | bd.addr += ETHOC_BUFSIZ; |
296 | } | 302 | } |
297 | 303 | ||
298 | bd.addr = dev->num_tx * ETHOC_BUFSIZ; | ||
299 | bd.stat = RX_BD_EMPTY | RX_BD_IRQ; | 304 | bd.stat = RX_BD_EMPTY | RX_BD_IRQ; |
300 | 305 | ||
301 | for (i = 0; i < dev->num_rx; i++) { | 306 | for (i = 0; i < dev->num_rx; i++) { |
@@ -400,8 +405,12 @@ static int ethoc_rx(struct net_device *dev, int limit) | |||
400 | if (ethoc_update_rx_stats(priv, &bd) == 0) { | 405 | if (ethoc_update_rx_stats(priv, &bd) == 0) { |
401 | int size = bd.stat >> 16; | 406 | int size = bd.stat >> 16; |
402 | struct sk_buff *skb = netdev_alloc_skb(dev, size); | 407 | struct sk_buff *skb = netdev_alloc_skb(dev, size); |
408 | |||
409 | size -= 4; /* strip the CRC */ | ||
410 | skb_reserve(skb, 2); /* align TCP/IP header */ | ||
411 | |||
403 | if (likely(skb)) { | 412 | if (likely(skb)) { |
404 | void *src = priv->membase + bd.addr; | 413 | void *src = phys_to_virt(bd.addr); |
405 | memcpy_fromio(skb_put(skb, size), src, size); | 414 | memcpy_fromio(skb_put(skb, size), src, size); |
406 | skb->protocol = eth_type_trans(skb, dev); | 415 | skb->protocol = eth_type_trans(skb, dev); |
407 | priv->stats.rx_packets++; | 416 | priv->stats.rx_packets++; |
@@ -653,9 +662,9 @@ static int ethoc_open(struct net_device *dev) | |||
653 | if (ret) | 662 | if (ret) |
654 | return ret; | 663 | return ret; |
655 | 664 | ||
656 | /* calculate the number of TX/RX buffers */ | 665 | /* calculate the number of TX/RX buffers, maximum 128 supported */ |
657 | num_bd = (dev->mem_end - dev->mem_start + 1) / ETHOC_BUFSIZ; | 666 | num_bd = min(128, (dev->mem_end - dev->mem_start + 1) / ETHOC_BUFSIZ); |
658 | priv->num_tx = min(min_tx, num_bd / 4); | 667 | priv->num_tx = max(min_tx, num_bd / 4); |
659 | priv->num_rx = num_bd - priv->num_tx; | 668 | priv->num_rx = num_bd - priv->num_tx; |
660 | ethoc_write(priv, TX_BD_NUM, priv->num_tx); | 669 | ethoc_write(priv, TX_BD_NUM, priv->num_tx); |
661 | 670 | ||
@@ -823,7 +832,7 @@ static netdev_tx_t ethoc_start_xmit(struct sk_buff *skb, struct net_device *dev) | |||
823 | else | 832 | else |
824 | bd.stat &= ~TX_BD_PAD; | 833 | bd.stat &= ~TX_BD_PAD; |
825 | 834 | ||
826 | dest = priv->membase + bd.addr; | 835 | dest = phys_to_virt(bd.addr); |
827 | memcpy_toio(dest, skb->data, skb->len); | 836 | memcpy_toio(dest, skb->data, skb->len); |
828 | 837 | ||
829 | bd.stat &= ~(TX_BD_STATS | TX_BD_LEN_MASK); | 838 | bd.stat &= ~(TX_BD_STATS | TX_BD_LEN_MASK); |
@@ -903,22 +912,19 @@ static int ethoc_probe(struct platform_device *pdev) | |||
903 | 912 | ||
904 | /* obtain buffer memory space */ | 913 | /* obtain buffer memory space */ |
905 | res = platform_get_resource(pdev, IORESOURCE_MEM, 1); | 914 | res = platform_get_resource(pdev, IORESOURCE_MEM, 1); |
906 | if (!res) { | 915 | if (res) { |
907 | dev_err(&pdev->dev, "cannot obtain memory space\n"); | 916 | mem = devm_request_mem_region(&pdev->dev, res->start, |
908 | ret = -ENXIO; | ||
909 | goto free; | ||
910 | } | ||
911 | |||
912 | mem = devm_request_mem_region(&pdev->dev, res->start, | ||
913 | res->end - res->start + 1, res->name); | 917 | res->end - res->start + 1, res->name); |
914 | if (!mem) { | 918 | if (!mem) { |
915 | dev_err(&pdev->dev, "cannot request memory space\n"); | 919 | dev_err(&pdev->dev, "cannot request memory space\n"); |
916 | ret = -ENXIO; | 920 | ret = -ENXIO; |
917 | goto free; | 921 | goto free; |
922 | } | ||
923 | |||
924 | netdev->mem_start = mem->start; | ||
925 | netdev->mem_end = mem->end; | ||
918 | } | 926 | } |
919 | 927 | ||
920 | netdev->mem_start = mem->start; | ||
921 | netdev->mem_end = mem->end; | ||
922 | 928 | ||
923 | /* obtain device IRQ number */ | 929 | /* obtain device IRQ number */ |
924 | res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | 930 | res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); |
@@ -933,6 +939,7 @@ static int ethoc_probe(struct platform_device *pdev) | |||
933 | /* setup driver-private data */ | 939 | /* setup driver-private data */ |
934 | priv = netdev_priv(netdev); | 940 | priv = netdev_priv(netdev); |
935 | priv->netdev = netdev; | 941 | priv->netdev = netdev; |
942 | priv->dma_alloc = 0; | ||
936 | 943 | ||
937 | priv->iobase = devm_ioremap_nocache(&pdev->dev, netdev->base_addr, | 944 | priv->iobase = devm_ioremap_nocache(&pdev->dev, netdev->base_addr, |
938 | mmio->end - mmio->start + 1); | 945 | mmio->end - mmio->start + 1); |
@@ -942,12 +949,27 @@ static int ethoc_probe(struct platform_device *pdev) | |||
942 | goto error; | 949 | goto error; |
943 | } | 950 | } |
944 | 951 | ||
945 | priv->membase = devm_ioremap_nocache(&pdev->dev, netdev->mem_start, | 952 | if (netdev->mem_end) { |
946 | mem->end - mem->start + 1); | 953 | priv->membase = devm_ioremap_nocache(&pdev->dev, |
947 | if (!priv->membase) { | 954 | netdev->mem_start, mem->end - mem->start + 1); |
948 | dev_err(&pdev->dev, "cannot remap memory space\n"); | 955 | if (!priv->membase) { |
949 | ret = -ENXIO; | 956 | dev_err(&pdev->dev, "cannot remap memory space\n"); |
950 | goto error; | 957 | ret = -ENXIO; |
958 | goto error; | ||
959 | } | ||
960 | } else { | ||
961 | /* Allocate buffer memory */ | ||
962 | priv->membase = dma_alloc_coherent(NULL, | ||
963 | buffer_size, (void *)&netdev->mem_start, | ||
964 | GFP_KERNEL); | ||
965 | if (!priv->membase) { | ||
966 | dev_err(&pdev->dev, "cannot allocate %dB buffer\n", | ||
967 | buffer_size); | ||
968 | ret = -ENOMEM; | ||
969 | goto error; | ||
970 | } | ||
971 | netdev->mem_end = netdev->mem_start + buffer_size; | ||
972 | priv->dma_alloc = buffer_size; | ||
951 | } | 973 | } |
952 | 974 | ||
953 | /* Allow the platform setup code to pass in a MAC address. */ | 975 | /* Allow the platform setup code to pass in a MAC address. */ |
@@ -1034,6 +1056,9 @@ free_mdio: | |||
1034 | kfree(priv->mdio->irq); | 1056 | kfree(priv->mdio->irq); |
1035 | mdiobus_free(priv->mdio); | 1057 | mdiobus_free(priv->mdio); |
1036 | free: | 1058 | free: |
1059 | if (priv->dma_alloc) | ||
1060 | dma_free_coherent(NULL, priv->dma_alloc, priv->membase, | ||
1061 | netdev->mem_start); | ||
1037 | free_netdev(netdev); | 1062 | free_netdev(netdev); |
1038 | out: | 1063 | out: |
1039 | return ret; | 1064 | return ret; |
@@ -1059,7 +1084,9 @@ static int ethoc_remove(struct platform_device *pdev) | |||
1059 | kfree(priv->mdio->irq); | 1084 | kfree(priv->mdio->irq); |
1060 | mdiobus_free(priv->mdio); | 1085 | mdiobus_free(priv->mdio); |
1061 | } | 1086 | } |
1062 | 1087 | if (priv->dma_alloc) | |
1088 | dma_free_coherent(NULL, priv->dma_alloc, priv->membase, | ||
1089 | netdev->mem_start); | ||
1063 | unregister_netdev(netdev); | 1090 | unregister_netdev(netdev); |
1064 | free_netdev(netdev); | 1091 | free_netdev(netdev); |
1065 | } | 1092 | } |
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c index 33b55f729742..db4b7f1603f6 100644 --- a/drivers/net/hamradio/mkiss.c +++ b/drivers/net/hamradio/mkiss.c | |||
@@ -258,7 +258,7 @@ static void ax_bump(struct mkiss *ax) | |||
258 | } | 258 | } |
259 | if (ax->crcmode != CRC_MODE_SMACK && ax->crcauto) { | 259 | if (ax->crcmode != CRC_MODE_SMACK && ax->crcauto) { |
260 | printk(KERN_INFO | 260 | printk(KERN_INFO |
261 | "mkiss: %s: Switchting to crc-smack\n", | 261 | "mkiss: %s: Switching to crc-smack\n", |
262 | ax->dev->name); | 262 | ax->dev->name); |
263 | ax->crcmode = CRC_MODE_SMACK; | 263 | ax->crcmode = CRC_MODE_SMACK; |
264 | } | 264 | } |
@@ -272,7 +272,7 @@ static void ax_bump(struct mkiss *ax) | |||
272 | } | 272 | } |
273 | if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) { | 273 | if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) { |
274 | printk(KERN_INFO | 274 | printk(KERN_INFO |
275 | "mkiss: %s: Switchting to crc-flexnet\n", | 275 | "mkiss: %s: Switching to crc-flexnet\n", |
276 | ax->dev->name); | 276 | ax->dev->name); |
277 | ax->crcmode = CRC_MODE_FLEX; | 277 | ax->crcmode = CRC_MODE_FLEX; |
278 | } | 278 | } |
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c index 5d6c1530a8c0..714c3a4a44ef 100644 --- a/drivers/net/igb/igb_main.c +++ b/drivers/net/igb/igb_main.c | |||
@@ -1246,12 +1246,7 @@ static int __devinit igb_probe(struct pci_dev *pdev, | |||
1246 | if (err) | 1246 | if (err) |
1247 | goto err_pci_reg; | 1247 | goto err_pci_reg; |
1248 | 1248 | ||
1249 | err = pci_enable_pcie_error_reporting(pdev); | 1249 | pci_enable_pcie_error_reporting(pdev); |
1250 | if (err) { | ||
1251 | dev_err(&pdev->dev, "pci_enable_pcie_error_reporting failed " | ||
1252 | "0x%x\n", err); | ||
1253 | /* non-fatal, continue */ | ||
1254 | } | ||
1255 | 1250 | ||
1256 | pci_set_master(pdev); | 1251 | pci_set_master(pdev); |
1257 | pci_save_state(pdev); | 1252 | pci_save_state(pdev); |
@@ -1628,7 +1623,6 @@ static void __devexit igb_remove(struct pci_dev *pdev) | |||
1628 | struct net_device *netdev = pci_get_drvdata(pdev); | 1623 | struct net_device *netdev = pci_get_drvdata(pdev); |
1629 | struct igb_adapter *adapter = netdev_priv(netdev); | 1624 | struct igb_adapter *adapter = netdev_priv(netdev); |
1630 | struct e1000_hw *hw = &adapter->hw; | 1625 | struct e1000_hw *hw = &adapter->hw; |
1631 | int err; | ||
1632 | 1626 | ||
1633 | /* flush_scheduled work may reschedule our watchdog task, so | 1627 | /* flush_scheduled work may reschedule our watchdog task, so |
1634 | * explicitly disable watchdog tasks from being rescheduled */ | 1628 | * explicitly disable watchdog tasks from being rescheduled */ |
@@ -1682,10 +1676,7 @@ static void __devexit igb_remove(struct pci_dev *pdev) | |||
1682 | 1676 | ||
1683 | free_netdev(netdev); | 1677 | free_netdev(netdev); |
1684 | 1678 | ||
1685 | err = pci_disable_pcie_error_reporting(pdev); | 1679 | pci_disable_pcie_error_reporting(pdev); |
1686 | if (err) | ||
1687 | dev_err(&pdev->dev, | ||
1688 | "pci_disable_pcie_error_reporting failed 0x%x\n", err); | ||
1689 | 1680 | ||
1690 | pci_disable_device(pdev); | 1681 | pci_disable_device(pdev); |
1691 | } | 1682 | } |
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c index e36e951cbc65..aa7286bc4364 100644 --- a/drivers/net/iseries_veth.c +++ b/drivers/net/iseries_veth.c | |||
@@ -495,7 +495,7 @@ static void veth_take_cap_ack(struct veth_lpar_connection *cnx, | |||
495 | cnx->remote_lp); | 495 | cnx->remote_lp); |
496 | } else { | 496 | } else { |
497 | memcpy(&cnx->cap_ack_event, event, | 497 | memcpy(&cnx->cap_ack_event, event, |
498 | sizeof(&cnx->cap_ack_event)); | 498 | sizeof(cnx->cap_ack_event)); |
499 | cnx->state |= VETH_STATE_GOTCAPACK; | 499 | cnx->state |= VETH_STATE_GOTCAPACK; |
500 | veth_kick_statemachine(cnx); | 500 | veth_kick_statemachine(cnx); |
501 | } | 501 | } |
diff --git a/drivers/net/ixgbe/ixgbe_82598.c b/drivers/net/ixgbe/ixgbe_82598.c index 56b12f3192f1..e2d5343f1275 100644 --- a/drivers/net/ixgbe/ixgbe_82598.c +++ b/drivers/net/ixgbe/ixgbe_82598.c | |||
@@ -425,7 +425,7 @@ static s32 ixgbe_fc_enable_82598(struct ixgbe_hw *hw, s32 packetbuf_num) | |||
425 | #endif /* CONFIG_DCB */ | 425 | #endif /* CONFIG_DCB */ |
426 | default: | 426 | default: |
427 | hw_dbg(hw, "Flow control param set incorrectly\n"); | 427 | hw_dbg(hw, "Flow control param set incorrectly\n"); |
428 | ret_val = -IXGBE_ERR_CONFIG; | 428 | ret_val = IXGBE_ERR_CONFIG; |
429 | goto out; | 429 | goto out; |
430 | break; | 430 | break; |
431 | } | 431 | } |
diff --git a/drivers/net/ixgbe/ixgbe_82599.c b/drivers/net/ixgbe/ixgbe_82599.c index 2ec58dcdb82b..34b04924c8a1 100644 --- a/drivers/net/ixgbe/ixgbe_82599.c +++ b/drivers/net/ixgbe/ixgbe_82599.c | |||
@@ -330,6 +330,8 @@ static enum ixgbe_media_type ixgbe_get_media_type_82599(struct ixgbe_hw *hw) | |||
330 | 330 | ||
331 | switch (hw->device_id) { | 331 | switch (hw->device_id) { |
332 | case IXGBE_DEV_ID_82599_KX4: | 332 | case IXGBE_DEV_ID_82599_KX4: |
333 | case IXGBE_DEV_ID_82599_KX4_MEZZ: | ||
334 | case IXGBE_DEV_ID_82599_COMBO_BACKPLANE: | ||
333 | case IXGBE_DEV_ID_82599_XAUI_LOM: | 335 | case IXGBE_DEV_ID_82599_XAUI_LOM: |
334 | /* Default device ID is mezzanine card KX/KX4 */ | 336 | /* Default device ID is mezzanine card KX/KX4 */ |
335 | media_type = ixgbe_media_type_backplane; | 337 | media_type = ixgbe_media_type_backplane; |
diff --git a/drivers/net/ixgbe/ixgbe_common.c b/drivers/net/ixgbe/ixgbe_common.c index 6621e172df3d..40ff120a9ad4 100644 --- a/drivers/net/ixgbe/ixgbe_common.c +++ b/drivers/net/ixgbe/ixgbe_common.c | |||
@@ -1355,9 +1355,7 @@ static void ixgbe_add_uc_addr(struct ixgbe_hw *hw, u8 *addr, u32 vmdq) | |||
1355 | /** | 1355 | /** |
1356 | * ixgbe_update_uc_addr_list_generic - Updates MAC list of secondary addresses | 1356 | * ixgbe_update_uc_addr_list_generic - Updates MAC list of secondary addresses |
1357 | * @hw: pointer to hardware structure | 1357 | * @hw: pointer to hardware structure |
1358 | * @addr_list: the list of new addresses | 1358 | * @uc_list: the list of new addresses |
1359 | * @addr_count: number of addresses | ||
1360 | * @next: iterator function to walk the address list | ||
1361 | * | 1359 | * |
1362 | * The given list replaces any existing list. Clears the secondary addrs from | 1360 | * The given list replaces any existing list. Clears the secondary addrs from |
1363 | * receive address registers. Uses unused receive address registers for the | 1361 | * receive address registers. Uses unused receive address registers for the |
@@ -1663,7 +1661,7 @@ s32 ixgbe_fc_enable_generic(struct ixgbe_hw *hw, s32 packetbuf_num) | |||
1663 | #endif /* CONFIG_DCB */ | 1661 | #endif /* CONFIG_DCB */ |
1664 | default: | 1662 | default: |
1665 | hw_dbg(hw, "Flow control param set incorrectly\n"); | 1663 | hw_dbg(hw, "Flow control param set incorrectly\n"); |
1666 | ret_val = -IXGBE_ERR_CONFIG; | 1664 | ret_val = IXGBE_ERR_CONFIG; |
1667 | goto out; | 1665 | goto out; |
1668 | break; | 1666 | break; |
1669 | } | 1667 | } |
@@ -1734,75 +1732,140 @@ s32 ixgbe_fc_autoneg(struct ixgbe_hw *hw) | |||
1734 | s32 ret_val = 0; | 1732 | s32 ret_val = 0; |
1735 | ixgbe_link_speed speed; | 1733 | ixgbe_link_speed speed; |
1736 | u32 pcs_anadv_reg, pcs_lpab_reg, linkstat; | 1734 | u32 pcs_anadv_reg, pcs_lpab_reg, linkstat; |
1735 | u32 links2, anlp1_reg, autoc_reg, links; | ||
1737 | bool link_up; | 1736 | bool link_up; |
1738 | 1737 | ||
1739 | /* | 1738 | /* |
1740 | * AN should have completed when the cable was plugged in. | 1739 | * AN should have completed when the cable was plugged in. |
1741 | * Look for reasons to bail out. Bail out if: | 1740 | * Look for reasons to bail out. Bail out if: |
1742 | * - FC autoneg is disabled, or if | 1741 | * - FC autoneg is disabled, or if |
1743 | * - we don't have multispeed fiber, or if | 1742 | * - link is not up. |
1744 | * - we're not running at 1G, or if | ||
1745 | * - link is not up, or if | ||
1746 | * - link is up but AN did not complete, or if | ||
1747 | * - link is up and AN completed but timed out | ||
1748 | * | 1743 | * |
1749 | * Since we're being called from an LSC, link is already know to be up. | 1744 | * Since we're being called from an LSC, link is already known to be up. |
1750 | * So use link_up_wait_to_complete=false. | 1745 | * So use link_up_wait_to_complete=false. |
1751 | */ | 1746 | */ |
1752 | hw->mac.ops.check_link(hw, &speed, &link_up, false); | 1747 | hw->mac.ops.check_link(hw, &speed, &link_up, false); |
1753 | linkstat = IXGBE_READ_REG(hw, IXGBE_PCS1GLSTA); | 1748 | |
1754 | 1749 | if (hw->fc.disable_fc_autoneg || (!link_up)) { | |
1755 | if (hw->fc.disable_fc_autoneg || | ||
1756 | !hw->phy.multispeed_fiber || | ||
1757 | (speed != IXGBE_LINK_SPEED_1GB_FULL) || | ||
1758 | !link_up || | ||
1759 | ((linkstat & IXGBE_PCS1GLSTA_AN_COMPLETE) == 0) || | ||
1760 | ((linkstat & IXGBE_PCS1GLSTA_AN_TIMED_OUT) == 1)) { | ||
1761 | hw->fc.fc_was_autonegged = false; | 1750 | hw->fc.fc_was_autonegged = false; |
1762 | hw->fc.current_mode = hw->fc.requested_mode; | 1751 | hw->fc.current_mode = hw->fc.requested_mode; |
1763 | hw_dbg(hw, "Autoneg FC was skipped.\n"); | ||
1764 | goto out; | 1752 | goto out; |
1765 | } | 1753 | } |
1766 | 1754 | ||
1767 | /* | 1755 | /* |
1756 | * On backplane, bail out if | ||
1757 | * - backplane autoneg was not completed, or if | ||
1758 | * - link partner is not AN enabled | ||
1759 | */ | ||
1760 | if (hw->phy.media_type == ixgbe_media_type_backplane) { | ||
1761 | links = IXGBE_READ_REG(hw, IXGBE_LINKS); | ||
1762 | links2 = IXGBE_READ_REG(hw, IXGBE_LINKS2); | ||
1763 | if (((links & IXGBE_LINKS_KX_AN_COMP) == 0) || | ||
1764 | ((links2 & IXGBE_LINKS2_AN_SUPPORTED) == 0)) { | ||
1765 | hw->fc.fc_was_autonegged = false; | ||
1766 | hw->fc.current_mode = hw->fc.requested_mode; | ||
1767 | goto out; | ||
1768 | } | ||
1769 | } | ||
1770 | |||
1771 | /* | ||
1772 | * On multispeed fiber at 1g, bail out if | ||
1773 | * - link is up but AN did not complete, or if | ||
1774 | * - link is up and AN completed but timed out | ||
1775 | */ | ||
1776 | if (hw->phy.multispeed_fiber && (speed == IXGBE_LINK_SPEED_1GB_FULL)) { | ||
1777 | linkstat = IXGBE_READ_REG(hw, IXGBE_PCS1GLSTA); | ||
1778 | if (((linkstat & IXGBE_PCS1GLSTA_AN_COMPLETE) == 0) || | ||
1779 | ((linkstat & IXGBE_PCS1GLSTA_AN_TIMED_OUT) == 1)) { | ||
1780 | hw->fc.fc_was_autonegged = false; | ||
1781 | hw->fc.current_mode = hw->fc.requested_mode; | ||
1782 | goto out; | ||
1783 | } | ||
1784 | } | ||
1785 | |||
1786 | /* | ||
1768 | * Read the AN advertisement and LP ability registers and resolve | 1787 | * Read the AN advertisement and LP ability registers and resolve |
1769 | * local flow control settings accordingly | 1788 | * local flow control settings accordingly |
1770 | */ | 1789 | */ |
1771 | pcs_anadv_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA); | 1790 | if ((speed == IXGBE_LINK_SPEED_1GB_FULL) && |
1772 | pcs_lpab_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANLP); | 1791 | (hw->phy.media_type != ixgbe_media_type_backplane)) { |
1773 | if ((pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | 1792 | pcs_anadv_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA); |
1774 | (pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE)) { | 1793 | pcs_lpab_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANLP); |
1794 | if ((pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1795 | (pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE)) { | ||
1796 | /* | ||
1797 | * Now we need to check if the user selected Rx ONLY | ||
1798 | * of pause frames. In this case, we had to advertise | ||
1799 | * FULL flow control because we could not advertise RX | ||
1800 | * ONLY. Hence, we must now check to see if we need to | ||
1801 | * turn OFF the TRANSMISSION of PAUSE frames. | ||
1802 | */ | ||
1803 | if (hw->fc.requested_mode == ixgbe_fc_full) { | ||
1804 | hw->fc.current_mode = ixgbe_fc_full; | ||
1805 | hw_dbg(hw, "Flow Control = FULL.\n"); | ||
1806 | } else { | ||
1807 | hw->fc.current_mode = ixgbe_fc_rx_pause; | ||
1808 | hw_dbg(hw, "Flow Control=RX PAUSE only\n"); | ||
1809 | } | ||
1810 | } else if (!(pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1811 | (pcs_anadv_reg & IXGBE_PCS1GANA_ASM_PAUSE) && | ||
1812 | (pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1813 | (pcs_lpab_reg & IXGBE_PCS1GANA_ASM_PAUSE)) { | ||
1814 | hw->fc.current_mode = ixgbe_fc_tx_pause; | ||
1815 | hw_dbg(hw, "Flow Control = TX PAUSE frames only.\n"); | ||
1816 | } else if ((pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1817 | (pcs_anadv_reg & IXGBE_PCS1GANA_ASM_PAUSE) && | ||
1818 | !(pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1819 | (pcs_lpab_reg & IXGBE_PCS1GANA_ASM_PAUSE)) { | ||
1820 | hw->fc.current_mode = ixgbe_fc_rx_pause; | ||
1821 | hw_dbg(hw, "Flow Control = RX PAUSE frames only.\n"); | ||
1822 | } else { | ||
1823 | hw->fc.current_mode = ixgbe_fc_none; | ||
1824 | hw_dbg(hw, "Flow Control = NONE.\n"); | ||
1825 | } | ||
1826 | } | ||
1827 | |||
1828 | if (hw->phy.media_type == ixgbe_media_type_backplane) { | ||
1775 | /* | 1829 | /* |
1776 | * Now we need to check if the user selected Rx ONLY | 1830 | * Read the 10g AN autoc and LP ability registers and resolve |
1777 | * of pause frames. In this case, we had to advertise | 1831 | * local flow control settings accordingly |
1778 | * FULL flow control because we could not advertise RX | ||
1779 | * ONLY. Hence, we must now check to see if we need to | ||
1780 | * turn OFF the TRANSMISSION of PAUSE frames. | ||
1781 | */ | 1832 | */ |
1782 | if (hw->fc.requested_mode == ixgbe_fc_full) { | 1833 | autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC); |
1783 | hw->fc.current_mode = ixgbe_fc_full; | 1834 | anlp1_reg = IXGBE_READ_REG(hw, IXGBE_ANLP1); |
1784 | hw_dbg(hw, "Flow Control = FULL.\n"); | 1835 | |
1785 | } else { | 1836 | if ((autoc_reg & IXGBE_AUTOC_SYM_PAUSE) && |
1837 | (anlp1_reg & IXGBE_ANLP1_SYM_PAUSE)) { | ||
1838 | /* | ||
1839 | * Now we need to check if the user selected Rx ONLY | ||
1840 | * of pause frames. In this case, we had to advertise | ||
1841 | * FULL flow control because we could not advertise RX | ||
1842 | * ONLY. Hence, we must now check to see if we need to | ||
1843 | * turn OFF the TRANSMISSION of PAUSE frames. | ||
1844 | */ | ||
1845 | if (hw->fc.requested_mode == ixgbe_fc_full) { | ||
1846 | hw->fc.current_mode = ixgbe_fc_full; | ||
1847 | hw_dbg(hw, "Flow Control = FULL.\n"); | ||
1848 | } else { | ||
1849 | hw->fc.current_mode = ixgbe_fc_rx_pause; | ||
1850 | hw_dbg(hw, "Flow Control=RX PAUSE only\n"); | ||
1851 | } | ||
1852 | } else if (!(autoc_reg & IXGBE_AUTOC_SYM_PAUSE) && | ||
1853 | (autoc_reg & IXGBE_AUTOC_ASM_PAUSE) && | ||
1854 | (anlp1_reg & IXGBE_ANLP1_SYM_PAUSE) && | ||
1855 | (anlp1_reg & IXGBE_ANLP1_ASM_PAUSE)) { | ||
1856 | hw->fc.current_mode = ixgbe_fc_tx_pause; | ||
1857 | hw_dbg(hw, "Flow Control = TX PAUSE frames only.\n"); | ||
1858 | } else if ((autoc_reg & IXGBE_AUTOC_SYM_PAUSE) && | ||
1859 | (autoc_reg & IXGBE_AUTOC_ASM_PAUSE) && | ||
1860 | !(anlp1_reg & IXGBE_ANLP1_SYM_PAUSE) && | ||
1861 | (anlp1_reg & IXGBE_ANLP1_ASM_PAUSE)) { | ||
1786 | hw->fc.current_mode = ixgbe_fc_rx_pause; | 1862 | hw->fc.current_mode = ixgbe_fc_rx_pause; |
1787 | hw_dbg(hw, "Flow Control = RX PAUSE frames only.\n"); | 1863 | hw_dbg(hw, "Flow Control = RX PAUSE frames only.\n"); |
1864 | } else { | ||
1865 | hw->fc.current_mode = ixgbe_fc_none; | ||
1866 | hw_dbg(hw, "Flow Control = NONE.\n"); | ||
1788 | } | 1867 | } |
1789 | } else if (!(pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1790 | (pcs_anadv_reg & IXGBE_PCS1GANA_ASM_PAUSE) && | ||
1791 | (pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1792 | (pcs_lpab_reg & IXGBE_PCS1GANA_ASM_PAUSE)) { | ||
1793 | hw->fc.current_mode = ixgbe_fc_tx_pause; | ||
1794 | hw_dbg(hw, "Flow Control = TX PAUSE frames only.\n"); | ||
1795 | } else if ((pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1796 | (pcs_anadv_reg & IXGBE_PCS1GANA_ASM_PAUSE) && | ||
1797 | !(pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE) && | ||
1798 | (pcs_lpab_reg & IXGBE_PCS1GANA_ASM_PAUSE)) { | ||
1799 | hw->fc.current_mode = ixgbe_fc_rx_pause; | ||
1800 | hw_dbg(hw, "Flow Control = RX PAUSE frames only.\n"); | ||
1801 | } else { | ||
1802 | hw->fc.current_mode = ixgbe_fc_none; | ||
1803 | hw_dbg(hw, "Flow Control = NONE.\n"); | ||
1804 | } | 1868 | } |
1805 | |||
1806 | /* Record that current_mode is the result of a successful autoneg */ | 1869 | /* Record that current_mode is the result of a successful autoneg */ |
1807 | hw->fc.fc_was_autonegged = true; | 1870 | hw->fc.fc_was_autonegged = true; |
1808 | 1871 | ||
@@ -1919,7 +1982,7 @@ static s32 ixgbe_setup_fc(struct ixgbe_hw *hw, s32 packetbuf_num) | |||
1919 | #endif /* CONFIG_DCB */ | 1982 | #endif /* CONFIG_DCB */ |
1920 | default: | 1983 | default: |
1921 | hw_dbg(hw, "Flow control param set incorrectly\n"); | 1984 | hw_dbg(hw, "Flow control param set incorrectly\n"); |
1922 | ret_val = -IXGBE_ERR_CONFIG; | 1985 | ret_val = IXGBE_ERR_CONFIG; |
1923 | goto out; | 1986 | goto out; |
1924 | break; | 1987 | break; |
1925 | } | 1988 | } |
@@ -1927,9 +1990,6 @@ static s32 ixgbe_setup_fc(struct ixgbe_hw *hw, s32 packetbuf_num) | |||
1927 | IXGBE_WRITE_REG(hw, IXGBE_PCS1GANA, reg); | 1990 | IXGBE_WRITE_REG(hw, IXGBE_PCS1GANA, reg); |
1928 | reg = IXGBE_READ_REG(hw, IXGBE_PCS1GLCTL); | 1991 | reg = IXGBE_READ_REG(hw, IXGBE_PCS1GLCTL); |
1929 | 1992 | ||
1930 | /* Enable and restart autoneg to inform the link partner */ | ||
1931 | reg |= IXGBE_PCS1GLCTL_AN_ENABLE | IXGBE_PCS1GLCTL_AN_RESTART; | ||
1932 | |||
1933 | /* Disable AN timeout */ | 1993 | /* Disable AN timeout */ |
1934 | if (hw->fc.strict_ieee) | 1994 | if (hw->fc.strict_ieee) |
1935 | reg &= ~IXGBE_PCS1GLCTL_AN_1G_TIMEOUT_EN; | 1995 | reg &= ~IXGBE_PCS1GLCTL_AN_1G_TIMEOUT_EN; |
@@ -1937,6 +1997,70 @@ static s32 ixgbe_setup_fc(struct ixgbe_hw *hw, s32 packetbuf_num) | |||
1937 | IXGBE_WRITE_REG(hw, IXGBE_PCS1GLCTL, reg); | 1997 | IXGBE_WRITE_REG(hw, IXGBE_PCS1GLCTL, reg); |
1938 | hw_dbg(hw, "Set up FC; PCS1GLCTL = 0x%08X\n", reg); | 1998 | hw_dbg(hw, "Set up FC; PCS1GLCTL = 0x%08X\n", reg); |
1939 | 1999 | ||
2000 | /* | ||
2001 | * Set up the 10G flow control advertisement registers so the HW | ||
2002 | * can do fc autoneg once the cable is plugged in. If we end up | ||
2003 | * using 1g instead, this is harmless. | ||
2004 | */ | ||
2005 | reg = IXGBE_READ_REG(hw, IXGBE_AUTOC); | ||
2006 | |||
2007 | /* | ||
2008 | * The possible values of fc.requested_mode are: | ||
2009 | * 0: Flow control is completely disabled | ||
2010 | * 1: Rx flow control is enabled (we can receive pause frames, | ||
2011 | * but not send pause frames). | ||
2012 | * 2: Tx flow control is enabled (we can send pause frames but | ||
2013 | * we do not support receiving pause frames). | ||
2014 | * 3: Both Rx and Tx flow control (symmetric) are enabled. | ||
2015 | * other: Invalid. | ||
2016 | */ | ||
2017 | switch (hw->fc.requested_mode) { | ||
2018 | case ixgbe_fc_none: | ||
2019 | /* Flow control completely disabled by software override. */ | ||
2020 | reg &= ~(IXGBE_AUTOC_SYM_PAUSE | IXGBE_AUTOC_ASM_PAUSE); | ||
2021 | break; | ||
2022 | case ixgbe_fc_rx_pause: | ||
2023 | /* | ||
2024 | * Rx Flow control is enabled and Tx Flow control is | ||
2025 | * disabled by software override. Since there really | ||
2026 | * isn't a way to advertise that we are capable of RX | ||
2027 | * Pause ONLY, we will advertise that we support both | ||
2028 | * symmetric and asymmetric Rx PAUSE. Later, we will | ||
2029 | * disable the adapter's ability to send PAUSE frames. | ||
2030 | */ | ||
2031 | reg |= (IXGBE_AUTOC_SYM_PAUSE | IXGBE_AUTOC_ASM_PAUSE); | ||
2032 | break; | ||
2033 | case ixgbe_fc_tx_pause: | ||
2034 | /* | ||
2035 | * Tx Flow control is enabled, and Rx Flow control is | ||
2036 | * disabled by software override. | ||
2037 | */ | ||
2038 | reg |= (IXGBE_AUTOC_ASM_PAUSE); | ||
2039 | reg &= ~(IXGBE_AUTOC_SYM_PAUSE); | ||
2040 | break; | ||
2041 | case ixgbe_fc_full: | ||
2042 | /* Flow control (both Rx and Tx) is enabled by SW override. */ | ||
2043 | reg |= (IXGBE_AUTOC_SYM_PAUSE | IXGBE_AUTOC_ASM_PAUSE); | ||
2044 | break; | ||
2045 | #ifdef CONFIG_DCB | ||
2046 | case ixgbe_fc_pfc: | ||
2047 | goto out; | ||
2048 | break; | ||
2049 | #endif /* CONFIG_DCB */ | ||
2050 | default: | ||
2051 | hw_dbg(hw, "Flow control param set incorrectly\n"); | ||
2052 | ret_val = IXGBE_ERR_CONFIG; | ||
2053 | goto out; | ||
2054 | break; | ||
2055 | } | ||
2056 | /* | ||
2057 | * AUTOC restart handles negotiation of 1G and 10G. There is | ||
2058 | * no need to set the PCS1GCTL register. | ||
2059 | */ | ||
2060 | reg |= IXGBE_AUTOC_AN_RESTART; | ||
2061 | IXGBE_WRITE_REG(hw, IXGBE_AUTOC, reg); | ||
2062 | hw_dbg(hw, "Set up FC; IXGBE_AUTOC = 0x%08X\n", reg); | ||
2063 | |||
1940 | out: | 2064 | out: |
1941 | return ret_val; | 2065 | return ret_val; |
1942 | } | 2066 | } |
@@ -2000,7 +2124,7 @@ s32 ixgbe_acquire_swfw_sync(struct ixgbe_hw *hw, u16 mask) | |||
2000 | 2124 | ||
2001 | while (timeout) { | 2125 | while (timeout) { |
2002 | if (ixgbe_get_eeprom_semaphore(hw)) | 2126 | if (ixgbe_get_eeprom_semaphore(hw)) |
2003 | return -IXGBE_ERR_SWFW_SYNC; | 2127 | return IXGBE_ERR_SWFW_SYNC; |
2004 | 2128 | ||
2005 | gssr = IXGBE_READ_REG(hw, IXGBE_GSSR); | 2129 | gssr = IXGBE_READ_REG(hw, IXGBE_GSSR); |
2006 | if (!(gssr & (fwmask | swmask))) | 2130 | if (!(gssr & (fwmask | swmask))) |
@@ -2017,7 +2141,7 @@ s32 ixgbe_acquire_swfw_sync(struct ixgbe_hw *hw, u16 mask) | |||
2017 | 2141 | ||
2018 | if (!timeout) { | 2142 | if (!timeout) { |
2019 | hw_dbg(hw, "Driver can't access resource, GSSR timeout.\n"); | 2143 | hw_dbg(hw, "Driver can't access resource, GSSR timeout.\n"); |
2020 | return -IXGBE_ERR_SWFW_SYNC; | 2144 | return IXGBE_ERR_SWFW_SYNC; |
2021 | } | 2145 | } |
2022 | 2146 | ||
2023 | gssr |= swmask; | 2147 | gssr |= swmask; |
diff --git a/drivers/net/ixgbe/ixgbe_ethtool.c b/drivers/net/ixgbe/ixgbe_ethtool.c index 53b0a6680254..fa314cb005a4 100644 --- a/drivers/net/ixgbe/ixgbe_ethtool.c +++ b/drivers/net/ixgbe/ixgbe_ethtool.c | |||
@@ -53,6 +53,10 @@ static struct ixgbe_stats ixgbe_gstrings_stats[] = { | |||
53 | {"tx_packets", IXGBE_STAT(net_stats.tx_packets)}, | 53 | {"tx_packets", IXGBE_STAT(net_stats.tx_packets)}, |
54 | {"rx_bytes", IXGBE_STAT(net_stats.rx_bytes)}, | 54 | {"rx_bytes", IXGBE_STAT(net_stats.rx_bytes)}, |
55 | {"tx_bytes", IXGBE_STAT(net_stats.tx_bytes)}, | 55 | {"tx_bytes", IXGBE_STAT(net_stats.tx_bytes)}, |
56 | {"rx_pkts_nic", IXGBE_STAT(stats.gprc)}, | ||
57 | {"tx_pkts_nic", IXGBE_STAT(stats.gptc)}, | ||
58 | {"rx_bytes_nic", IXGBE_STAT(stats.gorc)}, | ||
59 | {"tx_bytes_nic", IXGBE_STAT(stats.gotc)}, | ||
56 | {"lsc_int", IXGBE_STAT(lsc_int)}, | 60 | {"lsc_int", IXGBE_STAT(lsc_int)}, |
57 | {"tx_busy", IXGBE_STAT(tx_busy)}, | 61 | {"tx_busy", IXGBE_STAT(tx_busy)}, |
58 | {"non_eop_descs", IXGBE_STAT(non_eop_descs)}, | 62 | {"non_eop_descs", IXGBE_STAT(non_eop_descs)}, |
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c index c407bd9de0dd..cbb143ca1eb8 100644 --- a/drivers/net/ixgbe/ixgbe_main.c +++ b/drivers/net/ixgbe/ixgbe_main.c | |||
@@ -49,7 +49,7 @@ char ixgbe_driver_name[] = "ixgbe"; | |||
49 | static const char ixgbe_driver_string[] = | 49 | static const char ixgbe_driver_string[] = |
50 | "Intel(R) 10 Gigabit PCI Express Network Driver"; | 50 | "Intel(R) 10 Gigabit PCI Express Network Driver"; |
51 | 51 | ||
52 | #define DRV_VERSION "2.0.37-k2" | 52 | #define DRV_VERSION "2.0.44-k2" |
53 | const char ixgbe_driver_version[] = DRV_VERSION; | 53 | const char ixgbe_driver_version[] = DRV_VERSION; |
54 | static char ixgbe_copyright[] = "Copyright (c) 1999-2009 Intel Corporation."; | 54 | static char ixgbe_copyright[] = "Copyright (c) 1999-2009 Intel Corporation."; |
55 | 55 | ||
@@ -97,8 +97,12 @@ static struct pci_device_id ixgbe_pci_tbl[] = { | |||
97 | board_82599 }, | 97 | board_82599 }, |
98 | {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP), | 98 | {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP), |
99 | board_82599 }, | 99 | board_82599 }, |
100 | {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KX4_MEZZ), | ||
101 | board_82599 }, | ||
100 | {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_CX4), | 102 | {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_CX4), |
101 | board_82599 }, | 103 | board_82599 }, |
104 | {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_COMBO_BACKPLANE), | ||
105 | board_82599 }, | ||
102 | 106 | ||
103 | /* required last entry */ | 107 | /* required last entry */ |
104 | {0, } | 108 | {0, } |
@@ -1885,12 +1889,29 @@ static void ixgbe_configure_tx(struct ixgbe_adapter *adapter) | |||
1885 | IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0); | 1889 | IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0); |
1886 | adapter->tx_ring[i].head = IXGBE_TDH(j); | 1890 | adapter->tx_ring[i].head = IXGBE_TDH(j); |
1887 | adapter->tx_ring[i].tail = IXGBE_TDT(j); | 1891 | adapter->tx_ring[i].tail = IXGBE_TDT(j); |
1888 | /* Disable Tx Head Writeback RO bit, since this hoses | 1892 | /* |
1893 | * Disable Tx Head Writeback RO bit, since this hoses | ||
1889 | * bookkeeping if things aren't delivered in order. | 1894 | * bookkeeping if things aren't delivered in order. |
1890 | */ | 1895 | */ |
1891 | txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j)); | 1896 | switch (hw->mac.type) { |
1897 | case ixgbe_mac_82598EB: | ||
1898 | txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j)); | ||
1899 | break; | ||
1900 | case ixgbe_mac_82599EB: | ||
1901 | default: | ||
1902 | txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(j)); | ||
1903 | break; | ||
1904 | } | ||
1892 | txctrl &= ~IXGBE_DCA_TXCTRL_TX_WB_RO_EN; | 1905 | txctrl &= ~IXGBE_DCA_TXCTRL_TX_WB_RO_EN; |
1893 | IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl); | 1906 | switch (hw->mac.type) { |
1907 | case ixgbe_mac_82598EB: | ||
1908 | IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl); | ||
1909 | break; | ||
1910 | case ixgbe_mac_82599EB: | ||
1911 | default: | ||
1912 | IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(j), txctrl); | ||
1913 | break; | ||
1914 | } | ||
1894 | } | 1915 | } |
1895 | if (hw->mac.type == ixgbe_mac_82599EB) { | 1916 | if (hw->mac.type == ixgbe_mac_82599EB) { |
1896 | /* We enable 8 traffic classes, DCB only */ | 1917 | /* We enable 8 traffic classes, DCB only */ |
@@ -4432,10 +4453,13 @@ void ixgbe_update_stats(struct ixgbe_adapter *adapter) | |||
4432 | 4453 | ||
4433 | /* 82598 hardware only has a 32 bit counter in the high register */ | 4454 | /* 82598 hardware only has a 32 bit counter in the high register */ |
4434 | if (hw->mac.type == ixgbe_mac_82599EB) { | 4455 | if (hw->mac.type == ixgbe_mac_82599EB) { |
4456 | u64 tmp; | ||
4435 | adapter->stats.gorc += IXGBE_READ_REG(hw, IXGBE_GORCL); | 4457 | adapter->stats.gorc += IXGBE_READ_REG(hw, IXGBE_GORCL); |
4436 | IXGBE_READ_REG(hw, IXGBE_GORCH); /* to clear */ | 4458 | tmp = IXGBE_READ_REG(hw, IXGBE_GORCH) & 0xF; /* 4 high bits of GORC */ |
4459 | adapter->stats.gorc += (tmp << 32); | ||
4437 | adapter->stats.gotc += IXGBE_READ_REG(hw, IXGBE_GOTCL); | 4460 | adapter->stats.gotc += IXGBE_READ_REG(hw, IXGBE_GOTCL); |
4438 | IXGBE_READ_REG(hw, IXGBE_GOTCH); /* to clear */ | 4461 | tmp = IXGBE_READ_REG(hw, IXGBE_GOTCH) & 0xF; /* 4 high bits of GOTC */ |
4462 | adapter->stats.gotc += (tmp << 32); | ||
4439 | adapter->stats.tor += IXGBE_READ_REG(hw, IXGBE_TORL); | 4463 | adapter->stats.tor += IXGBE_READ_REG(hw, IXGBE_TORL); |
4440 | IXGBE_READ_REG(hw, IXGBE_TORH); /* to clear */ | 4464 | IXGBE_READ_REG(hw, IXGBE_TORH); /* to clear */ |
4441 | adapter->stats.lxonrxc += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); | 4465 | adapter->stats.lxonrxc += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); |
@@ -5071,7 +5095,6 @@ static void ixgbe_atr(struct ixgbe_adapter *adapter, struct sk_buff *skb, | |||
5071 | /* Right now, we support IPv4 only */ | 5095 | /* Right now, we support IPv4 only */ |
5072 | struct ixgbe_atr_input atr_input; | 5096 | struct ixgbe_atr_input atr_input; |
5073 | struct tcphdr *th; | 5097 | struct tcphdr *th; |
5074 | struct udphdr *uh; | ||
5075 | struct iphdr *iph = ip_hdr(skb); | 5098 | struct iphdr *iph = ip_hdr(skb); |
5076 | struct ethhdr *eth = (struct ethhdr *)skb->data; | 5099 | struct ethhdr *eth = (struct ethhdr *)skb->data; |
5077 | u16 vlan_id, src_port, dst_port, flex_bytes; | 5100 | u16 vlan_id, src_port, dst_port, flex_bytes; |
@@ -5085,12 +5108,6 @@ static void ixgbe_atr(struct ixgbe_adapter *adapter, struct sk_buff *skb, | |||
5085 | dst_port = th->dest; | 5108 | dst_port = th->dest; |
5086 | l4type |= IXGBE_ATR_L4TYPE_TCP; | 5109 | l4type |= IXGBE_ATR_L4TYPE_TCP; |
5087 | /* l4type IPv4 type is 0, no need to assign */ | 5110 | /* l4type IPv4 type is 0, no need to assign */ |
5088 | } else if(iph->protocol == IPPROTO_UDP) { | ||
5089 | uh = udp_hdr(skb); | ||
5090 | src_port = uh->source; | ||
5091 | dst_port = uh->dest; | ||
5092 | l4type |= IXGBE_ATR_L4TYPE_UDP; | ||
5093 | /* l4type IPv4 type is 0, no need to assign */ | ||
5094 | } else { | 5111 | } else { |
5095 | /* Unsupported L4 header, just bail here */ | 5112 | /* Unsupported L4 header, just bail here */ |
5096 | return; | 5113 | return; |
@@ -5494,12 +5511,7 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev, | |||
5494 | goto err_pci_reg; | 5511 | goto err_pci_reg; |
5495 | } | 5512 | } |
5496 | 5513 | ||
5497 | err = pci_enable_pcie_error_reporting(pdev); | 5514 | pci_enable_pcie_error_reporting(pdev); |
5498 | if (err) { | ||
5499 | dev_err(&pdev->dev, "pci_enable_pcie_error_reporting failed " | ||
5500 | "0x%x\n", err); | ||
5501 | /* non-fatal, continue */ | ||
5502 | } | ||
5503 | 5515 | ||
5504 | pci_set_master(pdev); | 5516 | pci_set_master(pdev); |
5505 | pci_save_state(pdev); | 5517 | pci_save_state(pdev); |
@@ -5808,7 +5820,6 @@ static void __devexit ixgbe_remove(struct pci_dev *pdev) | |||
5808 | { | 5820 | { |
5809 | struct net_device *netdev = pci_get_drvdata(pdev); | 5821 | struct net_device *netdev = pci_get_drvdata(pdev); |
5810 | struct ixgbe_adapter *adapter = netdev_priv(netdev); | 5822 | struct ixgbe_adapter *adapter = netdev_priv(netdev); |
5811 | int err; | ||
5812 | 5823 | ||
5813 | set_bit(__IXGBE_DOWN, &adapter->state); | 5824 | set_bit(__IXGBE_DOWN, &adapter->state); |
5814 | /* clear the module not found bit to make sure the worker won't | 5825 | /* clear the module not found bit to make sure the worker won't |
@@ -5859,10 +5870,7 @@ static void __devexit ixgbe_remove(struct pci_dev *pdev) | |||
5859 | 5870 | ||
5860 | free_netdev(netdev); | 5871 | free_netdev(netdev); |
5861 | 5872 | ||
5862 | err = pci_disable_pcie_error_reporting(pdev); | 5873 | pci_disable_pcie_error_reporting(pdev); |
5863 | if (err) | ||
5864 | dev_err(&pdev->dev, | ||
5865 | "pci_disable_pcie_error_reporting failed 0x%x\n", err); | ||
5866 | 5874 | ||
5867 | pci_disable_device(pdev); | 5875 | pci_disable_device(pdev); |
5868 | } | 5876 | } |
diff --git a/drivers/net/ixgbe/ixgbe_type.h b/drivers/net/ixgbe/ixgbe_type.h index 8761d7899f7d..ef4bdd58e016 100644 --- a/drivers/net/ixgbe/ixgbe_type.h +++ b/drivers/net/ixgbe/ixgbe_type.h | |||
@@ -49,9 +49,11 @@ | |||
49 | #define IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM 0x10E1 | 49 | #define IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM 0x10E1 |
50 | #define IXGBE_DEV_ID_82598EB_XF_LR 0x10F4 | 50 | #define IXGBE_DEV_ID_82598EB_XF_LR 0x10F4 |
51 | #define IXGBE_DEV_ID_82599_KX4 0x10F7 | 51 | #define IXGBE_DEV_ID_82599_KX4 0x10F7 |
52 | #define IXGBE_DEV_ID_82599_KX4_MEZZ 0x1514 | ||
52 | #define IXGBE_DEV_ID_82599_CX4 0x10F9 | 53 | #define IXGBE_DEV_ID_82599_CX4 0x10F9 |
53 | #define IXGBE_DEV_ID_82599_SFP 0x10FB | 54 | #define IXGBE_DEV_ID_82599_SFP 0x10FB |
54 | #define IXGBE_DEV_ID_82599_XAUI_LOM 0x10FC | 55 | #define IXGBE_DEV_ID_82599_XAUI_LOM 0x10FC |
56 | #define IXGBE_DEV_ID_82599_COMBO_BACKPLANE 0x10F8 | ||
55 | 57 | ||
56 | /* General Registers */ | 58 | /* General Registers */ |
57 | #define IXGBE_CTRL 0x00000 | 59 | #define IXGBE_CTRL 0x00000 |
@@ -1336,6 +1338,8 @@ | |||
1336 | #define IXGBE_AUTOC_KX4_SUPP 0x80000000 | 1338 | #define IXGBE_AUTOC_KX4_SUPP 0x80000000 |
1337 | #define IXGBE_AUTOC_KX_SUPP 0x40000000 | 1339 | #define IXGBE_AUTOC_KX_SUPP 0x40000000 |
1338 | #define IXGBE_AUTOC_PAUSE 0x30000000 | 1340 | #define IXGBE_AUTOC_PAUSE 0x30000000 |
1341 | #define IXGBE_AUTOC_ASM_PAUSE 0x20000000 | ||
1342 | #define IXGBE_AUTOC_SYM_PAUSE 0x10000000 | ||
1339 | #define IXGBE_AUTOC_RF 0x08000000 | 1343 | #define IXGBE_AUTOC_RF 0x08000000 |
1340 | #define IXGBE_AUTOC_PD_TMR 0x06000000 | 1344 | #define IXGBE_AUTOC_PD_TMR 0x06000000 |
1341 | #define IXGBE_AUTOC_AN_RX_LOOSE 0x01000000 | 1345 | #define IXGBE_AUTOC_AN_RX_LOOSE 0x01000000 |
@@ -1404,6 +1408,8 @@ | |||
1404 | #define IXGBE_LINK_UP_TIME 90 /* 9.0 Seconds */ | 1408 | #define IXGBE_LINK_UP_TIME 90 /* 9.0 Seconds */ |
1405 | #define IXGBE_AUTO_NEG_TIME 45 /* 4.5 Seconds */ | 1409 | #define IXGBE_AUTO_NEG_TIME 45 /* 4.5 Seconds */ |
1406 | 1410 | ||
1411 | #define IXGBE_LINKS2_AN_SUPPORTED 0x00000040 | ||
1412 | |||
1407 | /* PCS1GLSTA Bit Masks */ | 1413 | /* PCS1GLSTA Bit Masks */ |
1408 | #define IXGBE_PCS1GLSTA_LINK_OK 1 | 1414 | #define IXGBE_PCS1GLSTA_LINK_OK 1 |
1409 | #define IXGBE_PCS1GLSTA_SYNK_OK 0x10 | 1415 | #define IXGBE_PCS1GLSTA_SYNK_OK 0x10 |
@@ -1424,6 +1430,11 @@ | |||
1424 | #define IXGBE_PCS1GLCTL_AN_ENABLE 0x10000 | 1430 | #define IXGBE_PCS1GLCTL_AN_ENABLE 0x10000 |
1425 | #define IXGBE_PCS1GLCTL_AN_RESTART 0x20000 | 1431 | #define IXGBE_PCS1GLCTL_AN_RESTART 0x20000 |
1426 | 1432 | ||
1433 | /* ANLP1 Bit Masks */ | ||
1434 | #define IXGBE_ANLP1_PAUSE 0x0C00 | ||
1435 | #define IXGBE_ANLP1_SYM_PAUSE 0x0400 | ||
1436 | #define IXGBE_ANLP1_ASM_PAUSE 0x0800 | ||
1437 | |||
1427 | /* SW Semaphore Register bitmasks */ | 1438 | /* SW Semaphore Register bitmasks */ |
1428 | #define IXGBE_SWSM_SMBI 0x00000001 /* Driver Semaphore bit */ | 1439 | #define IXGBE_SWSM_SMBI 0x00000001 /* Driver Semaphore bit */ |
1429 | #define IXGBE_SWSM_SWESMBI 0x00000002 /* FW Semaphore bit */ | 1440 | #define IXGBE_SWSM_SWESMBI 0x00000002 /* FW Semaphore bit */ |
diff --git a/drivers/net/ks8851_mll.c b/drivers/net/ks8851_mll.c new file mode 100644 index 000000000000..0be14d702beb --- /dev/null +++ b/drivers/net/ks8851_mll.c | |||
@@ -0,0 +1,1697 @@ | |||
1 | /** | ||
2 | * drivers/net/ks8851_mll.c | ||
3 | * Copyright (c) 2009 Micrel Inc. | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify | ||
6 | * it under the terms of the GNU General Public License version 2 as | ||
7 | * published by the Free Software Foundation. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | * GNU General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License | ||
15 | * along with this program; if not, write to the Free Software | ||
16 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
17 | */ | ||
18 | |||
19 | /** | ||
20 | * Supports: | ||
21 | * KS8851 16bit MLL chip from Micrel Inc. | ||
22 | */ | ||
23 | |||
24 | #include <linux/module.h> | ||
25 | #include <linux/kernel.h> | ||
26 | #include <linux/netdevice.h> | ||
27 | #include <linux/etherdevice.h> | ||
28 | #include <linux/ethtool.h> | ||
29 | #include <linux/cache.h> | ||
30 | #include <linux/crc32.h> | ||
31 | #include <linux/mii.h> | ||
32 | #include <linux/platform_device.h> | ||
33 | #include <linux/delay.h> | ||
34 | |||
35 | #define DRV_NAME "ks8851_mll" | ||
36 | |||
37 | static u8 KS_DEFAULT_MAC_ADDRESS[] = { 0x00, 0x10, 0xA1, 0x86, 0x95, 0x11 }; | ||
38 | #define MAX_RECV_FRAMES 32 | ||
39 | #define MAX_BUF_SIZE 2048 | ||
40 | #define TX_BUF_SIZE 2000 | ||
41 | #define RX_BUF_SIZE 2000 | ||
42 | |||
43 | #define KS_CCR 0x08 | ||
44 | #define CCR_EEPROM (1 << 9) | ||
45 | #define CCR_SPI (1 << 8) | ||
46 | #define CCR_8BIT (1 << 7) | ||
47 | #define CCR_16BIT (1 << 6) | ||
48 | #define CCR_32BIT (1 << 5) | ||
49 | #define CCR_SHARED (1 << 4) | ||
50 | #define CCR_32PIN (1 << 0) | ||
51 | |||
52 | /* MAC address registers */ | ||
53 | #define KS_MARL 0x10 | ||
54 | #define KS_MARM 0x12 | ||
55 | #define KS_MARH 0x14 | ||
56 | |||
57 | #define KS_OBCR 0x20 | ||
58 | #define OBCR_ODS_16MA (1 << 6) | ||
59 | |||
60 | #define KS_EEPCR 0x22 | ||
61 | #define EEPCR_EESA (1 << 4) | ||
62 | #define EEPCR_EESB (1 << 3) | ||
63 | #define EEPCR_EEDO (1 << 2) | ||
64 | #define EEPCR_EESCK (1 << 1) | ||
65 | #define EEPCR_EECS (1 << 0) | ||
66 | |||
67 | #define KS_MBIR 0x24 | ||
68 | #define MBIR_TXMBF (1 << 12) | ||
69 | #define MBIR_TXMBFA (1 << 11) | ||
70 | #define MBIR_RXMBF (1 << 4) | ||
71 | #define MBIR_RXMBFA (1 << 3) | ||
72 | |||
73 | #define KS_GRR 0x26 | ||
74 | #define GRR_QMU (1 << 1) | ||
75 | #define GRR_GSR (1 << 0) | ||
76 | |||
77 | #define KS_WFCR 0x2A | ||
78 | #define WFCR_MPRXE (1 << 7) | ||
79 | #define WFCR_WF3E (1 << 3) | ||
80 | #define WFCR_WF2E (1 << 2) | ||
81 | #define WFCR_WF1E (1 << 1) | ||
82 | #define WFCR_WF0E (1 << 0) | ||
83 | |||
84 | #define KS_WF0CRC0 0x30 | ||
85 | #define KS_WF0CRC1 0x32 | ||
86 | #define KS_WF0BM0 0x34 | ||
87 | #define KS_WF0BM1 0x36 | ||
88 | #define KS_WF0BM2 0x38 | ||
89 | #define KS_WF0BM3 0x3A | ||
90 | |||
91 | #define KS_WF1CRC0 0x40 | ||
92 | #define KS_WF1CRC1 0x42 | ||
93 | #define KS_WF1BM0 0x44 | ||
94 | #define KS_WF1BM1 0x46 | ||
95 | #define KS_WF1BM2 0x48 | ||
96 | #define KS_WF1BM3 0x4A | ||
97 | |||
98 | #define KS_WF2CRC0 0x50 | ||
99 | #define KS_WF2CRC1 0x52 | ||
100 | #define KS_WF2BM0 0x54 | ||
101 | #define KS_WF2BM1 0x56 | ||
102 | #define KS_WF2BM2 0x58 | ||
103 | #define KS_WF2BM3 0x5A | ||
104 | |||
105 | #define KS_WF3CRC0 0x60 | ||
106 | #define KS_WF3CRC1 0x62 | ||
107 | #define KS_WF3BM0 0x64 | ||
108 | #define KS_WF3BM1 0x66 | ||
109 | #define KS_WF3BM2 0x68 | ||
110 | #define KS_WF3BM3 0x6A | ||
111 | |||
112 | #define KS_TXCR 0x70 | ||
113 | #define TXCR_TCGICMP (1 << 8) | ||
114 | #define TXCR_TCGUDP (1 << 7) | ||
115 | #define TXCR_TCGTCP (1 << 6) | ||
116 | #define TXCR_TCGIP (1 << 5) | ||
117 | #define TXCR_FTXQ (1 << 4) | ||
118 | #define TXCR_TXFCE (1 << 3) | ||
119 | #define TXCR_TXPE (1 << 2) | ||
120 | #define TXCR_TXCRC (1 << 1) | ||
121 | #define TXCR_TXE (1 << 0) | ||
122 | |||
123 | #define KS_TXSR 0x72 | ||
124 | #define TXSR_TXLC (1 << 13) | ||
125 | #define TXSR_TXMC (1 << 12) | ||
126 | #define TXSR_TXFID_MASK (0x3f << 0) | ||
127 | #define TXSR_TXFID_SHIFT (0) | ||
128 | #define TXSR_TXFID_GET(_v) (((_v) >> 0) & 0x3f) | ||
129 | |||
130 | |||
131 | #define KS_RXCR1 0x74 | ||
132 | #define RXCR1_FRXQ (1 << 15) | ||
133 | #define RXCR1_RXUDPFCC (1 << 14) | ||
134 | #define RXCR1_RXTCPFCC (1 << 13) | ||
135 | #define RXCR1_RXIPFCC (1 << 12) | ||
136 | #define RXCR1_RXPAFMA (1 << 11) | ||
137 | #define RXCR1_RXFCE (1 << 10) | ||
138 | #define RXCR1_RXEFE (1 << 9) | ||
139 | #define RXCR1_RXMAFMA (1 << 8) | ||
140 | #define RXCR1_RXBE (1 << 7) | ||
141 | #define RXCR1_RXME (1 << 6) | ||
142 | #define RXCR1_RXUE (1 << 5) | ||
143 | #define RXCR1_RXAE (1 << 4) | ||
144 | #define RXCR1_RXINVF (1 << 1) | ||
145 | #define RXCR1_RXE (1 << 0) | ||
146 | #define RXCR1_FILTER_MASK (RXCR1_RXINVF | RXCR1_RXAE | \ | ||
147 | RXCR1_RXMAFMA | RXCR1_RXPAFMA) | ||
148 | |||
149 | #define KS_RXCR2 0x76 | ||
150 | #define RXCR2_SRDBL_MASK (0x7 << 5) | ||
151 | #define RXCR2_SRDBL_SHIFT (5) | ||
152 | #define RXCR2_SRDBL_4B (0x0 << 5) | ||
153 | #define RXCR2_SRDBL_8B (0x1 << 5) | ||
154 | #define RXCR2_SRDBL_16B (0x2 << 5) | ||
155 | #define RXCR2_SRDBL_32B (0x3 << 5) | ||
156 | /* #define RXCR2_SRDBL_FRAME (0x4 << 5) */ | ||
157 | #define RXCR2_IUFFP (1 << 4) | ||
158 | #define RXCR2_RXIUFCEZ (1 << 3) | ||
159 | #define RXCR2_UDPLFE (1 << 2) | ||
160 | #define RXCR2_RXICMPFCC (1 << 1) | ||
161 | #define RXCR2_RXSAF (1 << 0) | ||
162 | |||
163 | #define KS_TXMIR 0x78 | ||
164 | |||
165 | #define KS_RXFHSR 0x7C | ||
166 | #define RXFSHR_RXFV (1 << 15) | ||
167 | #define RXFSHR_RXICMPFCS (1 << 13) | ||
168 | #define RXFSHR_RXIPFCS (1 << 12) | ||
169 | #define RXFSHR_RXTCPFCS (1 << 11) | ||
170 | #define RXFSHR_RXUDPFCS (1 << 10) | ||
171 | #define RXFSHR_RXBF (1 << 7) | ||
172 | #define RXFSHR_RXMF (1 << 6) | ||
173 | #define RXFSHR_RXUF (1 << 5) | ||
174 | #define RXFSHR_RXMR (1 << 4) | ||
175 | #define RXFSHR_RXFT (1 << 3) | ||
176 | #define RXFSHR_RXFTL (1 << 2) | ||
177 | #define RXFSHR_RXRF (1 << 1) | ||
178 | #define RXFSHR_RXCE (1 << 0) | ||
179 | #define RXFSHR_ERR (RXFSHR_RXCE | RXFSHR_RXRF |\ | ||
180 | RXFSHR_RXFTL | RXFSHR_RXMR |\ | ||
181 | RXFSHR_RXICMPFCS | RXFSHR_RXIPFCS |\ | ||
182 | RXFSHR_RXTCPFCS) | ||
183 | #define KS_RXFHBCR 0x7E | ||
184 | #define RXFHBCR_CNT_MASK 0x0FFF | ||
185 | |||
186 | #define KS_TXQCR 0x80 | ||
187 | #define TXQCR_AETFE (1 << 2) | ||
188 | #define TXQCR_TXQMAM (1 << 1) | ||
189 | #define TXQCR_METFE (1 << 0) | ||
190 | |||
191 | #define KS_RXQCR 0x82 | ||
192 | #define RXQCR_RXDTTS (1 << 12) | ||
193 | #define RXQCR_RXDBCTS (1 << 11) | ||
194 | #define RXQCR_RXFCTS (1 << 10) | ||
195 | #define RXQCR_RXIPHTOE (1 << 9) | ||
196 | #define RXQCR_RXDTTE (1 << 7) | ||
197 | #define RXQCR_RXDBCTE (1 << 6) | ||
198 | #define RXQCR_RXFCTE (1 << 5) | ||
199 | #define RXQCR_ADRFE (1 << 4) | ||
200 | #define RXQCR_SDA (1 << 3) | ||
201 | #define RXQCR_RRXEF (1 << 0) | ||
202 | #define RXQCR_CMD_CNTL (RXQCR_RXFCTE|RXQCR_ADRFE) | ||
203 | |||
204 | #define KS_TXFDPR 0x84 | ||
205 | #define TXFDPR_TXFPAI (1 << 14) | ||
206 | #define TXFDPR_TXFP_MASK (0x7ff << 0) | ||
207 | #define TXFDPR_TXFP_SHIFT (0) | ||
208 | |||
209 | #define KS_RXFDPR 0x86 | ||
210 | #define RXFDPR_RXFPAI (1 << 14) | ||
211 | |||
212 | #define KS_RXDTTR 0x8C | ||
213 | #define KS_RXDBCTR 0x8E | ||
214 | |||
215 | #define KS_IER 0x90 | ||
216 | #define KS_ISR 0x92 | ||
217 | #define IRQ_LCI (1 << 15) | ||
218 | #define IRQ_TXI (1 << 14) | ||
219 | #define IRQ_RXI (1 << 13) | ||
220 | #define IRQ_RXOI (1 << 11) | ||
221 | #define IRQ_TXPSI (1 << 9) | ||
222 | #define IRQ_RXPSI (1 << 8) | ||
223 | #define IRQ_TXSAI (1 << 6) | ||
224 | #define IRQ_RXWFDI (1 << 5) | ||
225 | #define IRQ_RXMPDI (1 << 4) | ||
226 | #define IRQ_LDI (1 << 3) | ||
227 | #define IRQ_EDI (1 << 2) | ||
228 | #define IRQ_SPIBEI (1 << 1) | ||
229 | #define IRQ_DEDI (1 << 0) | ||
230 | |||
231 | #define KS_RXFCTR 0x9C | ||
232 | #define RXFCTR_THRESHOLD_MASK 0x00FF | ||
233 | |||
234 | #define KS_RXFC 0x9D | ||
235 | #define RXFCTR_RXFC_MASK (0xff << 8) | ||
236 | #define RXFCTR_RXFC_SHIFT (8) | ||
237 | #define RXFCTR_RXFC_GET(_v) (((_v) >> 8) & 0xff) | ||
238 | #define RXFCTR_RXFCT_MASK (0xff << 0) | ||
239 | #define RXFCTR_RXFCT_SHIFT (0) | ||
240 | |||
241 | #define KS_TXNTFSR 0x9E | ||
242 | |||
243 | #define KS_MAHTR0 0xA0 | ||
244 | #define KS_MAHTR1 0xA2 | ||
245 | #define KS_MAHTR2 0xA4 | ||
246 | #define KS_MAHTR3 0xA6 | ||
247 | |||
248 | #define KS_FCLWR 0xB0 | ||
249 | #define KS_FCHWR 0xB2 | ||
250 | #define KS_FCOWR 0xB4 | ||
251 | |||
252 | #define KS_CIDER 0xC0 | ||
253 | #define CIDER_ID 0x8870 | ||
254 | #define CIDER_REV_MASK (0x7 << 1) | ||
255 | #define CIDER_REV_SHIFT (1) | ||
256 | #define CIDER_REV_GET(_v) (((_v) >> 1) & 0x7) | ||
257 | |||
258 | #define KS_CGCR 0xC6 | ||
259 | #define KS_IACR 0xC8 | ||
260 | #define IACR_RDEN (1 << 12) | ||
261 | #define IACR_TSEL_MASK (0x3 << 10) | ||
262 | #define IACR_TSEL_SHIFT (10) | ||
263 | #define IACR_TSEL_MIB (0x3 << 10) | ||
264 | #define IACR_ADDR_MASK (0x1f << 0) | ||
265 | #define IACR_ADDR_SHIFT (0) | ||
266 | |||
267 | #define KS_IADLR 0xD0 | ||
268 | #define KS_IAHDR 0xD2 | ||
269 | |||
270 | #define KS_PMECR 0xD4 | ||
271 | #define PMECR_PME_DELAY (1 << 14) | ||
272 | #define PMECR_PME_POL (1 << 12) | ||
273 | #define PMECR_WOL_WAKEUP (1 << 11) | ||
274 | #define PMECR_WOL_MAGICPKT (1 << 10) | ||
275 | #define PMECR_WOL_LINKUP (1 << 9) | ||
276 | #define PMECR_WOL_ENERGY (1 << 8) | ||
277 | #define PMECR_AUTO_WAKE_EN (1 << 7) | ||
278 | #define PMECR_WAKEUP_NORMAL (1 << 6) | ||
279 | #define PMECR_WKEVT_MASK (0xf << 2) | ||
280 | #define PMECR_WKEVT_SHIFT (2) | ||
281 | #define PMECR_WKEVT_GET(_v) (((_v) >> 2) & 0xf) | ||
282 | #define PMECR_WKEVT_ENERGY (0x1 << 2) | ||
283 | #define PMECR_WKEVT_LINK (0x2 << 2) | ||
284 | #define PMECR_WKEVT_MAGICPKT (0x4 << 2) | ||
285 | #define PMECR_WKEVT_FRAME (0x8 << 2) | ||
286 | #define PMECR_PM_MASK (0x3 << 0) | ||
287 | #define PMECR_PM_SHIFT (0) | ||
288 | #define PMECR_PM_NORMAL (0x0 << 0) | ||
289 | #define PMECR_PM_ENERGY (0x1 << 0) | ||
290 | #define PMECR_PM_SOFTDOWN (0x2 << 0) | ||
291 | #define PMECR_PM_POWERSAVE (0x3 << 0) | ||
292 | |||
293 | /* Standard MII PHY data */ | ||
294 | #define KS_P1MBCR 0xE4 | ||
295 | #define P1MBCR_FORCE_FDX (1 << 8) | ||
296 | |||
297 | #define KS_P1MBSR 0xE6 | ||
298 | #define P1MBSR_AN_COMPLETE (1 << 5) | ||
299 | #define P1MBSR_AN_CAPABLE (1 << 3) | ||
300 | #define P1MBSR_LINK_UP (1 << 2) | ||
301 | |||
302 | #define KS_PHY1ILR 0xE8 | ||
303 | #define KS_PHY1IHR 0xEA | ||
304 | #define KS_P1ANAR 0xEC | ||
305 | #define KS_P1ANLPR 0xEE | ||
306 | |||
307 | #define KS_P1SCLMD 0xF4 | ||
308 | #define P1SCLMD_LEDOFF (1 << 15) | ||
309 | #define P1SCLMD_TXIDS (1 << 14) | ||
310 | #define P1SCLMD_RESTARTAN (1 << 13) | ||
311 | #define P1SCLMD_DISAUTOMDIX (1 << 10) | ||
312 | #define P1SCLMD_FORCEMDIX (1 << 9) | ||
313 | #define P1SCLMD_AUTONEGEN (1 << 7) | ||
314 | #define P1SCLMD_FORCE100 (1 << 6) | ||
315 | #define P1SCLMD_FORCEFDX (1 << 5) | ||
316 | #define P1SCLMD_ADV_FLOW (1 << 4) | ||
317 | #define P1SCLMD_ADV_100BT_FDX (1 << 3) | ||
318 | #define P1SCLMD_ADV_100BT_HDX (1 << 2) | ||
319 | #define P1SCLMD_ADV_10BT_FDX (1 << 1) | ||
320 | #define P1SCLMD_ADV_10BT_HDX (1 << 0) | ||
321 | |||
322 | #define KS_P1CR 0xF6 | ||
323 | #define P1CR_HP_MDIX (1 << 15) | ||
324 | #define P1CR_REV_POL (1 << 13) | ||
325 | #define P1CR_OP_100M (1 << 10) | ||
326 | #define P1CR_OP_FDX (1 << 9) | ||
327 | #define P1CR_OP_MDI (1 << 7) | ||
328 | #define P1CR_AN_DONE (1 << 6) | ||
329 | #define P1CR_LINK_GOOD (1 << 5) | ||
330 | #define P1CR_PNTR_FLOW (1 << 4) | ||
331 | #define P1CR_PNTR_100BT_FDX (1 << 3) | ||
332 | #define P1CR_PNTR_100BT_HDX (1 << 2) | ||
333 | #define P1CR_PNTR_10BT_FDX (1 << 1) | ||
334 | #define P1CR_PNTR_10BT_HDX (1 << 0) | ||
335 | |||
336 | /* TX Frame control */ | ||
337 | |||
338 | #define TXFR_TXIC (1 << 15) | ||
339 | #define TXFR_TXFID_MASK (0x3f << 0) | ||
340 | #define TXFR_TXFID_SHIFT (0) | ||
341 | |||
342 | #define KS_P1SR 0xF8 | ||
343 | #define P1SR_HP_MDIX (1 << 15) | ||
344 | #define P1SR_REV_POL (1 << 13) | ||
345 | #define P1SR_OP_100M (1 << 10) | ||
346 | #define P1SR_OP_FDX (1 << 9) | ||
347 | #define P1SR_OP_MDI (1 << 7) | ||
348 | #define P1SR_AN_DONE (1 << 6) | ||
349 | #define P1SR_LINK_GOOD (1 << 5) | ||
350 | #define P1SR_PNTR_FLOW (1 << 4) | ||
351 | #define P1SR_PNTR_100BT_FDX (1 << 3) | ||
352 | #define P1SR_PNTR_100BT_HDX (1 << 2) | ||
353 | #define P1SR_PNTR_10BT_FDX (1 << 1) | ||
354 | #define P1SR_PNTR_10BT_HDX (1 << 0) | ||
355 | |||
356 | #define ENUM_BUS_NONE 0 | ||
357 | #define ENUM_BUS_8BIT 1 | ||
358 | #define ENUM_BUS_16BIT 2 | ||
359 | #define ENUM_BUS_32BIT 3 | ||
360 | |||
361 | #define MAX_MCAST_LST 32 | ||
362 | #define HW_MCAST_SIZE 8 | ||
363 | #define MAC_ADDR_LEN 6 | ||
364 | |||
365 | /** | ||
366 | * union ks_tx_hdr - tx header data | ||
367 | * @txb: The header as bytes | ||
368 | * @txw: The header as 16bit, little-endian words | ||
369 | * | ||
370 | * A dual representation of the tx header data to allow | ||
371 | * access to individual bytes, and to allow 16bit accesses | ||
372 | * with 16bit alignment. | ||
373 | */ | ||
374 | union ks_tx_hdr { | ||
375 | u8 txb[4]; | ||
376 | __le16 txw[2]; | ||
377 | }; | ||
378 | |||
379 | /** | ||
380 | * struct ks_net - KS8851 driver private data | ||
381 | * @net_device : The network device we're bound to | ||
382 | * @hw_addr : start address of data register. | ||
383 | * @hw_addr_cmd : start address of command register. | ||
384 | * @txh : temporaly buffer to save status/length. | ||
385 | * @lock : Lock to ensure that the device is not accessed when busy. | ||
386 | * @pdev : Pointer to platform device. | ||
387 | * @mii : The MII state information for the mii calls. | ||
388 | * @frame_head_info : frame header information for multi-pkt rx. | ||
389 | * @statelock : Lock on this structure for tx list. | ||
390 | * @msg_enable : The message flags controlling driver output (see ethtool). | ||
391 | * @frame_cnt : number of frames received. | ||
392 | * @bus_width : i/o bus width. | ||
393 | * @irq : irq number assigned to this device. | ||
394 | * @rc_rxqcr : Cached copy of KS_RXQCR. | ||
395 | * @rc_txcr : Cached copy of KS_TXCR. | ||
396 | * @rc_ier : Cached copy of KS_IER. | ||
397 | * @sharedbus : Multipex(addr and data bus) mode indicator. | ||
398 | * @cmd_reg_cache : command register cached. | ||
399 | * @cmd_reg_cache_int : command register cached. Used in the irq handler. | ||
400 | * @promiscuous : promiscuous mode indicator. | ||
401 | * @all_mcast : mutlicast indicator. | ||
402 | * @mcast_lst_size : size of multicast list. | ||
403 | * @mcast_lst : multicast list. | ||
404 | * @mcast_bits : multicast enabed. | ||
405 | * @mac_addr : MAC address assigned to this device. | ||
406 | * @fid : frame id. | ||
407 | * @extra_byte : number of extra byte prepended rx pkt. | ||
408 | * @enabled : indicator this device works. | ||
409 | * | ||
410 | * The @lock ensures that the chip is protected when certain operations are | ||
411 | * in progress. When the read or write packet transfer is in progress, most | ||
412 | * of the chip registers are not accessible until the transfer is finished and | ||
413 | * the DMA has been de-asserted. | ||
414 | * | ||
415 | * The @statelock is used to protect information in the structure which may | ||
416 | * need to be accessed via several sources, such as the network driver layer | ||
417 | * or one of the work queues. | ||
418 | * | ||
419 | */ | ||
420 | |||
421 | /* Receive multiplex framer header info */ | ||
422 | struct type_frame_head { | ||
423 | u16 sts; /* Frame status */ | ||
424 | u16 len; /* Byte count */ | ||
425 | }; | ||
426 | |||
427 | struct ks_net { | ||
428 | struct net_device *netdev; | ||
429 | void __iomem *hw_addr; | ||
430 | void __iomem *hw_addr_cmd; | ||
431 | union ks_tx_hdr txh ____cacheline_aligned; | ||
432 | struct mutex lock; /* spinlock to be interrupt safe */ | ||
433 | struct platform_device *pdev; | ||
434 | struct mii_if_info mii; | ||
435 | struct type_frame_head *frame_head_info; | ||
436 | spinlock_t statelock; | ||
437 | u32 msg_enable; | ||
438 | u32 frame_cnt; | ||
439 | int bus_width; | ||
440 | int irq; | ||
441 | |||
442 | u16 rc_rxqcr; | ||
443 | u16 rc_txcr; | ||
444 | u16 rc_ier; | ||
445 | u16 sharedbus; | ||
446 | u16 cmd_reg_cache; | ||
447 | u16 cmd_reg_cache_int; | ||
448 | u16 promiscuous; | ||
449 | u16 all_mcast; | ||
450 | u16 mcast_lst_size; | ||
451 | u8 mcast_lst[MAX_MCAST_LST][MAC_ADDR_LEN]; | ||
452 | u8 mcast_bits[HW_MCAST_SIZE]; | ||
453 | u8 mac_addr[6]; | ||
454 | u8 fid; | ||
455 | u8 extra_byte; | ||
456 | u8 enabled; | ||
457 | }; | ||
458 | |||
459 | static int msg_enable; | ||
460 | |||
461 | #define ks_info(_ks, _msg...) dev_info(&(_ks)->pdev->dev, _msg) | ||
462 | #define ks_warn(_ks, _msg...) dev_warn(&(_ks)->pdev->dev, _msg) | ||
463 | #define ks_dbg(_ks, _msg...) dev_dbg(&(_ks)->pdev->dev, _msg) | ||
464 | #define ks_err(_ks, _msg...) dev_err(&(_ks)->pdev->dev, _msg) | ||
465 | |||
466 | #define BE3 0x8000 /* Byte Enable 3 */ | ||
467 | #define BE2 0x4000 /* Byte Enable 2 */ | ||
468 | #define BE1 0x2000 /* Byte Enable 1 */ | ||
469 | #define BE0 0x1000 /* Byte Enable 0 */ | ||
470 | |||
471 | /** | ||
472 | * register read/write calls. | ||
473 | * | ||
474 | * All these calls issue transactions to access the chip's registers. They | ||
475 | * all require that the necessary lock is held to prevent accesses when the | ||
476 | * chip is busy transfering packet data (RX/TX FIFO accesses). | ||
477 | */ | ||
478 | |||
479 | /** | ||
480 | * ks_rdreg8 - read 8 bit register from device | ||
481 | * @ks : The chip information | ||
482 | * @offset: The register address | ||
483 | * | ||
484 | * Read a 8bit register from the chip, returning the result | ||
485 | */ | ||
486 | static u8 ks_rdreg8(struct ks_net *ks, int offset) | ||
487 | { | ||
488 | u16 data; | ||
489 | u8 shift_bit = offset & 0x03; | ||
490 | u8 shift_data = (offset & 1) << 3; | ||
491 | ks->cmd_reg_cache = (u16) offset | (u16)(BE0 << shift_bit); | ||
492 | iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd); | ||
493 | data = ioread16(ks->hw_addr); | ||
494 | return (u8)(data >> shift_data); | ||
495 | } | ||
496 | |||
497 | /** | ||
498 | * ks_rdreg16 - read 16 bit register from device | ||
499 | * @ks : The chip information | ||
500 | * @offset: The register address | ||
501 | * | ||
502 | * Read a 16bit register from the chip, returning the result | ||
503 | */ | ||
504 | |||
505 | static u16 ks_rdreg16(struct ks_net *ks, int offset) | ||
506 | { | ||
507 | ks->cmd_reg_cache = (u16)offset | ((BE1 | BE0) << (offset & 0x02)); | ||
508 | iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd); | ||
509 | return ioread16(ks->hw_addr); | ||
510 | } | ||
511 | |||
512 | /** | ||
513 | * ks_wrreg8 - write 8bit register value to chip | ||
514 | * @ks: The chip information | ||
515 | * @offset: The register address | ||
516 | * @value: The value to write | ||
517 | * | ||
518 | */ | ||
519 | static void ks_wrreg8(struct ks_net *ks, int offset, u8 value) | ||
520 | { | ||
521 | u8 shift_bit = (offset & 0x03); | ||
522 | u16 value_write = (u16)(value << ((offset & 1) << 3)); | ||
523 | ks->cmd_reg_cache = (u16)offset | (BE0 << shift_bit); | ||
524 | iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd); | ||
525 | iowrite16(value_write, ks->hw_addr); | ||
526 | } | ||
527 | |||
528 | /** | ||
529 | * ks_wrreg16 - write 16bit register value to chip | ||
530 | * @ks: The chip information | ||
531 | * @offset: The register address | ||
532 | * @value: The value to write | ||
533 | * | ||
534 | */ | ||
535 | |||
536 | static void ks_wrreg16(struct ks_net *ks, int offset, u16 value) | ||
537 | { | ||
538 | ks->cmd_reg_cache = (u16)offset | ((BE1 | BE0) << (offset & 0x02)); | ||
539 | iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd); | ||
540 | iowrite16(value, ks->hw_addr); | ||
541 | } | ||
542 | |||
543 | /** | ||
544 | * ks_inblk - read a block of data from QMU. This is called after sudo DMA mode enabled. | ||
545 | * @ks: The chip state | ||
546 | * @wptr: buffer address to save data | ||
547 | * @len: length in byte to read | ||
548 | * | ||
549 | */ | ||
550 | static inline void ks_inblk(struct ks_net *ks, u16 *wptr, u32 len) | ||
551 | { | ||
552 | len >>= 1; | ||
553 | while (len--) | ||
554 | *wptr++ = (u16)ioread16(ks->hw_addr); | ||
555 | } | ||
556 | |||
557 | /** | ||
558 | * ks_outblk - write data to QMU. This is called after sudo DMA mode enabled. | ||
559 | * @ks: The chip information | ||
560 | * @wptr: buffer address | ||
561 | * @len: length in byte to write | ||
562 | * | ||
563 | */ | ||
564 | static inline void ks_outblk(struct ks_net *ks, u16 *wptr, u32 len) | ||
565 | { | ||
566 | len >>= 1; | ||
567 | while (len--) | ||
568 | iowrite16(*wptr++, ks->hw_addr); | ||
569 | } | ||
570 | |||
571 | /** | ||
572 | * ks_tx_fifo_space - return the available hardware buffer size. | ||
573 | * @ks: The chip information | ||
574 | * | ||
575 | */ | ||
576 | static inline u16 ks_tx_fifo_space(struct ks_net *ks) | ||
577 | { | ||
578 | return ks_rdreg16(ks, KS_TXMIR) & 0x1fff; | ||
579 | } | ||
580 | |||
581 | /** | ||
582 | * ks_save_cmd_reg - save the command register from the cache. | ||
583 | * @ks: The chip information | ||
584 | * | ||
585 | */ | ||
586 | static inline void ks_save_cmd_reg(struct ks_net *ks) | ||
587 | { | ||
588 | /*ks8851 MLL has a bug to read back the command register. | ||
589 | * So rely on software to save the content of command register. | ||
590 | */ | ||
591 | ks->cmd_reg_cache_int = ks->cmd_reg_cache; | ||
592 | } | ||
593 | |||
594 | /** | ||
595 | * ks_restore_cmd_reg - restore the command register from the cache and | ||
596 | * write to hardware register. | ||
597 | * @ks: The chip information | ||
598 | * | ||
599 | */ | ||
600 | static inline void ks_restore_cmd_reg(struct ks_net *ks) | ||
601 | { | ||
602 | ks->cmd_reg_cache = ks->cmd_reg_cache_int; | ||
603 | iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd); | ||
604 | } | ||
605 | |||
606 | /** | ||
607 | * ks_set_powermode - set power mode of the device | ||
608 | * @ks: The chip information | ||
609 | * @pwrmode: The power mode value to write to KS_PMECR. | ||
610 | * | ||
611 | * Change the power mode of the chip. | ||
612 | */ | ||
613 | static void ks_set_powermode(struct ks_net *ks, unsigned pwrmode) | ||
614 | { | ||
615 | unsigned pmecr; | ||
616 | |||
617 | if (netif_msg_hw(ks)) | ||
618 | ks_dbg(ks, "setting power mode %d\n", pwrmode); | ||
619 | |||
620 | ks_rdreg16(ks, KS_GRR); | ||
621 | pmecr = ks_rdreg16(ks, KS_PMECR); | ||
622 | pmecr &= ~PMECR_PM_MASK; | ||
623 | pmecr |= pwrmode; | ||
624 | |||
625 | ks_wrreg16(ks, KS_PMECR, pmecr); | ||
626 | } | ||
627 | |||
628 | /** | ||
629 | * ks_read_config - read chip configuration of bus width. | ||
630 | * @ks: The chip information | ||
631 | * | ||
632 | */ | ||
633 | static void ks_read_config(struct ks_net *ks) | ||
634 | { | ||
635 | u16 reg_data = 0; | ||
636 | |||
637 | /* Regardless of bus width, 8 bit read should always work.*/ | ||
638 | reg_data = ks_rdreg8(ks, KS_CCR) & 0x00FF; | ||
639 | reg_data |= ks_rdreg8(ks, KS_CCR+1) << 8; | ||
640 | |||
641 | /* addr/data bus are multiplexed */ | ||
642 | ks->sharedbus = (reg_data & CCR_SHARED) == CCR_SHARED; | ||
643 | |||
644 | /* There are garbage data when reading data from QMU, | ||
645 | depending on bus-width. | ||
646 | */ | ||
647 | |||
648 | if (reg_data & CCR_8BIT) { | ||
649 | ks->bus_width = ENUM_BUS_8BIT; | ||
650 | ks->extra_byte = 1; | ||
651 | } else if (reg_data & CCR_16BIT) { | ||
652 | ks->bus_width = ENUM_BUS_16BIT; | ||
653 | ks->extra_byte = 2; | ||
654 | } else { | ||
655 | ks->bus_width = ENUM_BUS_32BIT; | ||
656 | ks->extra_byte = 4; | ||
657 | } | ||
658 | } | ||
659 | |||
660 | /** | ||
661 | * ks_soft_reset - issue one of the soft reset to the device | ||
662 | * @ks: The device state. | ||
663 | * @op: The bit(s) to set in the GRR | ||
664 | * | ||
665 | * Issue the relevant soft-reset command to the device's GRR register | ||
666 | * specified by @op. | ||
667 | * | ||
668 | * Note, the delays are in there as a caution to ensure that the reset | ||
669 | * has time to take effect and then complete. Since the datasheet does | ||
670 | * not currently specify the exact sequence, we have chosen something | ||
671 | * that seems to work with our device. | ||
672 | */ | ||
673 | static void ks_soft_reset(struct ks_net *ks, unsigned op) | ||
674 | { | ||
675 | /* Disable interrupt first */ | ||
676 | ks_wrreg16(ks, KS_IER, 0x0000); | ||
677 | ks_wrreg16(ks, KS_GRR, op); | ||
678 | mdelay(10); /* wait a short time to effect reset */ | ||
679 | ks_wrreg16(ks, KS_GRR, 0); | ||
680 | mdelay(1); /* wait for condition to clear */ | ||
681 | } | ||
682 | |||
683 | |||
684 | /** | ||
685 | * ks_read_qmu - read 1 pkt data from the QMU. | ||
686 | * @ks: The chip information | ||
687 | * @buf: buffer address to save 1 pkt | ||
688 | * @len: Pkt length | ||
689 | * Here is the sequence to read 1 pkt: | ||
690 | * 1. set sudo DMA mode | ||
691 | * 2. read prepend data | ||
692 | * 3. read pkt data | ||
693 | * 4. reset sudo DMA Mode | ||
694 | */ | ||
695 | static inline void ks_read_qmu(struct ks_net *ks, u16 *buf, u32 len) | ||
696 | { | ||
697 | u32 r = ks->extra_byte & 0x1 ; | ||
698 | u32 w = ks->extra_byte - r; | ||
699 | |||
700 | /* 1. set sudo DMA mode */ | ||
701 | ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI); | ||
702 | ks_wrreg8(ks, KS_RXQCR, (ks->rc_rxqcr | RXQCR_SDA) & 0xff); | ||
703 | |||
704 | /* 2. read prepend data */ | ||
705 | /** | ||
706 | * read 4 + extra bytes and discard them. | ||
707 | * extra bytes for dummy, 2 for status, 2 for len | ||
708 | */ | ||
709 | |||
710 | /* use likely(r) for 8 bit access for performance */ | ||
711 | if (unlikely(r)) | ||
712 | ioread8(ks->hw_addr); | ||
713 | ks_inblk(ks, buf, w + 2 + 2); | ||
714 | |||
715 | /* 3. read pkt data */ | ||
716 | ks_inblk(ks, buf, ALIGN(len, 4)); | ||
717 | |||
718 | /* 4. reset sudo DMA Mode */ | ||
719 | ks_wrreg8(ks, KS_RXQCR, ks->rc_rxqcr); | ||
720 | } | ||
721 | |||
722 | /** | ||
723 | * ks_rcv - read multiple pkts data from the QMU. | ||
724 | * @ks: The chip information | ||
725 | * @netdev: The network device being opened. | ||
726 | * | ||
727 | * Read all of header information before reading pkt content. | ||
728 | * It is not allowed only port of pkts in QMU after issuing | ||
729 | * interrupt ack. | ||
730 | */ | ||
731 | static void ks_rcv(struct ks_net *ks, struct net_device *netdev) | ||
732 | { | ||
733 | u32 i; | ||
734 | struct type_frame_head *frame_hdr = ks->frame_head_info; | ||
735 | struct sk_buff *skb; | ||
736 | |||
737 | ks->frame_cnt = ks_rdreg16(ks, KS_RXFCTR) >> 8; | ||
738 | |||
739 | /* read all header information */ | ||
740 | for (i = 0; i < ks->frame_cnt; i++) { | ||
741 | /* Checking Received packet status */ | ||
742 | frame_hdr->sts = ks_rdreg16(ks, KS_RXFHSR); | ||
743 | /* Get packet len from hardware */ | ||
744 | frame_hdr->len = ks_rdreg16(ks, KS_RXFHBCR); | ||
745 | frame_hdr++; | ||
746 | } | ||
747 | |||
748 | frame_hdr = ks->frame_head_info; | ||
749 | while (ks->frame_cnt--) { | ||
750 | skb = dev_alloc_skb(frame_hdr->len + 16); | ||
751 | if (likely(skb && (frame_hdr->sts & RXFSHR_RXFV) && | ||
752 | (frame_hdr->len < RX_BUF_SIZE) && frame_hdr->len)) { | ||
753 | skb_reserve(skb, 2); | ||
754 | /* read data block including CRC 4 bytes */ | ||
755 | ks_read_qmu(ks, (u16 *)skb->data, frame_hdr->len + 4); | ||
756 | skb_put(skb, frame_hdr->len); | ||
757 | skb->dev = netdev; | ||
758 | skb->protocol = eth_type_trans(skb, netdev); | ||
759 | netif_rx(skb); | ||
760 | } else { | ||
761 | printk(KERN_ERR "%s: err:skb alloc\n", __func__); | ||
762 | ks_wrreg16(ks, KS_RXQCR, (ks->rc_rxqcr | RXQCR_RRXEF)); | ||
763 | if (skb) | ||
764 | dev_kfree_skb_irq(skb); | ||
765 | } | ||
766 | frame_hdr++; | ||
767 | } | ||
768 | } | ||
769 | |||
770 | /** | ||
771 | * ks_update_link_status - link status update. | ||
772 | * @netdev: The network device being opened. | ||
773 | * @ks: The chip information | ||
774 | * | ||
775 | */ | ||
776 | |||
777 | static void ks_update_link_status(struct net_device *netdev, struct ks_net *ks) | ||
778 | { | ||
779 | /* check the status of the link */ | ||
780 | u32 link_up_status; | ||
781 | if (ks_rdreg16(ks, KS_P1SR) & P1SR_LINK_GOOD) { | ||
782 | netif_carrier_on(netdev); | ||
783 | link_up_status = true; | ||
784 | } else { | ||
785 | netif_carrier_off(netdev); | ||
786 | link_up_status = false; | ||
787 | } | ||
788 | if (netif_msg_link(ks)) | ||
789 | ks_dbg(ks, "%s: %s\n", | ||
790 | __func__, link_up_status ? "UP" : "DOWN"); | ||
791 | } | ||
792 | |||
793 | /** | ||
794 | * ks_irq - device interrupt handler | ||
795 | * @irq: Interrupt number passed from the IRQ hnalder. | ||
796 | * @pw: The private word passed to register_irq(), our struct ks_net. | ||
797 | * | ||
798 | * This is the handler invoked to find out what happened | ||
799 | * | ||
800 | * Read the interrupt status, work out what needs to be done and then clear | ||
801 | * any of the interrupts that are not needed. | ||
802 | */ | ||
803 | |||
804 | static irqreturn_t ks_irq(int irq, void *pw) | ||
805 | { | ||
806 | struct ks_net *ks = pw; | ||
807 | struct net_device *netdev = ks->netdev; | ||
808 | u16 status; | ||
809 | |||
810 | /*this should be the first in IRQ handler */ | ||
811 | ks_save_cmd_reg(ks); | ||
812 | |||
813 | status = ks_rdreg16(ks, KS_ISR); | ||
814 | if (unlikely(!status)) { | ||
815 | ks_restore_cmd_reg(ks); | ||
816 | return IRQ_NONE; | ||
817 | } | ||
818 | |||
819 | ks_wrreg16(ks, KS_ISR, status); | ||
820 | |||
821 | if (likely(status & IRQ_RXI)) | ||
822 | ks_rcv(ks, netdev); | ||
823 | |||
824 | if (unlikely(status & IRQ_LCI)) | ||
825 | ks_update_link_status(netdev, ks); | ||
826 | |||
827 | if (unlikely(status & IRQ_TXI)) | ||
828 | netif_wake_queue(netdev); | ||
829 | |||
830 | if (unlikely(status & IRQ_LDI)) { | ||
831 | |||
832 | u16 pmecr = ks_rdreg16(ks, KS_PMECR); | ||
833 | pmecr &= ~PMECR_WKEVT_MASK; | ||
834 | ks_wrreg16(ks, KS_PMECR, pmecr | PMECR_WKEVT_LINK); | ||
835 | } | ||
836 | |||
837 | /* this should be the last in IRQ handler*/ | ||
838 | ks_restore_cmd_reg(ks); | ||
839 | return IRQ_HANDLED; | ||
840 | } | ||
841 | |||
842 | |||
843 | /** | ||
844 | * ks_net_open - open network device | ||
845 | * @netdev: The network device being opened. | ||
846 | * | ||
847 | * Called when the network device is marked active, such as a user executing | ||
848 | * 'ifconfig up' on the device. | ||
849 | */ | ||
850 | static int ks_net_open(struct net_device *netdev) | ||
851 | { | ||
852 | struct ks_net *ks = netdev_priv(netdev); | ||
853 | int err; | ||
854 | |||
855 | #define KS_INT_FLAGS (IRQF_DISABLED|IRQF_TRIGGER_LOW) | ||
856 | /* lock the card, even if we may not actually do anything | ||
857 | * else at the moment. | ||
858 | */ | ||
859 | |||
860 | if (netif_msg_ifup(ks)) | ||
861 | ks_dbg(ks, "%s - entry\n", __func__); | ||
862 | |||
863 | /* reset the HW */ | ||
864 | err = request_irq(ks->irq, ks_irq, KS_INT_FLAGS, DRV_NAME, ks); | ||
865 | |||
866 | if (err) { | ||
867 | printk(KERN_ERR "Failed to request IRQ: %d: %d\n", | ||
868 | ks->irq, err); | ||
869 | return err; | ||
870 | } | ||
871 | |||
872 | if (netif_msg_ifup(ks)) | ||
873 | ks_dbg(ks, "network device %s up\n", netdev->name); | ||
874 | |||
875 | return 0; | ||
876 | } | ||
877 | |||
878 | /** | ||
879 | * ks_net_stop - close network device | ||
880 | * @netdev: The device being closed. | ||
881 | * | ||
882 | * Called to close down a network device which has been active. Cancell any | ||
883 | * work, shutdown the RX and TX process and then place the chip into a low | ||
884 | * power state whilst it is not being used. | ||
885 | */ | ||
886 | static int ks_net_stop(struct net_device *netdev) | ||
887 | { | ||
888 | struct ks_net *ks = netdev_priv(netdev); | ||
889 | |||
890 | if (netif_msg_ifdown(ks)) | ||
891 | ks_info(ks, "%s: shutting down\n", netdev->name); | ||
892 | |||
893 | netif_stop_queue(netdev); | ||
894 | |||
895 | kfree(ks->frame_head_info); | ||
896 | |||
897 | mutex_lock(&ks->lock); | ||
898 | |||
899 | /* turn off the IRQs and ack any outstanding */ | ||
900 | ks_wrreg16(ks, KS_IER, 0x0000); | ||
901 | ks_wrreg16(ks, KS_ISR, 0xffff); | ||
902 | |||
903 | /* shutdown RX process */ | ||
904 | ks_wrreg16(ks, KS_RXCR1, 0x0000); | ||
905 | |||
906 | /* shutdown TX process */ | ||
907 | ks_wrreg16(ks, KS_TXCR, 0x0000); | ||
908 | |||
909 | /* set powermode to soft power down to save power */ | ||
910 | ks_set_powermode(ks, PMECR_PM_SOFTDOWN); | ||
911 | free_irq(ks->irq, netdev); | ||
912 | mutex_unlock(&ks->lock); | ||
913 | return 0; | ||
914 | } | ||
915 | |||
916 | |||
917 | /** | ||
918 | * ks_write_qmu - write 1 pkt data to the QMU. | ||
919 | * @ks: The chip information | ||
920 | * @pdata: buffer address to save 1 pkt | ||
921 | * @len: Pkt length in byte | ||
922 | * Here is the sequence to write 1 pkt: | ||
923 | * 1. set sudo DMA mode | ||
924 | * 2. write status/length | ||
925 | * 3. write pkt data | ||
926 | * 4. reset sudo DMA Mode | ||
927 | * 5. reset sudo DMA mode | ||
928 | * 6. Wait until pkt is out | ||
929 | */ | ||
930 | static void ks_write_qmu(struct ks_net *ks, u8 *pdata, u16 len) | ||
931 | { | ||
932 | unsigned fid = ks->fid; | ||
933 | |||
934 | fid = ks->fid; | ||
935 | ks->fid = (ks->fid + 1) & TXFR_TXFID_MASK; | ||
936 | |||
937 | /* reduce the tx interrupt occurrances. */ | ||
938 | if (!fid) | ||
939 | fid |= TXFR_TXIC; /* irq on completion */ | ||
940 | |||
941 | /* start header at txb[0] to align txw entries */ | ||
942 | ks->txh.txw[0] = cpu_to_le16(fid); | ||
943 | ks->txh.txw[1] = cpu_to_le16(len); | ||
944 | |||
945 | /* 1. set sudo-DMA mode */ | ||
946 | ks_wrreg8(ks, KS_RXQCR, (ks->rc_rxqcr | RXQCR_SDA) & 0xff); | ||
947 | /* 2. write status/lenth info */ | ||
948 | ks_outblk(ks, ks->txh.txw, 4); | ||
949 | /* 3. write pkt data */ | ||
950 | ks_outblk(ks, (u16 *)pdata, ALIGN(len, 4)); | ||
951 | /* 4. reset sudo-DMA mode */ | ||
952 | ks_wrreg8(ks, KS_RXQCR, ks->rc_rxqcr); | ||
953 | /* 5. Enqueue Tx(move the pkt from TX buffer into TXQ) */ | ||
954 | ks_wrreg16(ks, KS_TXQCR, TXQCR_METFE); | ||
955 | /* 6. wait until TXQCR_METFE is auto-cleared */ | ||
956 | while (ks_rdreg16(ks, KS_TXQCR) & TXQCR_METFE) | ||
957 | ; | ||
958 | } | ||
959 | |||
960 | static void ks_disable_int(struct ks_net *ks) | ||
961 | { | ||
962 | ks_wrreg16(ks, KS_IER, 0x0000); | ||
963 | } /* ks_disable_int */ | ||
964 | |||
965 | static void ks_enable_int(struct ks_net *ks) | ||
966 | { | ||
967 | ks_wrreg16(ks, KS_IER, ks->rc_ier); | ||
968 | } /* ks_enable_int */ | ||
969 | |||
970 | /** | ||
971 | * ks_start_xmit - transmit packet | ||
972 | * @skb : The buffer to transmit | ||
973 | * @netdev : The device used to transmit the packet. | ||
974 | * | ||
975 | * Called by the network layer to transmit the @skb. | ||
976 | * spin_lock_irqsave is required because tx and rx should be mutual exclusive. | ||
977 | * So while tx is in-progress, prevent IRQ interrupt from happenning. | ||
978 | */ | ||
979 | static int ks_start_xmit(struct sk_buff *skb, struct net_device *netdev) | ||
980 | { | ||
981 | int retv = NETDEV_TX_OK; | ||
982 | struct ks_net *ks = netdev_priv(netdev); | ||
983 | |||
984 | disable_irq(netdev->irq); | ||
985 | ks_disable_int(ks); | ||
986 | spin_lock(&ks->statelock); | ||
987 | |||
988 | /* Extra space are required: | ||
989 | * 4 byte for alignment, 4 for status/length, 4 for CRC | ||
990 | */ | ||
991 | |||
992 | if (likely(ks_tx_fifo_space(ks) >= skb->len + 12)) { | ||
993 | ks_write_qmu(ks, skb->data, skb->len); | ||
994 | dev_kfree_skb(skb); | ||
995 | } else | ||
996 | retv = NETDEV_TX_BUSY; | ||
997 | spin_unlock(&ks->statelock); | ||
998 | ks_enable_int(ks); | ||
999 | enable_irq(netdev->irq); | ||
1000 | return retv; | ||
1001 | } | ||
1002 | |||
1003 | /** | ||
1004 | * ks_start_rx - ready to serve pkts | ||
1005 | * @ks : The chip information | ||
1006 | * | ||
1007 | */ | ||
1008 | static void ks_start_rx(struct ks_net *ks) | ||
1009 | { | ||
1010 | u16 cntl; | ||
1011 | |||
1012 | /* Enables QMU Receive (RXCR1). */ | ||
1013 | cntl = ks_rdreg16(ks, KS_RXCR1); | ||
1014 | cntl |= RXCR1_RXE ; | ||
1015 | ks_wrreg16(ks, KS_RXCR1, cntl); | ||
1016 | } /* ks_start_rx */ | ||
1017 | |||
1018 | /** | ||
1019 | * ks_stop_rx - stop to serve pkts | ||
1020 | * @ks : The chip information | ||
1021 | * | ||
1022 | */ | ||
1023 | static void ks_stop_rx(struct ks_net *ks) | ||
1024 | { | ||
1025 | u16 cntl; | ||
1026 | |||
1027 | /* Disables QMU Receive (RXCR1). */ | ||
1028 | cntl = ks_rdreg16(ks, KS_RXCR1); | ||
1029 | cntl &= ~RXCR1_RXE ; | ||
1030 | ks_wrreg16(ks, KS_RXCR1, cntl); | ||
1031 | |||
1032 | } /* ks_stop_rx */ | ||
1033 | |||
1034 | static unsigned long const ethernet_polynomial = 0x04c11db7U; | ||
1035 | |||
1036 | static unsigned long ether_gen_crc(int length, u8 *data) | ||
1037 | { | ||
1038 | long crc = -1; | ||
1039 | while (--length >= 0) { | ||
1040 | u8 current_octet = *data++; | ||
1041 | int bit; | ||
1042 | |||
1043 | for (bit = 0; bit < 8; bit++, current_octet >>= 1) { | ||
1044 | crc = (crc << 1) ^ | ||
1045 | ((crc < 0) ^ (current_octet & 1) ? | ||
1046 | ethernet_polynomial : 0); | ||
1047 | } | ||
1048 | } | ||
1049 | return (unsigned long)crc; | ||
1050 | } /* ether_gen_crc */ | ||
1051 | |||
1052 | /** | ||
1053 | * ks_set_grpaddr - set multicast information | ||
1054 | * @ks : The chip information | ||
1055 | */ | ||
1056 | |||
1057 | static void ks_set_grpaddr(struct ks_net *ks) | ||
1058 | { | ||
1059 | u8 i; | ||
1060 | u32 index, position, value; | ||
1061 | |||
1062 | memset(ks->mcast_bits, 0, sizeof(u8) * HW_MCAST_SIZE); | ||
1063 | |||
1064 | for (i = 0; i < ks->mcast_lst_size; i++) { | ||
1065 | position = (ether_gen_crc(6, ks->mcast_lst[i]) >> 26) & 0x3f; | ||
1066 | index = position >> 3; | ||
1067 | value = 1 << (position & 7); | ||
1068 | ks->mcast_bits[index] |= (u8)value; | ||
1069 | } | ||
1070 | |||
1071 | for (i = 0; i < HW_MCAST_SIZE; i++) { | ||
1072 | if (i & 1) { | ||
1073 | ks_wrreg16(ks, (u16)((KS_MAHTR0 + i) & ~1), | ||
1074 | (ks->mcast_bits[i] << 8) | | ||
1075 | ks->mcast_bits[i - 1]); | ||
1076 | } | ||
1077 | } | ||
1078 | } /* ks_set_grpaddr */ | ||
1079 | |||
1080 | /* | ||
1081 | * ks_clear_mcast - clear multicast information | ||
1082 | * | ||
1083 | * @ks : The chip information | ||
1084 | * This routine removes all mcast addresses set in the hardware. | ||
1085 | */ | ||
1086 | |||
1087 | static void ks_clear_mcast(struct ks_net *ks) | ||
1088 | { | ||
1089 | u16 i, mcast_size; | ||
1090 | for (i = 0; i < HW_MCAST_SIZE; i++) | ||
1091 | ks->mcast_bits[i] = 0; | ||
1092 | |||
1093 | mcast_size = HW_MCAST_SIZE >> 2; | ||
1094 | for (i = 0; i < mcast_size; i++) | ||
1095 | ks_wrreg16(ks, KS_MAHTR0 + (2*i), 0); | ||
1096 | } | ||
1097 | |||
1098 | static void ks_set_promis(struct ks_net *ks, u16 promiscuous_mode) | ||
1099 | { | ||
1100 | u16 cntl; | ||
1101 | ks->promiscuous = promiscuous_mode; | ||
1102 | ks_stop_rx(ks); /* Stop receiving for reconfiguration */ | ||
1103 | cntl = ks_rdreg16(ks, KS_RXCR1); | ||
1104 | |||
1105 | cntl &= ~RXCR1_FILTER_MASK; | ||
1106 | if (promiscuous_mode) | ||
1107 | /* Enable Promiscuous mode */ | ||
1108 | cntl |= RXCR1_RXAE | RXCR1_RXINVF; | ||
1109 | else | ||
1110 | /* Disable Promiscuous mode (default normal mode) */ | ||
1111 | cntl |= RXCR1_RXPAFMA; | ||
1112 | |||
1113 | ks_wrreg16(ks, KS_RXCR1, cntl); | ||
1114 | |||
1115 | if (ks->enabled) | ||
1116 | ks_start_rx(ks); | ||
1117 | |||
1118 | } /* ks_set_promis */ | ||
1119 | |||
1120 | static void ks_set_mcast(struct ks_net *ks, u16 mcast) | ||
1121 | { | ||
1122 | u16 cntl; | ||
1123 | |||
1124 | ks->all_mcast = mcast; | ||
1125 | ks_stop_rx(ks); /* Stop receiving for reconfiguration */ | ||
1126 | cntl = ks_rdreg16(ks, KS_RXCR1); | ||
1127 | cntl &= ~RXCR1_FILTER_MASK; | ||
1128 | if (mcast) | ||
1129 | /* Enable "Perfect with Multicast address passed mode" */ | ||
1130 | cntl |= (RXCR1_RXAE | RXCR1_RXMAFMA | RXCR1_RXPAFMA); | ||
1131 | else | ||
1132 | /** | ||
1133 | * Disable "Perfect with Multicast address passed | ||
1134 | * mode" (normal mode). | ||
1135 | */ | ||
1136 | cntl |= RXCR1_RXPAFMA; | ||
1137 | |||
1138 | ks_wrreg16(ks, KS_RXCR1, cntl); | ||
1139 | |||
1140 | if (ks->enabled) | ||
1141 | ks_start_rx(ks); | ||
1142 | } /* ks_set_mcast */ | ||
1143 | |||
1144 | static void ks_set_rx_mode(struct net_device *netdev) | ||
1145 | { | ||
1146 | struct ks_net *ks = netdev_priv(netdev); | ||
1147 | struct dev_mc_list *ptr; | ||
1148 | |||
1149 | /* Turn on/off promiscuous mode. */ | ||
1150 | if ((netdev->flags & IFF_PROMISC) == IFF_PROMISC) | ||
1151 | ks_set_promis(ks, | ||
1152 | (u16)((netdev->flags & IFF_PROMISC) == IFF_PROMISC)); | ||
1153 | /* Turn on/off all mcast mode. */ | ||
1154 | else if ((netdev->flags & IFF_ALLMULTI) == IFF_ALLMULTI) | ||
1155 | ks_set_mcast(ks, | ||
1156 | (u16)((netdev->flags & IFF_ALLMULTI) == IFF_ALLMULTI)); | ||
1157 | else | ||
1158 | ks_set_promis(ks, false); | ||
1159 | |||
1160 | if ((netdev->flags & IFF_MULTICAST) && netdev->mc_count) { | ||
1161 | if (netdev->mc_count <= MAX_MCAST_LST) { | ||
1162 | int i = 0; | ||
1163 | for (ptr = netdev->mc_list; ptr; ptr = ptr->next) { | ||
1164 | if (!(*ptr->dmi_addr & 1)) | ||
1165 | continue; | ||
1166 | if (i >= MAX_MCAST_LST) | ||
1167 | break; | ||
1168 | memcpy(ks->mcast_lst[i++], ptr->dmi_addr, | ||
1169 | MAC_ADDR_LEN); | ||
1170 | } | ||
1171 | ks->mcast_lst_size = (u8)i; | ||
1172 | ks_set_grpaddr(ks); | ||
1173 | } else { | ||
1174 | /** | ||
1175 | * List too big to support so | ||
1176 | * turn on all mcast mode. | ||
1177 | */ | ||
1178 | ks->mcast_lst_size = MAX_MCAST_LST; | ||
1179 | ks_set_mcast(ks, true); | ||
1180 | } | ||
1181 | } else { | ||
1182 | ks->mcast_lst_size = 0; | ||
1183 | ks_clear_mcast(ks); | ||
1184 | } | ||
1185 | } /* ks_set_rx_mode */ | ||
1186 | |||
1187 | static void ks_set_mac(struct ks_net *ks, u8 *data) | ||
1188 | { | ||
1189 | u16 *pw = (u16 *)data; | ||
1190 | u16 w, u; | ||
1191 | |||
1192 | ks_stop_rx(ks); /* Stop receiving for reconfiguration */ | ||
1193 | |||
1194 | u = *pw++; | ||
1195 | w = ((u & 0xFF) << 8) | ((u >> 8) & 0xFF); | ||
1196 | ks_wrreg16(ks, KS_MARH, w); | ||
1197 | |||
1198 | u = *pw++; | ||
1199 | w = ((u & 0xFF) << 8) | ((u >> 8) & 0xFF); | ||
1200 | ks_wrreg16(ks, KS_MARM, w); | ||
1201 | |||
1202 | u = *pw; | ||
1203 | w = ((u & 0xFF) << 8) | ((u >> 8) & 0xFF); | ||
1204 | ks_wrreg16(ks, KS_MARL, w); | ||
1205 | |||
1206 | memcpy(ks->mac_addr, data, 6); | ||
1207 | |||
1208 | if (ks->enabled) | ||
1209 | ks_start_rx(ks); | ||
1210 | } | ||
1211 | |||
1212 | static int ks_set_mac_address(struct net_device *netdev, void *paddr) | ||
1213 | { | ||
1214 | struct ks_net *ks = netdev_priv(netdev); | ||
1215 | struct sockaddr *addr = paddr; | ||
1216 | u8 *da; | ||
1217 | |||
1218 | memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); | ||
1219 | |||
1220 | da = (u8 *)netdev->dev_addr; | ||
1221 | |||
1222 | ks_set_mac(ks, da); | ||
1223 | return 0; | ||
1224 | } | ||
1225 | |||
1226 | static int ks_net_ioctl(struct net_device *netdev, struct ifreq *req, int cmd) | ||
1227 | { | ||
1228 | struct ks_net *ks = netdev_priv(netdev); | ||
1229 | |||
1230 | if (!netif_running(netdev)) | ||
1231 | return -EINVAL; | ||
1232 | |||
1233 | return generic_mii_ioctl(&ks->mii, if_mii(req), cmd, NULL); | ||
1234 | } | ||
1235 | |||
1236 | static const struct net_device_ops ks_netdev_ops = { | ||
1237 | .ndo_open = ks_net_open, | ||
1238 | .ndo_stop = ks_net_stop, | ||
1239 | .ndo_do_ioctl = ks_net_ioctl, | ||
1240 | .ndo_start_xmit = ks_start_xmit, | ||
1241 | .ndo_set_mac_address = ks_set_mac_address, | ||
1242 | .ndo_set_rx_mode = ks_set_rx_mode, | ||
1243 | .ndo_change_mtu = eth_change_mtu, | ||
1244 | .ndo_validate_addr = eth_validate_addr, | ||
1245 | }; | ||
1246 | |||
1247 | /* ethtool support */ | ||
1248 | |||
1249 | static void ks_get_drvinfo(struct net_device *netdev, | ||
1250 | struct ethtool_drvinfo *di) | ||
1251 | { | ||
1252 | strlcpy(di->driver, DRV_NAME, sizeof(di->driver)); | ||
1253 | strlcpy(di->version, "1.00", sizeof(di->version)); | ||
1254 | strlcpy(di->bus_info, dev_name(netdev->dev.parent), | ||
1255 | sizeof(di->bus_info)); | ||
1256 | } | ||
1257 | |||
1258 | static u32 ks_get_msglevel(struct net_device *netdev) | ||
1259 | { | ||
1260 | struct ks_net *ks = netdev_priv(netdev); | ||
1261 | return ks->msg_enable; | ||
1262 | } | ||
1263 | |||
1264 | static void ks_set_msglevel(struct net_device *netdev, u32 to) | ||
1265 | { | ||
1266 | struct ks_net *ks = netdev_priv(netdev); | ||
1267 | ks->msg_enable = to; | ||
1268 | } | ||
1269 | |||
1270 | static int ks_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd) | ||
1271 | { | ||
1272 | struct ks_net *ks = netdev_priv(netdev); | ||
1273 | return mii_ethtool_gset(&ks->mii, cmd); | ||
1274 | } | ||
1275 | |||
1276 | static int ks_set_settings(struct net_device *netdev, struct ethtool_cmd *cmd) | ||
1277 | { | ||
1278 | struct ks_net *ks = netdev_priv(netdev); | ||
1279 | return mii_ethtool_sset(&ks->mii, cmd); | ||
1280 | } | ||
1281 | |||
1282 | static u32 ks_get_link(struct net_device *netdev) | ||
1283 | { | ||
1284 | struct ks_net *ks = netdev_priv(netdev); | ||
1285 | return mii_link_ok(&ks->mii); | ||
1286 | } | ||
1287 | |||
1288 | static int ks_nway_reset(struct net_device *netdev) | ||
1289 | { | ||
1290 | struct ks_net *ks = netdev_priv(netdev); | ||
1291 | return mii_nway_restart(&ks->mii); | ||
1292 | } | ||
1293 | |||
1294 | static const struct ethtool_ops ks_ethtool_ops = { | ||
1295 | .get_drvinfo = ks_get_drvinfo, | ||
1296 | .get_msglevel = ks_get_msglevel, | ||
1297 | .set_msglevel = ks_set_msglevel, | ||
1298 | .get_settings = ks_get_settings, | ||
1299 | .set_settings = ks_set_settings, | ||
1300 | .get_link = ks_get_link, | ||
1301 | .nway_reset = ks_nway_reset, | ||
1302 | }; | ||
1303 | |||
1304 | /* MII interface controls */ | ||
1305 | |||
1306 | /** | ||
1307 | * ks_phy_reg - convert MII register into a KS8851 register | ||
1308 | * @reg: MII register number. | ||
1309 | * | ||
1310 | * Return the KS8851 register number for the corresponding MII PHY register | ||
1311 | * if possible. Return zero if the MII register has no direct mapping to the | ||
1312 | * KS8851 register set. | ||
1313 | */ | ||
1314 | static int ks_phy_reg(int reg) | ||
1315 | { | ||
1316 | switch (reg) { | ||
1317 | case MII_BMCR: | ||
1318 | return KS_P1MBCR; | ||
1319 | case MII_BMSR: | ||
1320 | return KS_P1MBSR; | ||
1321 | case MII_PHYSID1: | ||
1322 | return KS_PHY1ILR; | ||
1323 | case MII_PHYSID2: | ||
1324 | return KS_PHY1IHR; | ||
1325 | case MII_ADVERTISE: | ||
1326 | return KS_P1ANAR; | ||
1327 | case MII_LPA: | ||
1328 | return KS_P1ANLPR; | ||
1329 | } | ||
1330 | |||
1331 | return 0x0; | ||
1332 | } | ||
1333 | |||
1334 | /** | ||
1335 | * ks_phy_read - MII interface PHY register read. | ||
1336 | * @netdev: The network device the PHY is on. | ||
1337 | * @phy_addr: Address of PHY (ignored as we only have one) | ||
1338 | * @reg: The register to read. | ||
1339 | * | ||
1340 | * This call reads data from the PHY register specified in @reg. Since the | ||
1341 | * device does not support all the MII registers, the non-existant values | ||
1342 | * are always returned as zero. | ||
1343 | * | ||
1344 | * We return zero for unsupported registers as the MII code does not check | ||
1345 | * the value returned for any error status, and simply returns it to the | ||
1346 | * caller. The mii-tool that the driver was tested with takes any -ve error | ||
1347 | * as real PHY capabilities, thus displaying incorrect data to the user. | ||
1348 | */ | ||
1349 | static int ks_phy_read(struct net_device *netdev, int phy_addr, int reg) | ||
1350 | { | ||
1351 | struct ks_net *ks = netdev_priv(netdev); | ||
1352 | int ksreg; | ||
1353 | int result; | ||
1354 | |||
1355 | ksreg = ks_phy_reg(reg); | ||
1356 | if (!ksreg) | ||
1357 | return 0x0; /* no error return allowed, so use zero */ | ||
1358 | |||
1359 | mutex_lock(&ks->lock); | ||
1360 | result = ks_rdreg16(ks, ksreg); | ||
1361 | mutex_unlock(&ks->lock); | ||
1362 | |||
1363 | return result; | ||
1364 | } | ||
1365 | |||
1366 | static void ks_phy_write(struct net_device *netdev, | ||
1367 | int phy, int reg, int value) | ||
1368 | { | ||
1369 | struct ks_net *ks = netdev_priv(netdev); | ||
1370 | int ksreg; | ||
1371 | |||
1372 | ksreg = ks_phy_reg(reg); | ||
1373 | if (ksreg) { | ||
1374 | mutex_lock(&ks->lock); | ||
1375 | ks_wrreg16(ks, ksreg, value); | ||
1376 | mutex_unlock(&ks->lock); | ||
1377 | } | ||
1378 | } | ||
1379 | |||
1380 | /** | ||
1381 | * ks_read_selftest - read the selftest memory info. | ||
1382 | * @ks: The device state | ||
1383 | * | ||
1384 | * Read and check the TX/RX memory selftest information. | ||
1385 | */ | ||
1386 | static int ks_read_selftest(struct ks_net *ks) | ||
1387 | { | ||
1388 | unsigned both_done = MBIR_TXMBF | MBIR_RXMBF; | ||
1389 | int ret = 0; | ||
1390 | unsigned rd; | ||
1391 | |||
1392 | rd = ks_rdreg16(ks, KS_MBIR); | ||
1393 | |||
1394 | if ((rd & both_done) != both_done) { | ||
1395 | ks_warn(ks, "Memory selftest not finished\n"); | ||
1396 | return 0; | ||
1397 | } | ||
1398 | |||
1399 | if (rd & MBIR_TXMBFA) { | ||
1400 | ks_err(ks, "TX memory selftest fails\n"); | ||
1401 | ret |= 1; | ||
1402 | } | ||
1403 | |||
1404 | if (rd & MBIR_RXMBFA) { | ||
1405 | ks_err(ks, "RX memory selftest fails\n"); | ||
1406 | ret |= 2; | ||
1407 | } | ||
1408 | |||
1409 | ks_info(ks, "the selftest passes\n"); | ||
1410 | return ret; | ||
1411 | } | ||
1412 | |||
1413 | static void ks_disable(struct ks_net *ks) | ||
1414 | { | ||
1415 | u16 w; | ||
1416 | |||
1417 | w = ks_rdreg16(ks, KS_TXCR); | ||
1418 | |||
1419 | /* Disables QMU Transmit (TXCR). */ | ||
1420 | w &= ~TXCR_TXE; | ||
1421 | ks_wrreg16(ks, KS_TXCR, w); | ||
1422 | |||
1423 | /* Disables QMU Receive (RXCR1). */ | ||
1424 | w = ks_rdreg16(ks, KS_RXCR1); | ||
1425 | w &= ~RXCR1_RXE ; | ||
1426 | ks_wrreg16(ks, KS_RXCR1, w); | ||
1427 | |||
1428 | ks->enabled = false; | ||
1429 | |||
1430 | } /* ks_disable */ | ||
1431 | |||
1432 | static void ks_setup(struct ks_net *ks) | ||
1433 | { | ||
1434 | u16 w; | ||
1435 | |||
1436 | /** | ||
1437 | * Configure QMU Transmit | ||
1438 | */ | ||
1439 | |||
1440 | /* Setup Transmit Frame Data Pointer Auto-Increment (TXFDPR) */ | ||
1441 | ks_wrreg16(ks, KS_TXFDPR, TXFDPR_TXFPAI); | ||
1442 | |||
1443 | /* Setup Receive Frame Data Pointer Auto-Increment */ | ||
1444 | ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI); | ||
1445 | |||
1446 | /* Setup Receive Frame Threshold - 1 frame (RXFCTFC) */ | ||
1447 | ks_wrreg16(ks, KS_RXFCTR, 1 & RXFCTR_THRESHOLD_MASK); | ||
1448 | |||
1449 | /* Setup RxQ Command Control (RXQCR) */ | ||
1450 | ks->rc_rxqcr = RXQCR_CMD_CNTL; | ||
1451 | ks_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr); | ||
1452 | |||
1453 | /** | ||
1454 | * set the force mode to half duplex, default is full duplex | ||
1455 | * because if the auto-negotiation fails, most switch uses | ||
1456 | * half-duplex. | ||
1457 | */ | ||
1458 | |||
1459 | w = ks_rdreg16(ks, KS_P1MBCR); | ||
1460 | w &= ~P1MBCR_FORCE_FDX; | ||
1461 | ks_wrreg16(ks, KS_P1MBCR, w); | ||
1462 | |||
1463 | w = TXCR_TXFCE | TXCR_TXPE | TXCR_TXCRC | TXCR_TCGIP; | ||
1464 | ks_wrreg16(ks, KS_TXCR, w); | ||
1465 | |||
1466 | w = RXCR1_RXFCE | RXCR1_RXBE | RXCR1_RXUE; | ||
1467 | |||
1468 | if (ks->promiscuous) /* bPromiscuous */ | ||
1469 | w |= (RXCR1_RXAE | RXCR1_RXINVF); | ||
1470 | else if (ks->all_mcast) /* Multicast address passed mode */ | ||
1471 | w |= (RXCR1_RXAE | RXCR1_RXMAFMA | RXCR1_RXPAFMA); | ||
1472 | else /* Normal mode */ | ||
1473 | w |= RXCR1_RXPAFMA; | ||
1474 | |||
1475 | ks_wrreg16(ks, KS_RXCR1, w); | ||
1476 | } /*ks_setup */ | ||
1477 | |||
1478 | |||
1479 | static void ks_setup_int(struct ks_net *ks) | ||
1480 | { | ||
1481 | ks->rc_ier = 0x00; | ||
1482 | /* Clear the interrupts status of the hardware. */ | ||
1483 | ks_wrreg16(ks, KS_ISR, 0xffff); | ||
1484 | |||
1485 | /* Enables the interrupts of the hardware. */ | ||
1486 | ks->rc_ier = (IRQ_LCI | IRQ_TXI | IRQ_RXI); | ||
1487 | } /* ks_setup_int */ | ||
1488 | |||
1489 | void ks_enable(struct ks_net *ks) | ||
1490 | { | ||
1491 | u16 w; | ||
1492 | |||
1493 | w = ks_rdreg16(ks, KS_TXCR); | ||
1494 | /* Enables QMU Transmit (TXCR). */ | ||
1495 | ks_wrreg16(ks, KS_TXCR, w | TXCR_TXE); | ||
1496 | |||
1497 | /* | ||
1498 | * RX Frame Count Threshold Enable and Auto-Dequeue RXQ Frame | ||
1499 | * Enable | ||
1500 | */ | ||
1501 | |||
1502 | w = ks_rdreg16(ks, KS_RXQCR); | ||
1503 | ks_wrreg16(ks, KS_RXQCR, w | RXQCR_RXFCTE); | ||
1504 | |||
1505 | /* Enables QMU Receive (RXCR1). */ | ||
1506 | w = ks_rdreg16(ks, KS_RXCR1); | ||
1507 | ks_wrreg16(ks, KS_RXCR1, w | RXCR1_RXE); | ||
1508 | ks->enabled = true; | ||
1509 | } /* ks_enable */ | ||
1510 | |||
1511 | static int ks_hw_init(struct ks_net *ks) | ||
1512 | { | ||
1513 | #define MHEADER_SIZE (sizeof(struct type_frame_head) * MAX_RECV_FRAMES) | ||
1514 | ks->promiscuous = 0; | ||
1515 | ks->all_mcast = 0; | ||
1516 | ks->mcast_lst_size = 0; | ||
1517 | |||
1518 | ks->frame_head_info = (struct type_frame_head *) \ | ||
1519 | kmalloc(MHEADER_SIZE, GFP_KERNEL); | ||
1520 | if (!ks->frame_head_info) { | ||
1521 | printk(KERN_ERR "Error: Fail to allocate frame memory\n"); | ||
1522 | return false; | ||
1523 | } | ||
1524 | |||
1525 | ks_set_mac(ks, KS_DEFAULT_MAC_ADDRESS); | ||
1526 | return true; | ||
1527 | } | ||
1528 | |||
1529 | |||
1530 | static int __devinit ks8851_probe(struct platform_device *pdev) | ||
1531 | { | ||
1532 | int err = -ENOMEM; | ||
1533 | struct resource *io_d, *io_c; | ||
1534 | struct net_device *netdev; | ||
1535 | struct ks_net *ks; | ||
1536 | u16 id, data; | ||
1537 | |||
1538 | io_d = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
1539 | io_c = platform_get_resource(pdev, IORESOURCE_MEM, 1); | ||
1540 | |||
1541 | if (!request_mem_region(io_d->start, resource_size(io_d), DRV_NAME)) | ||
1542 | goto err_mem_region; | ||
1543 | |||
1544 | if (!request_mem_region(io_c->start, resource_size(io_c), DRV_NAME)) | ||
1545 | goto err_mem_region1; | ||
1546 | |||
1547 | netdev = alloc_etherdev(sizeof(struct ks_net)); | ||
1548 | if (!netdev) | ||
1549 | goto err_alloc_etherdev; | ||
1550 | |||
1551 | SET_NETDEV_DEV(netdev, &pdev->dev); | ||
1552 | |||
1553 | ks = netdev_priv(netdev); | ||
1554 | ks->netdev = netdev; | ||
1555 | ks->hw_addr = ioremap(io_d->start, resource_size(io_d)); | ||
1556 | |||
1557 | if (!ks->hw_addr) | ||
1558 | goto err_ioremap; | ||
1559 | |||
1560 | ks->hw_addr_cmd = ioremap(io_c->start, resource_size(io_c)); | ||
1561 | if (!ks->hw_addr_cmd) | ||
1562 | goto err_ioremap1; | ||
1563 | |||
1564 | ks->irq = platform_get_irq(pdev, 0); | ||
1565 | |||
1566 | if (ks->irq < 0) { | ||
1567 | err = ks->irq; | ||
1568 | goto err_get_irq; | ||
1569 | } | ||
1570 | |||
1571 | ks->pdev = pdev; | ||
1572 | |||
1573 | mutex_init(&ks->lock); | ||
1574 | spin_lock_init(&ks->statelock); | ||
1575 | |||
1576 | netdev->netdev_ops = &ks_netdev_ops; | ||
1577 | netdev->ethtool_ops = &ks_ethtool_ops; | ||
1578 | |||
1579 | /* setup mii state */ | ||
1580 | ks->mii.dev = netdev; | ||
1581 | ks->mii.phy_id = 1, | ||
1582 | ks->mii.phy_id_mask = 1; | ||
1583 | ks->mii.reg_num_mask = 0xf; | ||
1584 | ks->mii.mdio_read = ks_phy_read; | ||
1585 | ks->mii.mdio_write = ks_phy_write; | ||
1586 | |||
1587 | ks_info(ks, "message enable is %d\n", msg_enable); | ||
1588 | /* set the default message enable */ | ||
1589 | ks->msg_enable = netif_msg_init(msg_enable, (NETIF_MSG_DRV | | ||
1590 | NETIF_MSG_PROBE | | ||
1591 | NETIF_MSG_LINK)); | ||
1592 | ks_read_config(ks); | ||
1593 | |||
1594 | /* simple check for a valid chip being connected to the bus */ | ||
1595 | if ((ks_rdreg16(ks, KS_CIDER) & ~CIDER_REV_MASK) != CIDER_ID) { | ||
1596 | ks_err(ks, "failed to read device ID\n"); | ||
1597 | err = -ENODEV; | ||
1598 | goto err_register; | ||
1599 | } | ||
1600 | |||
1601 | if (ks_read_selftest(ks)) { | ||
1602 | ks_err(ks, "failed to read device ID\n"); | ||
1603 | err = -ENODEV; | ||
1604 | goto err_register; | ||
1605 | } | ||
1606 | |||
1607 | err = register_netdev(netdev); | ||
1608 | if (err) | ||
1609 | goto err_register; | ||
1610 | |||
1611 | platform_set_drvdata(pdev, netdev); | ||
1612 | |||
1613 | ks_soft_reset(ks, GRR_GSR); | ||
1614 | ks_hw_init(ks); | ||
1615 | ks_disable(ks); | ||
1616 | ks_setup(ks); | ||
1617 | ks_setup_int(ks); | ||
1618 | ks_enable_int(ks); | ||
1619 | ks_enable(ks); | ||
1620 | memcpy(netdev->dev_addr, ks->mac_addr, 6); | ||
1621 | |||
1622 | data = ks_rdreg16(ks, KS_OBCR); | ||
1623 | ks_wrreg16(ks, KS_OBCR, data | OBCR_ODS_16MA); | ||
1624 | |||
1625 | /** | ||
1626 | * If you want to use the default MAC addr, | ||
1627 | * comment out the 2 functions below. | ||
1628 | */ | ||
1629 | |||
1630 | random_ether_addr(netdev->dev_addr); | ||
1631 | ks_set_mac(ks, netdev->dev_addr); | ||
1632 | |||
1633 | id = ks_rdreg16(ks, KS_CIDER); | ||
1634 | |||
1635 | printk(KERN_INFO DRV_NAME | ||
1636 | " Found chip, family: 0x%x, id: 0x%x, rev: 0x%x\n", | ||
1637 | (id >> 8) & 0xff, (id >> 4) & 0xf, (id >> 1) & 0x7); | ||
1638 | return 0; | ||
1639 | |||
1640 | err_register: | ||
1641 | err_get_irq: | ||
1642 | iounmap(ks->hw_addr_cmd); | ||
1643 | err_ioremap1: | ||
1644 | iounmap(ks->hw_addr); | ||
1645 | err_ioremap: | ||
1646 | free_netdev(netdev); | ||
1647 | err_alloc_etherdev: | ||
1648 | release_mem_region(io_c->start, resource_size(io_c)); | ||
1649 | err_mem_region1: | ||
1650 | release_mem_region(io_d->start, resource_size(io_d)); | ||
1651 | err_mem_region: | ||
1652 | return err; | ||
1653 | } | ||
1654 | |||
1655 | static int __devexit ks8851_remove(struct platform_device *pdev) | ||
1656 | { | ||
1657 | struct net_device *netdev = platform_get_drvdata(pdev); | ||
1658 | struct ks_net *ks = netdev_priv(netdev); | ||
1659 | struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); | ||
1660 | |||
1661 | unregister_netdev(netdev); | ||
1662 | iounmap(ks->hw_addr); | ||
1663 | free_netdev(netdev); | ||
1664 | release_mem_region(iomem->start, resource_size(iomem)); | ||
1665 | platform_set_drvdata(pdev, NULL); | ||
1666 | return 0; | ||
1667 | |||
1668 | } | ||
1669 | |||
1670 | static struct platform_driver ks8851_platform_driver = { | ||
1671 | .driver = { | ||
1672 | .name = DRV_NAME, | ||
1673 | .owner = THIS_MODULE, | ||
1674 | }, | ||
1675 | .probe = ks8851_probe, | ||
1676 | .remove = __devexit_p(ks8851_remove), | ||
1677 | }; | ||
1678 | |||
1679 | static int __init ks8851_init(void) | ||
1680 | { | ||
1681 | return platform_driver_register(&ks8851_platform_driver); | ||
1682 | } | ||
1683 | |||
1684 | static void __exit ks8851_exit(void) | ||
1685 | { | ||
1686 | platform_driver_unregister(&ks8851_platform_driver); | ||
1687 | } | ||
1688 | |||
1689 | module_init(ks8851_init); | ||
1690 | module_exit(ks8851_exit); | ||
1691 | |||
1692 | MODULE_DESCRIPTION("KS8851 MLL Network driver"); | ||
1693 | MODULE_AUTHOR("David Choi <david.choi@micrel.com>"); | ||
1694 | MODULE_LICENSE("GPL"); | ||
1695 | module_param_named(message, msg_enable, int, 0); | ||
1696 | MODULE_PARM_DESC(message, "Message verbosity level (0=none, 31=all)"); | ||
1697 | |||
diff --git a/drivers/net/meth.c b/drivers/net/meth.c index 92ceb689b4d4..2af81735386b 100644 --- a/drivers/net/meth.c +++ b/drivers/net/meth.c | |||
@@ -828,7 +828,7 @@ static int __exit meth_remove(struct platform_device *pdev) | |||
828 | 828 | ||
829 | static struct platform_driver meth_driver = { | 829 | static struct platform_driver meth_driver = { |
830 | .probe = meth_probe, | 830 | .probe = meth_probe, |
831 | .remove = __devexit_p(meth_remove), | 831 | .remove = __exit_p(meth_remove), |
832 | .driver = { | 832 | .driver = { |
833 | .name = "meth", | 833 | .name = "meth", |
834 | .owner = THIS_MODULE, | 834 | .owner = THIS_MODULE, |
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c index b5aa974827e5..9b9eab107704 100644 --- a/drivers/net/netxen/netxen_nic_main.c +++ b/drivers/net/netxen/netxen_nic_main.c | |||
@@ -1714,7 +1714,7 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev) | |||
1714 | /* 4 fragments per cmd des */ | 1714 | /* 4 fragments per cmd des */ |
1715 | no_of_desc = (frag_count + 3) >> 2; | 1715 | no_of_desc = (frag_count + 3) >> 2; |
1716 | 1716 | ||
1717 | if (unlikely(no_of_desc + 2) > netxen_tx_avail(tx_ring)) { | 1717 | if (unlikely(no_of_desc + 2 > netxen_tx_avail(tx_ring))) { |
1718 | netif_stop_queue(netdev); | 1718 | netif_stop_queue(netdev); |
1719 | return NETDEV_TX_BUSY; | 1719 | return NETDEV_TX_BUSY; |
1720 | } | 1720 | } |
diff --git a/drivers/net/pasemi_mac_ethtool.c b/drivers/net/pasemi_mac_ethtool.c index 064a4fe1dd90..28a86224879d 100644 --- a/drivers/net/pasemi_mac_ethtool.c +++ b/drivers/net/pasemi_mac_ethtool.c | |||
@@ -71,6 +71,9 @@ pasemi_mac_ethtool_get_settings(struct net_device *netdev, | |||
71 | struct pasemi_mac *mac = netdev_priv(netdev); | 71 | struct pasemi_mac *mac = netdev_priv(netdev); |
72 | struct phy_device *phydev = mac->phydev; | 72 | struct phy_device *phydev = mac->phydev; |
73 | 73 | ||
74 | if (!phydev) | ||
75 | return -EOPNOTSUPP; | ||
76 | |||
74 | return phy_ethtool_gset(phydev, cmd); | 77 | return phy_ethtool_gset(phydev, cmd); |
75 | } | 78 | } |
76 | 79 | ||
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c index 474876c879cb..bd3447f04902 100644 --- a/drivers/net/pcmcia/pcnet_cs.c +++ b/drivers/net/pcmcia/pcnet_cs.c | |||
@@ -1754,14 +1754,14 @@ static struct pcmcia_device_id pcnet_ids[] = { | |||
1754 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "cis/PCMLM28.cis"), | 1754 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "cis/PCMLM28.cis"), |
1755 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "cis/PCMLM28.cis"), | 1755 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "cis/PCMLM28.cis"), |
1756 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "cis/PCMLM28.cis"), | 1756 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(0, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "cis/PCMLM28.cis"), |
1757 | PCMCIA_MFC_DEVICE_CIS_PROD_ID12(0, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"), | 1757 | PCMCIA_MFC_DEVICE_CIS_PROD_ID12(0, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "cis/DP83903.cis"), |
1758 | PCMCIA_MFC_DEVICE_CIS_PROD_ID4(0, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"), | 1758 | PCMCIA_MFC_DEVICE_CIS_PROD_ID4(0, "NSC MF LAN/Modem", 0x58fc6056, "cis/DP83903.cis"), |
1759 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0175, 0x0000, "DP83903.cis"), | 1759 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0175, 0x0000, "cis/DP83903.cis"), |
1760 | PCMCIA_DEVICE_CIS_MANF_CARD(0xc00f, 0x0002, "cis/LA-PCM.cis"), | 1760 | PCMCIA_DEVICE_CIS_MANF_CARD(0xc00f, 0x0002, "cis/LA-PCM.cis"), |
1761 | PCMCIA_DEVICE_CIS_PROD_ID12("KTI", "PE520 PLUS", 0xad180345, 0x9d58d392, "PE520.cis"), | 1761 | PCMCIA_DEVICE_CIS_PROD_ID12("KTI", "PE520 PLUS", 0xad180345, 0x9d58d392, "PE520.cis"), |
1762 | PCMCIA_DEVICE_CIS_PROD_ID12("NDC", "Ethernet", 0x01c43ae1, 0x00b2e941, "NE2K.cis"), | 1762 | PCMCIA_DEVICE_CIS_PROD_ID12("NDC", "Ethernet", 0x01c43ae1, 0x00b2e941, "cis/NE2K.cis"), |
1763 | PCMCIA_DEVICE_CIS_PROD_ID12("PMX ", "PE-200", 0x34f3f1c8, 0x10b59f8c, "PE-200.cis"), | 1763 | PCMCIA_DEVICE_CIS_PROD_ID12("PMX ", "PE-200", 0x34f3f1c8, 0x10b59f8c, "PE-200.cis"), |
1764 | PCMCIA_DEVICE_CIS_PROD_ID12("TAMARACK", "Ethernet", 0xcf434fba, 0x00b2e941, "tamarack.cis"), | 1764 | PCMCIA_DEVICE_CIS_PROD_ID12("TAMARACK", "Ethernet", 0xcf434fba, 0x00b2e941, "cis/tamarack.cis"), |
1765 | PCMCIA_DEVICE_PROD_ID12("Ethernet", "CF Size PC Card", 0x00b2e941, 0x43ac239b), | 1765 | PCMCIA_DEVICE_PROD_ID12("Ethernet", "CF Size PC Card", 0x00b2e941, 0x43ac239b), |
1766 | PCMCIA_DEVICE_PROD_ID123("Fast Ethernet", "CF Size PC Card", "1.0", | 1766 | PCMCIA_DEVICE_PROD_ID123("Fast Ethernet", "CF Size PC Card", "1.0", |
1767 | 0xb4be14e3, 0x43ac239b, 0x0877b627), | 1767 | 0xb4be14e3, 0x43ac239b, 0x0877b627), |
diff --git a/drivers/net/pppol2tp.c b/drivers/net/pppol2tp.c index cc394d073755..5910df60c93e 100644 --- a/drivers/net/pppol2tp.c +++ b/drivers/net/pppol2tp.c | |||
@@ -2179,7 +2179,7 @@ static int pppol2tp_session_setsockopt(struct sock *sk, | |||
2179 | * session or the special tunnel type. | 2179 | * session or the special tunnel type. |
2180 | */ | 2180 | */ |
2181 | static int pppol2tp_setsockopt(struct socket *sock, int level, int optname, | 2181 | static int pppol2tp_setsockopt(struct socket *sock, int level, int optname, |
2182 | char __user *optval, int optlen) | 2182 | char __user *optval, unsigned int optlen) |
2183 | { | 2183 | { |
2184 | struct sock *sk = sock->sk; | 2184 | struct sock *sk = sock->sk; |
2185 | struct pppol2tp_session *session = sk->sk_user_data; | 2185 | struct pppol2tp_session *session = sk->sk_user_data; |
diff --git a/drivers/net/qlge/qlge.h b/drivers/net/qlge/qlge.h index a9845a2f243f..3ec6e85587a2 100644 --- a/drivers/net/qlge/qlge.h +++ b/drivers/net/qlge/qlge.h | |||
@@ -9,6 +9,7 @@ | |||
9 | 9 | ||
10 | #include <linux/pci.h> | 10 | #include <linux/pci.h> |
11 | #include <linux/netdevice.h> | 11 | #include <linux/netdevice.h> |
12 | #include <linux/rtnetlink.h> | ||
12 | 13 | ||
13 | /* | 14 | /* |
14 | * General definitions... | 15 | * General definitions... |
@@ -135,9 +136,9 @@ enum { | |||
135 | RST_FO_TFO = (1 << 0), | 136 | RST_FO_TFO = (1 << 0), |
136 | RST_FO_RR_MASK = 0x00060000, | 137 | RST_FO_RR_MASK = 0x00060000, |
137 | RST_FO_RR_CQ_CAM = 0x00000000, | 138 | RST_FO_RR_CQ_CAM = 0x00000000, |
138 | RST_FO_RR_DROP = 0x00000001, | 139 | RST_FO_RR_DROP = 0x00000002, |
139 | RST_FO_RR_DQ = 0x00000002, | 140 | RST_FO_RR_DQ = 0x00000004, |
140 | RST_FO_RR_RCV_FUNC_CQ = 0x00000003, | 141 | RST_FO_RR_RCV_FUNC_CQ = 0x00000006, |
141 | RST_FO_FRB = (1 << 12), | 142 | RST_FO_FRB = (1 << 12), |
142 | RST_FO_MOP = (1 << 13), | 143 | RST_FO_MOP = (1 << 13), |
143 | RST_FO_REG = (1 << 14), | 144 | RST_FO_REG = (1 << 14), |
@@ -1381,15 +1382,15 @@ struct intr_context { | |||
1381 | 1382 | ||
1382 | /* adapter flags definitions. */ | 1383 | /* adapter flags definitions. */ |
1383 | enum { | 1384 | enum { |
1384 | QL_ADAPTER_UP = (1 << 0), /* Adapter has been brought up. */ | 1385 | QL_ADAPTER_UP = 0, /* Adapter has been brought up. */ |
1385 | QL_LEGACY_ENABLED = (1 << 3), | 1386 | QL_LEGACY_ENABLED = 1, |
1386 | QL_MSI_ENABLED = (1 << 3), | 1387 | QL_MSI_ENABLED = 2, |
1387 | QL_MSIX_ENABLED = (1 << 4), | 1388 | QL_MSIX_ENABLED = 3, |
1388 | QL_DMA64 = (1 << 5), | 1389 | QL_DMA64 = 4, |
1389 | QL_PROMISCUOUS = (1 << 6), | 1390 | QL_PROMISCUOUS = 5, |
1390 | QL_ALLMULTI = (1 << 7), | 1391 | QL_ALLMULTI = 6, |
1391 | QL_PORT_CFG = (1 << 8), | 1392 | QL_PORT_CFG = 7, |
1392 | QL_CAM_RT_SET = (1 << 9), | 1393 | QL_CAM_RT_SET = 8, |
1393 | }; | 1394 | }; |
1394 | 1395 | ||
1395 | /* link_status bit definitions */ | 1396 | /* link_status bit definitions */ |
@@ -1477,7 +1478,6 @@ struct ql_adapter { | |||
1477 | u32 mailbox_in; | 1478 | u32 mailbox_in; |
1478 | u32 mailbox_out; | 1479 | u32 mailbox_out; |
1479 | struct mbox_params idc_mbc; | 1480 | struct mbox_params idc_mbc; |
1480 | struct mutex mpi_mutex; | ||
1481 | 1481 | ||
1482 | int tx_ring_size; | 1482 | int tx_ring_size; |
1483 | int rx_ring_size; | 1483 | int rx_ring_size; |
diff --git a/drivers/net/qlge/qlge_ethtool.c b/drivers/net/qlge/qlge_ethtool.c index 68f9bd280f86..52073946bce3 100644 --- a/drivers/net/qlge/qlge_ethtool.c +++ b/drivers/net/qlge/qlge_ethtool.c | |||
@@ -45,7 +45,6 @@ static int ql_update_ring_coalescing(struct ql_adapter *qdev) | |||
45 | if (!netif_running(qdev->ndev)) | 45 | if (!netif_running(qdev->ndev)) |
46 | return status; | 46 | return status; |
47 | 47 | ||
48 | spin_lock(&qdev->hw_lock); | ||
49 | /* Skip the default queue, and update the outbound handler | 48 | /* Skip the default queue, and update the outbound handler |
50 | * queues if they changed. | 49 | * queues if they changed. |
51 | */ | 50 | */ |
@@ -92,7 +91,6 @@ static int ql_update_ring_coalescing(struct ql_adapter *qdev) | |||
92 | } | 91 | } |
93 | } | 92 | } |
94 | exit: | 93 | exit: |
95 | spin_unlock(&qdev->hw_lock); | ||
96 | return status; | 94 | return status; |
97 | } | 95 | } |
98 | 96 | ||
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c index 7783c5db81dc..61680715cde0 100644 --- a/drivers/net/qlge/qlge_main.c +++ b/drivers/net/qlge/qlge_main.c | |||
@@ -34,7 +34,6 @@ | |||
34 | #include <linux/etherdevice.h> | 34 | #include <linux/etherdevice.h> |
35 | #include <linux/ethtool.h> | 35 | #include <linux/ethtool.h> |
36 | #include <linux/skbuff.h> | 36 | #include <linux/skbuff.h> |
37 | #include <linux/rtnetlink.h> | ||
38 | #include <linux/if_vlan.h> | 37 | #include <linux/if_vlan.h> |
39 | #include <linux/delay.h> | 38 | #include <linux/delay.h> |
40 | #include <linux/mm.h> | 39 | #include <linux/mm.h> |
@@ -1926,12 +1925,10 @@ static void ql_vlan_rx_add_vid(struct net_device *ndev, u16 vid) | |||
1926 | status = ql_sem_spinlock(qdev, SEM_MAC_ADDR_MASK); | 1925 | status = ql_sem_spinlock(qdev, SEM_MAC_ADDR_MASK); |
1927 | if (status) | 1926 | if (status) |
1928 | return; | 1927 | return; |
1929 | spin_lock(&qdev->hw_lock); | ||
1930 | if (ql_set_mac_addr_reg | 1928 | if (ql_set_mac_addr_reg |
1931 | (qdev, (u8 *) &enable_bit, MAC_ADDR_TYPE_VLAN, vid)) { | 1929 | (qdev, (u8 *) &enable_bit, MAC_ADDR_TYPE_VLAN, vid)) { |
1932 | QPRINTK(qdev, IFUP, ERR, "Failed to init vlan address.\n"); | 1930 | QPRINTK(qdev, IFUP, ERR, "Failed to init vlan address.\n"); |
1933 | } | 1931 | } |
1934 | spin_unlock(&qdev->hw_lock); | ||
1935 | ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK); | 1932 | ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK); |
1936 | } | 1933 | } |
1937 | 1934 | ||
@@ -1945,12 +1942,10 @@ static void ql_vlan_rx_kill_vid(struct net_device *ndev, u16 vid) | |||
1945 | if (status) | 1942 | if (status) |
1946 | return; | 1943 | return; |
1947 | 1944 | ||
1948 | spin_lock(&qdev->hw_lock); | ||
1949 | if (ql_set_mac_addr_reg | 1945 | if (ql_set_mac_addr_reg |
1950 | (qdev, (u8 *) &enable_bit, MAC_ADDR_TYPE_VLAN, vid)) { | 1946 | (qdev, (u8 *) &enable_bit, MAC_ADDR_TYPE_VLAN, vid)) { |
1951 | QPRINTK(qdev, IFUP, ERR, "Failed to clear vlan address.\n"); | 1947 | QPRINTK(qdev, IFUP, ERR, "Failed to clear vlan address.\n"); |
1952 | } | 1948 | } |
1953 | spin_unlock(&qdev->hw_lock); | ||
1954 | ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK); | 1949 | ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK); |
1955 | 1950 | ||
1956 | } | 1951 | } |
@@ -2001,15 +1996,17 @@ static irqreturn_t qlge_isr(int irq, void *dev_id) | |||
2001 | /* | 1996 | /* |
2002 | * Check MPI processor activity. | 1997 | * Check MPI processor activity. |
2003 | */ | 1998 | */ |
2004 | if (var & STS_PI) { | 1999 | if ((var & STS_PI) && |
2000 | (ql_read32(qdev, INTR_MASK) & INTR_MASK_PI)) { | ||
2005 | /* | 2001 | /* |
2006 | * We've got an async event or mailbox completion. | 2002 | * We've got an async event or mailbox completion. |
2007 | * Handle it and clear the source of the interrupt. | 2003 | * Handle it and clear the source of the interrupt. |
2008 | */ | 2004 | */ |
2009 | QPRINTK(qdev, INTR, ERR, "Got MPI processor interrupt.\n"); | 2005 | QPRINTK(qdev, INTR, ERR, "Got MPI processor interrupt.\n"); |
2010 | ql_disable_completion_interrupt(qdev, intr_context->intr); | 2006 | ql_disable_completion_interrupt(qdev, intr_context->intr); |
2011 | queue_delayed_work_on(smp_processor_id(), qdev->workqueue, | 2007 | ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16)); |
2012 | &qdev->mpi_work, 0); | 2008 | queue_delayed_work_on(smp_processor_id(), |
2009 | qdev->workqueue, &qdev->mpi_work, 0); | ||
2013 | work_done++; | 2010 | work_done++; |
2014 | } | 2011 | } |
2015 | 2012 | ||
@@ -3142,14 +3139,14 @@ static int ql_route_initialize(struct ql_adapter *qdev) | |||
3142 | { | 3139 | { |
3143 | int status = 0; | 3140 | int status = 0; |
3144 | 3141 | ||
3145 | status = ql_sem_spinlock(qdev, SEM_RT_IDX_MASK); | 3142 | /* Clear all the entries in the routing table. */ |
3143 | status = ql_clear_routing_entries(qdev); | ||
3146 | if (status) | 3144 | if (status) |
3147 | return status; | 3145 | return status; |
3148 | 3146 | ||
3149 | /* Clear all the entries in the routing table. */ | 3147 | status = ql_sem_spinlock(qdev, SEM_RT_IDX_MASK); |
3150 | status = ql_clear_routing_entries(qdev); | ||
3151 | if (status) | 3148 | if (status) |
3152 | goto exit; | 3149 | return status; |
3153 | 3150 | ||
3154 | status = ql_set_routing_reg(qdev, RT_IDX_ALL_ERR_SLOT, RT_IDX_ERR, 1); | 3151 | status = ql_set_routing_reg(qdev, RT_IDX_ALL_ERR_SLOT, RT_IDX_ERR, 1); |
3155 | if (status) { | 3152 | if (status) { |
@@ -3380,12 +3377,10 @@ static int ql_adapter_down(struct ql_adapter *qdev) | |||
3380 | 3377 | ||
3381 | ql_free_rx_buffers(qdev); | 3378 | ql_free_rx_buffers(qdev); |
3382 | 3379 | ||
3383 | spin_lock(&qdev->hw_lock); | ||
3384 | status = ql_adapter_reset(qdev); | 3380 | status = ql_adapter_reset(qdev); |
3385 | if (status) | 3381 | if (status) |
3386 | QPRINTK(qdev, IFDOWN, ERR, "reset(func #%d) FAILED!\n", | 3382 | QPRINTK(qdev, IFDOWN, ERR, "reset(func #%d) FAILED!\n", |
3387 | qdev->func); | 3383 | qdev->func); |
3388 | spin_unlock(&qdev->hw_lock); | ||
3389 | return status; | 3384 | return status; |
3390 | } | 3385 | } |
3391 | 3386 | ||
@@ -3587,7 +3582,6 @@ static void qlge_set_multicast_list(struct net_device *ndev) | |||
3587 | status = ql_sem_spinlock(qdev, SEM_RT_IDX_MASK); | 3582 | status = ql_sem_spinlock(qdev, SEM_RT_IDX_MASK); |
3588 | if (status) | 3583 | if (status) |
3589 | return; | 3584 | return; |
3590 | spin_lock(&qdev->hw_lock); | ||
3591 | /* | 3585 | /* |
3592 | * Set or clear promiscuous mode if a | 3586 | * Set or clear promiscuous mode if a |
3593 | * transition is taking place. | 3587 | * transition is taking place. |
@@ -3664,7 +3658,6 @@ static void qlge_set_multicast_list(struct net_device *ndev) | |||
3664 | } | 3658 | } |
3665 | } | 3659 | } |
3666 | exit: | 3660 | exit: |
3667 | spin_unlock(&qdev->hw_lock); | ||
3668 | ql_sem_unlock(qdev, SEM_RT_IDX_MASK); | 3661 | ql_sem_unlock(qdev, SEM_RT_IDX_MASK); |
3669 | } | 3662 | } |
3670 | 3663 | ||
@@ -3684,10 +3677,8 @@ static int qlge_set_mac_address(struct net_device *ndev, void *p) | |||
3684 | status = ql_sem_spinlock(qdev, SEM_MAC_ADDR_MASK); | 3677 | status = ql_sem_spinlock(qdev, SEM_MAC_ADDR_MASK); |
3685 | if (status) | 3678 | if (status) |
3686 | return status; | 3679 | return status; |
3687 | spin_lock(&qdev->hw_lock); | ||
3688 | status = ql_set_mac_addr_reg(qdev, (u8 *) ndev->dev_addr, | 3680 | status = ql_set_mac_addr_reg(qdev, (u8 *) ndev->dev_addr, |
3689 | MAC_ADDR_TYPE_CAM_MAC, qdev->func * MAX_CQ); | 3681 | MAC_ADDR_TYPE_CAM_MAC, qdev->func * MAX_CQ); |
3690 | spin_unlock(&qdev->hw_lock); | ||
3691 | if (status) | 3682 | if (status) |
3692 | QPRINTK(qdev, HW, ERR, "Failed to load MAC address.\n"); | 3683 | QPRINTK(qdev, HW, ERR, "Failed to load MAC address.\n"); |
3693 | ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK); | 3684 | ql_sem_unlock(qdev, SEM_MAC_ADDR_MASK); |
@@ -3705,7 +3696,7 @@ static void ql_asic_reset_work(struct work_struct *work) | |||
3705 | struct ql_adapter *qdev = | 3696 | struct ql_adapter *qdev = |
3706 | container_of(work, struct ql_adapter, asic_reset_work.work); | 3697 | container_of(work, struct ql_adapter, asic_reset_work.work); |
3707 | int status; | 3698 | int status; |
3708 | 3699 | rtnl_lock(); | |
3709 | status = ql_adapter_down(qdev); | 3700 | status = ql_adapter_down(qdev); |
3710 | if (status) | 3701 | if (status) |
3711 | goto error; | 3702 | goto error; |
@@ -3713,12 +3704,12 @@ static void ql_asic_reset_work(struct work_struct *work) | |||
3713 | status = ql_adapter_up(qdev); | 3704 | status = ql_adapter_up(qdev); |
3714 | if (status) | 3705 | if (status) |
3715 | goto error; | 3706 | goto error; |
3716 | 3707 | rtnl_unlock(); | |
3717 | return; | 3708 | return; |
3718 | error: | 3709 | error: |
3719 | QPRINTK(qdev, IFUP, ALERT, | 3710 | QPRINTK(qdev, IFUP, ALERT, |
3720 | "Driver up/down cycle failed, closing device\n"); | 3711 | "Driver up/down cycle failed, closing device\n"); |
3721 | rtnl_lock(); | 3712 | |
3722 | set_bit(QL_ADAPTER_UP, &qdev->flags); | 3713 | set_bit(QL_ADAPTER_UP, &qdev->flags); |
3723 | dev_close(qdev->ndev); | 3714 | dev_close(qdev->ndev); |
3724 | rtnl_unlock(); | 3715 | rtnl_unlock(); |
@@ -3834,11 +3825,14 @@ static int __devinit ql_init_device(struct pci_dev *pdev, | |||
3834 | return err; | 3825 | return err; |
3835 | } | 3826 | } |
3836 | 3827 | ||
3828 | qdev->ndev = ndev; | ||
3829 | qdev->pdev = pdev; | ||
3830 | pci_set_drvdata(pdev, ndev); | ||
3837 | pos = pci_find_capability(pdev, PCI_CAP_ID_EXP); | 3831 | pos = pci_find_capability(pdev, PCI_CAP_ID_EXP); |
3838 | if (pos <= 0) { | 3832 | if (pos <= 0) { |
3839 | dev_err(&pdev->dev, PFX "Cannot find PCI Express capability, " | 3833 | dev_err(&pdev->dev, PFX "Cannot find PCI Express capability, " |
3840 | "aborting.\n"); | 3834 | "aborting.\n"); |
3841 | goto err_out; | 3835 | return pos; |
3842 | } else { | 3836 | } else { |
3843 | pci_read_config_word(pdev, pos + PCI_EXP_DEVCTL, &val16); | 3837 | pci_read_config_word(pdev, pos + PCI_EXP_DEVCTL, &val16); |
3844 | val16 &= ~PCI_EXP_DEVCTL_NOSNOOP_EN; | 3838 | val16 &= ~PCI_EXP_DEVCTL_NOSNOOP_EN; |
@@ -3851,7 +3845,7 @@ static int __devinit ql_init_device(struct pci_dev *pdev, | |||
3851 | err = pci_request_regions(pdev, DRV_NAME); | 3845 | err = pci_request_regions(pdev, DRV_NAME); |
3852 | if (err) { | 3846 | if (err) { |
3853 | dev_err(&pdev->dev, "PCI region request failed.\n"); | 3847 | dev_err(&pdev->dev, "PCI region request failed.\n"); |
3854 | goto err_out; | 3848 | return err; |
3855 | } | 3849 | } |
3856 | 3850 | ||
3857 | pci_set_master(pdev); | 3851 | pci_set_master(pdev); |
@@ -3869,7 +3863,6 @@ static int __devinit ql_init_device(struct pci_dev *pdev, | |||
3869 | goto err_out; | 3863 | goto err_out; |
3870 | } | 3864 | } |
3871 | 3865 | ||
3872 | pci_set_drvdata(pdev, ndev); | ||
3873 | qdev->reg_base = | 3866 | qdev->reg_base = |
3874 | ioremap_nocache(pci_resource_start(pdev, 1), | 3867 | ioremap_nocache(pci_resource_start(pdev, 1), |
3875 | pci_resource_len(pdev, 1)); | 3868 | pci_resource_len(pdev, 1)); |
@@ -3889,8 +3882,6 @@ static int __devinit ql_init_device(struct pci_dev *pdev, | |||
3889 | goto err_out; | 3882 | goto err_out; |
3890 | } | 3883 | } |
3891 | 3884 | ||
3892 | qdev->ndev = ndev; | ||
3893 | qdev->pdev = pdev; | ||
3894 | err = ql_get_board_info(qdev); | 3885 | err = ql_get_board_info(qdev); |
3895 | if (err) { | 3886 | if (err) { |
3896 | dev_err(&pdev->dev, "Register access failed.\n"); | 3887 | dev_err(&pdev->dev, "Register access failed.\n"); |
@@ -3930,7 +3921,6 @@ static int __devinit ql_init_device(struct pci_dev *pdev, | |||
3930 | INIT_DELAYED_WORK(&qdev->mpi_work, ql_mpi_work); | 3921 | INIT_DELAYED_WORK(&qdev->mpi_work, ql_mpi_work); |
3931 | INIT_DELAYED_WORK(&qdev->mpi_port_cfg_work, ql_mpi_port_cfg_work); | 3922 | INIT_DELAYED_WORK(&qdev->mpi_port_cfg_work, ql_mpi_port_cfg_work); |
3932 | INIT_DELAYED_WORK(&qdev->mpi_idc_work, ql_mpi_idc_work); | 3923 | INIT_DELAYED_WORK(&qdev->mpi_idc_work, ql_mpi_idc_work); |
3933 | mutex_init(&qdev->mpi_mutex); | ||
3934 | init_completion(&qdev->ide_completion); | 3924 | init_completion(&qdev->ide_completion); |
3935 | 3925 | ||
3936 | if (!cards_found) { | 3926 | if (!cards_found) { |
diff --git a/drivers/net/qlge/qlge_mpi.c b/drivers/net/qlge/qlge_mpi.c index 6685bd97da91..c2e43073047e 100644 --- a/drivers/net/qlge/qlge_mpi.c +++ b/drivers/net/qlge/qlge_mpi.c | |||
@@ -472,7 +472,6 @@ static int ql_mailbox_command(struct ql_adapter *qdev, struct mbox_params *mbcp) | |||
472 | { | 472 | { |
473 | int status, count; | 473 | int status, count; |
474 | 474 | ||
475 | mutex_lock(&qdev->mpi_mutex); | ||
476 | 475 | ||
477 | /* Begin polled mode for MPI */ | 476 | /* Begin polled mode for MPI */ |
478 | ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16)); | 477 | ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16)); |
@@ -541,7 +540,6 @@ static int ql_mailbox_command(struct ql_adapter *qdev, struct mbox_params *mbcp) | |||
541 | status = -EIO; | 540 | status = -EIO; |
542 | } | 541 | } |
543 | end: | 542 | end: |
544 | mutex_unlock(&qdev->mpi_mutex); | ||
545 | /* End polled mode for MPI */ | 543 | /* End polled mode for MPI */ |
546 | ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI); | 544 | ql_write32(qdev, INTR_MASK, (INTR_MASK_PI << 16) | INTR_MASK_PI); |
547 | return status; | 545 | return status; |
@@ -776,7 +774,9 @@ static int ql_idc_wait(struct ql_adapter *qdev) | |||
776 | static int ql_set_port_cfg(struct ql_adapter *qdev) | 774 | static int ql_set_port_cfg(struct ql_adapter *qdev) |
777 | { | 775 | { |
778 | int status; | 776 | int status; |
777 | rtnl_lock(); | ||
779 | status = ql_mb_set_port_cfg(qdev); | 778 | status = ql_mb_set_port_cfg(qdev); |
779 | rtnl_unlock(); | ||
780 | if (status) | 780 | if (status) |
781 | return status; | 781 | return status; |
782 | status = ql_idc_wait(qdev); | 782 | status = ql_idc_wait(qdev); |
@@ -797,7 +797,9 @@ void ql_mpi_port_cfg_work(struct work_struct *work) | |||
797 | container_of(work, struct ql_adapter, mpi_port_cfg_work.work); | 797 | container_of(work, struct ql_adapter, mpi_port_cfg_work.work); |
798 | int status; | 798 | int status; |
799 | 799 | ||
800 | rtnl_lock(); | ||
800 | status = ql_mb_get_port_cfg(qdev); | 801 | status = ql_mb_get_port_cfg(qdev); |
802 | rtnl_unlock(); | ||
801 | if (status) { | 803 | if (status) { |
802 | QPRINTK(qdev, DRV, ERR, | 804 | QPRINTK(qdev, DRV, ERR, |
803 | "Bug: Failed to get port config data.\n"); | 805 | "Bug: Failed to get port config data.\n"); |
@@ -855,7 +857,9 @@ void ql_mpi_idc_work(struct work_struct *work) | |||
855 | * needs to be set. | 857 | * needs to be set. |
856 | * */ | 858 | * */ |
857 | set_bit(QL_CAM_RT_SET, &qdev->flags); | 859 | set_bit(QL_CAM_RT_SET, &qdev->flags); |
860 | rtnl_lock(); | ||
858 | status = ql_mb_idc_ack(qdev); | 861 | status = ql_mb_idc_ack(qdev); |
862 | rtnl_unlock(); | ||
859 | if (status) { | 863 | if (status) { |
860 | QPRINTK(qdev, DRV, ERR, | 864 | QPRINTK(qdev, DRV, ERR, |
861 | "Bug: No pending IDC!\n"); | 865 | "Bug: No pending IDC!\n"); |
@@ -871,7 +875,7 @@ void ql_mpi_work(struct work_struct *work) | |||
871 | struct mbox_params *mbcp = &mbc; | 875 | struct mbox_params *mbcp = &mbc; |
872 | int err = 0; | 876 | int err = 0; |
873 | 877 | ||
874 | mutex_lock(&qdev->mpi_mutex); | 878 | rtnl_lock(); |
875 | 879 | ||
876 | while (ql_read32(qdev, STS) & STS_PI) { | 880 | while (ql_read32(qdev, STS) & STS_PI) { |
877 | memset(mbcp, 0, sizeof(struct mbox_params)); | 881 | memset(mbcp, 0, sizeof(struct mbox_params)); |
@@ -884,7 +888,7 @@ void ql_mpi_work(struct work_struct *work) | |||
884 | break; | 888 | break; |
885 | } | 889 | } |
886 | 890 | ||
887 | mutex_unlock(&qdev->mpi_mutex); | 891 | rtnl_unlock(); |
888 | ql_enable_completion_interrupt(qdev, 0); | 892 | ql_enable_completion_interrupt(qdev, 0); |
889 | } | 893 | } |
890 | 894 | ||
diff --git a/drivers/net/sgiseeq.c b/drivers/net/sgiseeq.c index ecf3279fbef5..f4dfd1f679a9 100644 --- a/drivers/net/sgiseeq.c +++ b/drivers/net/sgiseeq.c | |||
@@ -826,7 +826,7 @@ static int __exit sgiseeq_remove(struct platform_device *pdev) | |||
826 | 826 | ||
827 | static struct platform_driver sgiseeq_driver = { | 827 | static struct platform_driver sgiseeq_driver = { |
828 | .probe = sgiseeq_probe, | 828 | .probe = sgiseeq_probe, |
829 | .remove = __devexit_p(sgiseeq_remove), | 829 | .remove = __exit_p(sgiseeq_remove), |
830 | .driver = { | 830 | .driver = { |
831 | .name = "sgiseeq", | 831 | .name = "sgiseeq", |
832 | .owner = THIS_MODULE, | 832 | .owner = THIS_MODULE, |
diff --git a/drivers/net/skge.c b/drivers/net/skge.c index 55bad4081966..01f6811f1324 100644 --- a/drivers/net/skge.c +++ b/drivers/net/skge.c | |||
@@ -3935,11 +3935,14 @@ static int __devinit skge_probe(struct pci_dev *pdev, | |||
3935 | #endif | 3935 | #endif |
3936 | 3936 | ||
3937 | err = -ENOMEM; | 3937 | err = -ENOMEM; |
3938 | hw = kzalloc(sizeof(*hw), GFP_KERNEL); | 3938 | /* space for skge@pci:0000:04:00.0 */ |
3939 | hw = kzalloc(sizeof(*hw) + strlen(DRV_NAME "@pci:" ) | ||
3940 | + strlen(pci_name(pdev)) + 1, GFP_KERNEL); | ||
3939 | if (!hw) { | 3941 | if (!hw) { |
3940 | dev_err(&pdev->dev, "cannot allocate hardware struct\n"); | 3942 | dev_err(&pdev->dev, "cannot allocate hardware struct\n"); |
3941 | goto err_out_free_regions; | 3943 | goto err_out_free_regions; |
3942 | } | 3944 | } |
3945 | sprintf(hw->irq_name, DRV_NAME "@pci:%s", pci_name(pdev)); | ||
3943 | 3946 | ||
3944 | hw->pdev = pdev; | 3947 | hw->pdev = pdev; |
3945 | spin_lock_init(&hw->hw_lock); | 3948 | spin_lock_init(&hw->hw_lock); |
@@ -3974,7 +3977,7 @@ static int __devinit skge_probe(struct pci_dev *pdev, | |||
3974 | goto err_out_free_netdev; | 3977 | goto err_out_free_netdev; |
3975 | } | 3978 | } |
3976 | 3979 | ||
3977 | err = request_irq(pdev->irq, skge_intr, IRQF_SHARED, dev->name, hw); | 3980 | err = request_irq(pdev->irq, skge_intr, IRQF_SHARED, hw->irq_name, hw); |
3978 | if (err) { | 3981 | if (err) { |
3979 | dev_err(&pdev->dev, "%s: cannot assign irq %d\n", | 3982 | dev_err(&pdev->dev, "%s: cannot assign irq %d\n", |
3980 | dev->name, pdev->irq); | 3983 | dev->name, pdev->irq); |
@@ -3982,14 +3985,17 @@ static int __devinit skge_probe(struct pci_dev *pdev, | |||
3982 | } | 3985 | } |
3983 | skge_show_addr(dev); | 3986 | skge_show_addr(dev); |
3984 | 3987 | ||
3985 | if (hw->ports > 1 && (dev1 = skge_devinit(hw, 1, using_dac))) { | 3988 | if (hw->ports > 1) { |
3986 | if (register_netdev(dev1) == 0) | 3989 | dev1 = skge_devinit(hw, 1, using_dac); |
3990 | if (dev1 && register_netdev(dev1) == 0) | ||
3987 | skge_show_addr(dev1); | 3991 | skge_show_addr(dev1); |
3988 | else { | 3992 | else { |
3989 | /* Failure to register second port need not be fatal */ | 3993 | /* Failure to register second port need not be fatal */ |
3990 | dev_warn(&pdev->dev, "register of second port failed\n"); | 3994 | dev_warn(&pdev->dev, "register of second port failed\n"); |
3991 | hw->dev[1] = NULL; | 3995 | hw->dev[1] = NULL; |
3992 | free_netdev(dev1); | 3996 | hw->ports = 1; |
3997 | if (dev1) | ||
3998 | free_netdev(dev1); | ||
3993 | } | 3999 | } |
3994 | } | 4000 | } |
3995 | pci_set_drvdata(pdev, hw); | 4001 | pci_set_drvdata(pdev, hw); |
diff --git a/drivers/net/skge.h b/drivers/net/skge.h index 17caccbb7685..831de1b6e96e 100644 --- a/drivers/net/skge.h +++ b/drivers/net/skge.h | |||
@@ -2423,6 +2423,8 @@ struct skge_hw { | |||
2423 | u16 phy_addr; | 2423 | u16 phy_addr; |
2424 | spinlock_t phy_lock; | 2424 | spinlock_t phy_lock; |
2425 | struct tasklet_struct phy_task; | 2425 | struct tasklet_struct phy_task; |
2426 | |||
2427 | char irq_name[0]; /* skge@pci:000:04:00.0 */ | ||
2426 | }; | 2428 | }; |
2427 | 2429 | ||
2428 | enum pause_control { | 2430 | enum pause_control { |
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c index ef1165718dd7..2ab5c39f33ca 100644 --- a/drivers/net/sky2.c +++ b/drivers/net/sky2.c | |||
@@ -4487,13 +4487,16 @@ static int __devinit sky2_probe(struct pci_dev *pdev, | |||
4487 | wol_default = device_may_wakeup(&pdev->dev) ? WAKE_MAGIC : 0; | 4487 | wol_default = device_may_wakeup(&pdev->dev) ? WAKE_MAGIC : 0; |
4488 | 4488 | ||
4489 | err = -ENOMEM; | 4489 | err = -ENOMEM; |
4490 | hw = kzalloc(sizeof(*hw), GFP_KERNEL); | 4490 | |
4491 | hw = kzalloc(sizeof(*hw) + strlen(DRV_NAME "@pci:") | ||
4492 | + strlen(pci_name(pdev)) + 1, GFP_KERNEL); | ||
4491 | if (!hw) { | 4493 | if (!hw) { |
4492 | dev_err(&pdev->dev, "cannot allocate hardware struct\n"); | 4494 | dev_err(&pdev->dev, "cannot allocate hardware struct\n"); |
4493 | goto err_out_free_regions; | 4495 | goto err_out_free_regions; |
4494 | } | 4496 | } |
4495 | 4497 | ||
4496 | hw->pdev = pdev; | 4498 | hw->pdev = pdev; |
4499 | sprintf(hw->irq_name, DRV_NAME "@pci:%s", pci_name(pdev)); | ||
4497 | 4500 | ||
4498 | hw->regs = ioremap_nocache(pci_resource_start(pdev, 0), 0x4000); | 4501 | hw->regs = ioremap_nocache(pci_resource_start(pdev, 0), 0x4000); |
4499 | if (!hw->regs) { | 4502 | if (!hw->regs) { |
@@ -4539,7 +4542,7 @@ static int __devinit sky2_probe(struct pci_dev *pdev, | |||
4539 | 4542 | ||
4540 | err = request_irq(pdev->irq, sky2_intr, | 4543 | err = request_irq(pdev->irq, sky2_intr, |
4541 | (hw->flags & SKY2_HW_USE_MSI) ? 0 : IRQF_SHARED, | 4544 | (hw->flags & SKY2_HW_USE_MSI) ? 0 : IRQF_SHARED, |
4542 | dev->name, hw); | 4545 | hw->irq_name, hw); |
4543 | if (err) { | 4546 | if (err) { |
4544 | dev_err(&pdev->dev, "cannot assign irq %d\n", pdev->irq); | 4547 | dev_err(&pdev->dev, "cannot assign irq %d\n", pdev->irq); |
4545 | goto err_out_unregister; | 4548 | goto err_out_unregister; |
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h index e0f23a101043..ed54129698b4 100644 --- a/drivers/net/sky2.h +++ b/drivers/net/sky2.h | |||
@@ -2085,6 +2085,8 @@ struct sky2_hw { | |||
2085 | struct timer_list watchdog_timer; | 2085 | struct timer_list watchdog_timer; |
2086 | struct work_struct restart_work; | 2086 | struct work_struct restart_work; |
2087 | wait_queue_head_t msi_wait; | 2087 | wait_queue_head_t msi_wait; |
2088 | |||
2089 | char irq_name[0]; | ||
2088 | }; | 2090 | }; |
2089 | 2091 | ||
2090 | static inline int sky2_is_copper(const struct sky2_hw *hw) | 2092 | static inline int sky2_is_copper(const struct sky2_hw *hw) |
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c index f09bc5dfe8b2..ba5d3fe753b6 100644 --- a/drivers/net/tg3.c +++ b/drivers/net/tg3.c | |||
@@ -902,11 +902,12 @@ static int tg3_mdio_read(struct mii_bus *bp, int mii_id, int reg) | |||
902 | struct tg3 *tp = bp->priv; | 902 | struct tg3 *tp = bp->priv; |
903 | u32 val; | 903 | u32 val; |
904 | 904 | ||
905 | if (tp->tg3_flags3 & TG3_FLG3_MDIOBUS_PAUSED) | 905 | spin_lock_bh(&tp->lock); |
906 | return -EAGAIN; | ||
907 | 906 | ||
908 | if (tg3_readphy(tp, reg, &val)) | 907 | if (tg3_readphy(tp, reg, &val)) |
909 | return -EIO; | 908 | val = -EIO; |
909 | |||
910 | spin_unlock_bh(&tp->lock); | ||
910 | 911 | ||
911 | return val; | 912 | return val; |
912 | } | 913 | } |
@@ -914,14 +915,16 @@ static int tg3_mdio_read(struct mii_bus *bp, int mii_id, int reg) | |||
914 | static int tg3_mdio_write(struct mii_bus *bp, int mii_id, int reg, u16 val) | 915 | static int tg3_mdio_write(struct mii_bus *bp, int mii_id, int reg, u16 val) |
915 | { | 916 | { |
916 | struct tg3 *tp = bp->priv; | 917 | struct tg3 *tp = bp->priv; |
918 | u32 ret = 0; | ||
917 | 919 | ||
918 | if (tp->tg3_flags3 & TG3_FLG3_MDIOBUS_PAUSED) | 920 | spin_lock_bh(&tp->lock); |
919 | return -EAGAIN; | ||
920 | 921 | ||
921 | if (tg3_writephy(tp, reg, val)) | 922 | if (tg3_writephy(tp, reg, val)) |
922 | return -EIO; | 923 | ret = -EIO; |
923 | 924 | ||
924 | return 0; | 925 | spin_unlock_bh(&tp->lock); |
926 | |||
927 | return ret; | ||
925 | } | 928 | } |
926 | 929 | ||
927 | static int tg3_mdio_reset(struct mii_bus *bp) | 930 | static int tg3_mdio_reset(struct mii_bus *bp) |
@@ -1011,12 +1014,6 @@ static void tg3_mdio_config_5785(struct tg3 *tp) | |||
1011 | 1014 | ||
1012 | static void tg3_mdio_start(struct tg3 *tp) | 1015 | static void tg3_mdio_start(struct tg3 *tp) |
1013 | { | 1016 | { |
1014 | if (tp->tg3_flags3 & TG3_FLG3_MDIOBUS_INITED) { | ||
1015 | mutex_lock(&tp->mdio_bus->mdio_lock); | ||
1016 | tp->tg3_flags3 &= ~TG3_FLG3_MDIOBUS_PAUSED; | ||
1017 | mutex_unlock(&tp->mdio_bus->mdio_lock); | ||
1018 | } | ||
1019 | |||
1020 | tp->mi_mode &= ~MAC_MI_MODE_AUTO_POLL; | 1017 | tp->mi_mode &= ~MAC_MI_MODE_AUTO_POLL; |
1021 | tw32_f(MAC_MI_MODE, tp->mi_mode); | 1018 | tw32_f(MAC_MI_MODE, tp->mi_mode); |
1022 | udelay(80); | 1019 | udelay(80); |
@@ -1041,15 +1038,6 @@ static void tg3_mdio_start(struct tg3 *tp) | |||
1041 | tg3_mdio_config_5785(tp); | 1038 | tg3_mdio_config_5785(tp); |
1042 | } | 1039 | } |
1043 | 1040 | ||
1044 | static void tg3_mdio_stop(struct tg3 *tp) | ||
1045 | { | ||
1046 | if (tp->tg3_flags3 & TG3_FLG3_MDIOBUS_INITED) { | ||
1047 | mutex_lock(&tp->mdio_bus->mdio_lock); | ||
1048 | tp->tg3_flags3 |= TG3_FLG3_MDIOBUS_PAUSED; | ||
1049 | mutex_unlock(&tp->mdio_bus->mdio_lock); | ||
1050 | } | ||
1051 | } | ||
1052 | |||
1053 | static int tg3_mdio_init(struct tg3 *tp) | 1041 | static int tg3_mdio_init(struct tg3 *tp) |
1054 | { | 1042 | { |
1055 | int i; | 1043 | int i; |
@@ -1141,7 +1129,6 @@ static void tg3_mdio_fini(struct tg3 *tp) | |||
1141 | tp->tg3_flags3 &= ~TG3_FLG3_MDIOBUS_INITED; | 1129 | tp->tg3_flags3 &= ~TG3_FLG3_MDIOBUS_INITED; |
1142 | mdiobus_unregister(tp->mdio_bus); | 1130 | mdiobus_unregister(tp->mdio_bus); |
1143 | mdiobus_free(tp->mdio_bus); | 1131 | mdiobus_free(tp->mdio_bus); |
1144 | tp->tg3_flags3 &= ~TG3_FLG3_MDIOBUS_PAUSED; | ||
1145 | } | 1132 | } |
1146 | } | 1133 | } |
1147 | 1134 | ||
@@ -1363,7 +1350,7 @@ static void tg3_adjust_link(struct net_device *dev) | |||
1363 | struct tg3 *tp = netdev_priv(dev); | 1350 | struct tg3 *tp = netdev_priv(dev); |
1364 | struct phy_device *phydev = tp->mdio_bus->phy_map[PHY_ADDR]; | 1351 | struct phy_device *phydev = tp->mdio_bus->phy_map[PHY_ADDR]; |
1365 | 1352 | ||
1366 | spin_lock(&tp->lock); | 1353 | spin_lock_bh(&tp->lock); |
1367 | 1354 | ||
1368 | mac_mode = tp->mac_mode & ~(MAC_MODE_PORT_MODE_MASK | | 1355 | mac_mode = tp->mac_mode & ~(MAC_MODE_PORT_MODE_MASK | |
1369 | MAC_MODE_HALF_DUPLEX); | 1356 | MAC_MODE_HALF_DUPLEX); |
@@ -1431,7 +1418,7 @@ static void tg3_adjust_link(struct net_device *dev) | |||
1431 | tp->link_config.active_speed = phydev->speed; | 1418 | tp->link_config.active_speed = phydev->speed; |
1432 | tp->link_config.active_duplex = phydev->duplex; | 1419 | tp->link_config.active_duplex = phydev->duplex; |
1433 | 1420 | ||
1434 | spin_unlock(&tp->lock); | 1421 | spin_unlock_bh(&tp->lock); |
1435 | 1422 | ||
1436 | if (linkmesg) | 1423 | if (linkmesg) |
1437 | tg3_link_report(tp); | 1424 | tg3_link_report(tp); |
@@ -6392,8 +6379,6 @@ static int tg3_chip_reset(struct tg3 *tp) | |||
6392 | 6379 | ||
6393 | tg3_nvram_lock(tp); | 6380 | tg3_nvram_lock(tp); |
6394 | 6381 | ||
6395 | tg3_mdio_stop(tp); | ||
6396 | |||
6397 | tg3_ape_lock(tp, TG3_APE_LOCK_GRC); | 6382 | tg3_ape_lock(tp, TG3_APE_LOCK_GRC); |
6398 | 6383 | ||
6399 | /* No matching tg3_nvram_unlock() after this because | 6384 | /* No matching tg3_nvram_unlock() after this because |
@@ -8698,6 +8683,8 @@ static int tg3_close(struct net_device *dev) | |||
8698 | 8683 | ||
8699 | del_timer_sync(&tp->timer); | 8684 | del_timer_sync(&tp->timer); |
8700 | 8685 | ||
8686 | tg3_phy_stop(tp); | ||
8687 | |||
8701 | tg3_full_lock(tp, 1); | 8688 | tg3_full_lock(tp, 1); |
8702 | #if 0 | 8689 | #if 0 |
8703 | tg3_dump_state(tp); | 8690 | tg3_dump_state(tp); |
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h index 82b45d8797b4..bab7940158e6 100644 --- a/drivers/net/tg3.h +++ b/drivers/net/tg3.h | |||
@@ -2412,7 +2412,6 @@ struct ring_info { | |||
2412 | 2412 | ||
2413 | struct tx_ring_info { | 2413 | struct tx_ring_info { |
2414 | struct sk_buff *skb; | 2414 | struct sk_buff *skb; |
2415 | u32 prev_vlan_tag; | ||
2416 | }; | 2415 | }; |
2417 | 2416 | ||
2418 | struct tg3_config_info { | 2417 | struct tg3_config_info { |
@@ -2749,7 +2748,6 @@ struct tg3 { | |||
2749 | #define TG3_FLG3_5701_DMA_BUG 0x00000008 | 2748 | #define TG3_FLG3_5701_DMA_BUG 0x00000008 |
2750 | #define TG3_FLG3_USE_PHYLIB 0x00000010 | 2749 | #define TG3_FLG3_USE_PHYLIB 0x00000010 |
2751 | #define TG3_FLG3_MDIOBUS_INITED 0x00000020 | 2750 | #define TG3_FLG3_MDIOBUS_INITED 0x00000020 |
2752 | #define TG3_FLG3_MDIOBUS_PAUSED 0x00000040 | ||
2753 | #define TG3_FLG3_PHY_CONNECTED 0x00000080 | 2751 | #define TG3_FLG3_PHY_CONNECTED 0x00000080 |
2754 | #define TG3_FLG3_RGMII_STD_IBND_DISABLE 0x00000100 | 2752 | #define TG3_FLG3_RGMII_STD_IBND_DISABLE 0x00000100 |
2755 | #define TG3_FLG3_RGMII_EXT_IBND_RX_EN 0x00000200 | 2753 | #define TG3_FLG3_RGMII_EXT_IBND_RX_EN 0x00000200 |
diff --git a/drivers/net/usb/rndis_host.c b/drivers/net/usb/rndis_host.c index d032bba9bc4c..0caa8008c51c 100644 --- a/drivers/net/usb/rndis_host.c +++ b/drivers/net/usb/rndis_host.c | |||
@@ -418,6 +418,7 @@ generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags) | |||
418 | goto halt_fail_and_release; | 418 | goto halt_fail_and_release; |
419 | } | 419 | } |
420 | memcpy(net->dev_addr, bp, ETH_ALEN); | 420 | memcpy(net->dev_addr, bp, ETH_ALEN); |
421 | memcpy(net->perm_addr, bp, ETH_ALEN); | ||
421 | 422 | ||
422 | /* set a nonzero filter to enable data transfers */ | 423 | /* set a nonzero filter to enable data transfers */ |
423 | memset(u.set, 0, sizeof *u.set); | 424 | memset(u.set, 0, sizeof *u.set); |
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c index d445845f2779..8d009760277c 100644 --- a/drivers/net/virtio_net.c +++ b/drivers/net/virtio_net.c | |||
@@ -948,7 +948,7 @@ free: | |||
948 | return err; | 948 | return err; |
949 | } | 949 | } |
950 | 950 | ||
951 | static void virtnet_remove(struct virtio_device *vdev) | 951 | static void __devexit virtnet_remove(struct virtio_device *vdev) |
952 | { | 952 | { |
953 | struct virtnet_info *vi = vdev->priv; | 953 | struct virtnet_info *vi = vdev->priv; |
954 | struct sk_buff *skb; | 954 | struct sk_buff *skb; |
diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig index 49ea9c92b7e6..d7a764a2fc1a 100644 --- a/drivers/net/wireless/Kconfig +++ b/drivers/net/wireless/Kconfig | |||
@@ -31,13 +31,12 @@ config STRIP | |||
31 | ---help--- | 31 | ---help--- |
32 | Say Y if you have a Metricom radio and intend to use Starmode Radio | 32 | Say Y if you have a Metricom radio and intend to use Starmode Radio |
33 | IP. STRIP is a radio protocol developed for the MosquitoNet project | 33 | IP. STRIP is a radio protocol developed for the MosquitoNet project |
34 | (on the WWW at <http://mosquitonet.stanford.edu/>) to send Internet | 34 | to send Internet traffic using Metricom radios. Metricom radios are |
35 | traffic using Metricom radios. Metricom radios are small, battery | 35 | small, battery powered, 100kbit/sec packet radio transceivers, about |
36 | powered, 100kbit/sec packet radio transceivers, about the size and | 36 | the size and weight of a cellular telephone. (You may also have heard |
37 | weight of a cellular telephone. (You may also have heard them called | 37 | them called "Metricom modems" but we avoid the term "modem" because |
38 | "Metricom modems" but we avoid the term "modem" because it misleads | 38 | it misleads many people into thinking that you can plug a Metricom |
39 | many people into thinking that you can plug a Metricom modem into a | 39 | modem into a phone line and use it as a modem.) |
40 | phone line and use it as a modem.) | ||
41 | 40 | ||
42 | You can use STRIP on any Linux machine with a serial port, although | 41 | You can use STRIP on any Linux machine with a serial port, although |
43 | it is obviously most useful for people with laptop computers. If you | 42 | it is obviously most useful for people with laptop computers. If you |
diff --git a/drivers/net/wireless/ath/ar9170/phy.c b/drivers/net/wireless/ath/ar9170/phy.c index b3e5cf3735b0..dbd488da18b1 100644 --- a/drivers/net/wireless/ath/ar9170/phy.c +++ b/drivers/net/wireless/ath/ar9170/phy.c | |||
@@ -1141,7 +1141,8 @@ static int ar9170_set_freq_cal_data(struct ar9170 *ar, | |||
1141 | u8 vpds[2][AR5416_PD_GAIN_ICEPTS]; | 1141 | u8 vpds[2][AR5416_PD_GAIN_ICEPTS]; |
1142 | u8 pwrs[2][AR5416_PD_GAIN_ICEPTS]; | 1142 | u8 pwrs[2][AR5416_PD_GAIN_ICEPTS]; |
1143 | int chain, idx, i; | 1143 | int chain, idx, i; |
1144 | u8 f; | 1144 | u32 phy_data = 0; |
1145 | u8 f, tmp; | ||
1145 | 1146 | ||
1146 | switch (channel->band) { | 1147 | switch (channel->band) { |
1147 | case IEEE80211_BAND_2GHZ: | 1148 | case IEEE80211_BAND_2GHZ: |
@@ -1208,9 +1209,6 @@ static int ar9170_set_freq_cal_data(struct ar9170 *ar, | |||
1208 | } | 1209 | } |
1209 | 1210 | ||
1210 | for (i = 0; i < 76; i++) { | 1211 | for (i = 0; i < 76; i++) { |
1211 | u32 phy_data; | ||
1212 | u8 tmp; | ||
1213 | |||
1214 | if (i < 25) { | 1212 | if (i < 25) { |
1215 | tmp = ar9170_interpolate_val(i, &pwrs[0][0], | 1213 | tmp = ar9170_interpolate_val(i, &pwrs[0][0], |
1216 | &vpds[0][0]); | 1214 | &vpds[0][0]); |
diff --git a/drivers/net/wireless/b43/pio.c b/drivers/net/wireless/b43/pio.c index e96091b31499..9c1397996e0a 100644 --- a/drivers/net/wireless/b43/pio.c +++ b/drivers/net/wireless/b43/pio.c | |||
@@ -340,10 +340,15 @@ static u16 tx_write_2byte_queue(struct b43_pio_txqueue *q, | |||
340 | q->mmio_base + B43_PIO_TXDATA, | 340 | q->mmio_base + B43_PIO_TXDATA, |
341 | sizeof(u16)); | 341 | sizeof(u16)); |
342 | if (data_len & 1) { | 342 | if (data_len & 1) { |
343 | u8 tail[2] = { 0, }; | ||
344 | |||
343 | /* Write the last byte. */ | 345 | /* Write the last byte. */ |
344 | ctl &= ~B43_PIO_TXCTL_WRITEHI; | 346 | ctl &= ~B43_PIO_TXCTL_WRITEHI; |
345 | b43_piotx_write16(q, B43_PIO_TXCTL, ctl); | 347 | b43_piotx_write16(q, B43_PIO_TXCTL, ctl); |
346 | b43_piotx_write16(q, B43_PIO_TXDATA, data[data_len - 1]); | 348 | tail[0] = data[data_len - 1]; |
349 | ssb_block_write(dev->dev, tail, 2, | ||
350 | q->mmio_base + B43_PIO_TXDATA, | ||
351 | sizeof(u16)); | ||
347 | } | 352 | } |
348 | 353 | ||
349 | return ctl; | 354 | return ctl; |
@@ -386,26 +391,31 @@ static u32 tx_write_4byte_queue(struct b43_pio_txqueue *q, | |||
386 | q->mmio_base + B43_PIO8_TXDATA, | 391 | q->mmio_base + B43_PIO8_TXDATA, |
387 | sizeof(u32)); | 392 | sizeof(u32)); |
388 | if (data_len & 3) { | 393 | if (data_len & 3) { |
389 | u32 value = 0; | 394 | u8 tail[4] = { 0, }; |
390 | 395 | ||
391 | /* Write the last few bytes. */ | 396 | /* Write the last few bytes. */ |
392 | ctl &= ~(B43_PIO8_TXCTL_8_15 | B43_PIO8_TXCTL_16_23 | | 397 | ctl &= ~(B43_PIO8_TXCTL_8_15 | B43_PIO8_TXCTL_16_23 | |
393 | B43_PIO8_TXCTL_24_31); | 398 | B43_PIO8_TXCTL_24_31); |
394 | data = &(data[data_len - 1]); | ||
395 | switch (data_len & 3) { | 399 | switch (data_len & 3) { |
396 | case 3: | 400 | case 3: |
397 | ctl |= B43_PIO8_TXCTL_16_23; | 401 | ctl |= B43_PIO8_TXCTL_16_23 | B43_PIO8_TXCTL_8_15; |
398 | value |= (u32)(*data) << 16; | 402 | tail[0] = data[data_len - 3]; |
399 | data--; | 403 | tail[1] = data[data_len - 2]; |
404 | tail[2] = data[data_len - 1]; | ||
405 | break; | ||
400 | case 2: | 406 | case 2: |
401 | ctl |= B43_PIO8_TXCTL_8_15; | 407 | ctl |= B43_PIO8_TXCTL_8_15; |
402 | value |= (u32)(*data) << 8; | 408 | tail[0] = data[data_len - 2]; |
403 | data--; | 409 | tail[1] = data[data_len - 1]; |
410 | break; | ||
404 | case 1: | 411 | case 1: |
405 | value |= (u32)(*data); | 412 | tail[0] = data[data_len - 1]; |
413 | break; | ||
406 | } | 414 | } |
407 | b43_piotx_write32(q, B43_PIO8_TXCTL, ctl); | 415 | b43_piotx_write32(q, B43_PIO8_TXCTL, ctl); |
408 | b43_piotx_write32(q, B43_PIO8_TXDATA, value); | 416 | ssb_block_write(dev->dev, tail, 4, |
417 | q->mmio_base + B43_PIO8_TXDATA, | ||
418 | sizeof(u32)); | ||
409 | } | 419 | } |
410 | 420 | ||
411 | return ctl; | 421 | return ctl; |
@@ -693,21 +703,25 @@ data_ready: | |||
693 | q->mmio_base + B43_PIO8_RXDATA, | 703 | q->mmio_base + B43_PIO8_RXDATA, |
694 | sizeof(u32)); | 704 | sizeof(u32)); |
695 | if (len & 3) { | 705 | if (len & 3) { |
696 | u32 value; | 706 | u8 tail[4] = { 0, }; |
697 | char *data; | ||
698 | 707 | ||
699 | /* Read the last few bytes. */ | 708 | /* Read the last few bytes. */ |
700 | value = b43_piorx_read32(q, B43_PIO8_RXDATA); | 709 | ssb_block_read(dev->dev, tail, 4, |
701 | data = &(skb->data[len + padding - 1]); | 710 | q->mmio_base + B43_PIO8_RXDATA, |
711 | sizeof(u32)); | ||
702 | switch (len & 3) { | 712 | switch (len & 3) { |
703 | case 3: | 713 | case 3: |
704 | *data = (value >> 16); | 714 | skb->data[len + padding - 3] = tail[0]; |
705 | data--; | 715 | skb->data[len + padding - 2] = tail[1]; |
716 | skb->data[len + padding - 1] = tail[2]; | ||
717 | break; | ||
706 | case 2: | 718 | case 2: |
707 | *data = (value >> 8); | 719 | skb->data[len + padding - 2] = tail[0]; |
708 | data--; | 720 | skb->data[len + padding - 1] = tail[1]; |
721 | break; | ||
709 | case 1: | 722 | case 1: |
710 | *data = value; | 723 | skb->data[len + padding - 1] = tail[0]; |
724 | break; | ||
711 | } | 725 | } |
712 | } | 726 | } |
713 | } else { | 727 | } else { |
@@ -715,11 +729,13 @@ data_ready: | |||
715 | q->mmio_base + B43_PIO_RXDATA, | 729 | q->mmio_base + B43_PIO_RXDATA, |
716 | sizeof(u16)); | 730 | sizeof(u16)); |
717 | if (len & 1) { | 731 | if (len & 1) { |
718 | u16 value; | 732 | u8 tail[2] = { 0, }; |
719 | 733 | ||
720 | /* Read the last byte. */ | 734 | /* Read the last byte. */ |
721 | value = b43_piorx_read16(q, B43_PIO_RXDATA); | 735 | ssb_block_read(dev->dev, tail, 2, |
722 | skb->data[len + padding - 1] = value; | 736 | q->mmio_base + B43_PIO_RXDATA, |
737 | sizeof(u16)); | ||
738 | skb->data[len + padding - 1] = tail[0]; | ||
723 | } | 739 | } |
724 | } | 740 | } |
725 | 741 | ||
diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c index 896f532182f0..38cfd79e0590 100644 --- a/drivers/net/wireless/mac80211_hwsim.c +++ b/drivers/net/wireless/mac80211_hwsim.c | |||
@@ -631,6 +631,9 @@ static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw, | |||
631 | data->beacon_int = 1024 * info->beacon_int / 1000 * HZ / 1000; | 631 | data->beacon_int = 1024 * info->beacon_int / 1000 * HZ / 1000; |
632 | if (WARN_ON(!data->beacon_int)) | 632 | if (WARN_ON(!data->beacon_int)) |
633 | data->beacon_int = 1; | 633 | data->beacon_int = 1; |
634 | if (data->started) | ||
635 | mod_timer(&data->beacon_timer, | ||
636 | jiffies + data->beacon_int); | ||
634 | } | 637 | } |
635 | 638 | ||
636 | if (changed & BSS_CHANGED_ERP_CTS_PROT) { | 639 | if (changed & BSS_CHANGED_ERP_CTS_PROT) { |
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c index 1cbd9b4a3efc..b8f5ee33445e 100644 --- a/drivers/net/wireless/rt2x00/rt73usb.c +++ b/drivers/net/wireless/rt2x00/rt73usb.c | |||
@@ -2381,6 +2381,7 @@ static struct usb_device_id rt73usb_device_table[] = { | |||
2381 | /* Huawei-3Com */ | 2381 | /* Huawei-3Com */ |
2382 | { USB_DEVICE(0x1472, 0x0009), USB_DEVICE_DATA(&rt73usb_ops) }, | 2382 | { USB_DEVICE(0x1472, 0x0009), USB_DEVICE_DATA(&rt73usb_ops) }, |
2383 | /* Hercules */ | 2383 | /* Hercules */ |
2384 | { USB_DEVICE(0x06f8, 0xe002), USB_DEVICE_DATA(&rt73usb_ops) }, | ||
2384 | { USB_DEVICE(0x06f8, 0xe010), USB_DEVICE_DATA(&rt73usb_ops) }, | 2385 | { USB_DEVICE(0x06f8, 0xe010), USB_DEVICE_DATA(&rt73usb_ops) }, |
2385 | { USB_DEVICE(0x06f8, 0xe020), USB_DEVICE_DATA(&rt73usb_ops) }, | 2386 | { USB_DEVICE(0x06f8, 0xe020), USB_DEVICE_DATA(&rt73usb_ops) }, |
2386 | /* Linksys */ | 2387 | /* Linksys */ |
diff --git a/drivers/pcmcia/sa1100_assabet.c b/drivers/pcmcia/sa1100_assabet.c index f424146a2bc9..ac8aa09ba0da 100644 --- a/drivers/pcmcia/sa1100_assabet.c +++ b/drivers/pcmcia/sa1100_assabet.c | |||
@@ -130,7 +130,7 @@ static struct pcmcia_low_level assabet_pcmcia_ops = { | |||
130 | .socket_suspend = assabet_pcmcia_socket_suspend, | 130 | .socket_suspend = assabet_pcmcia_socket_suspend, |
131 | }; | 131 | }; |
132 | 132 | ||
133 | int __init pcmcia_assabet_init(struct device *dev) | 133 | int pcmcia_assabet_init(struct device *dev) |
134 | { | 134 | { |
135 | int ret = -ENODEV; | 135 | int ret = -ENODEV; |
136 | 136 | ||
diff --git a/drivers/pcmcia/sa1100_neponset.c b/drivers/pcmcia/sa1100_neponset.c index 4c41e86ccff9..0c76d337815b 100644 --- a/drivers/pcmcia/sa1100_neponset.c +++ b/drivers/pcmcia/sa1100_neponset.c | |||
@@ -123,7 +123,7 @@ static struct pcmcia_low_level neponset_pcmcia_ops = { | |||
123 | .socket_suspend = sa1111_pcmcia_socket_suspend, | 123 | .socket_suspend = sa1111_pcmcia_socket_suspend, |
124 | }; | 124 | }; |
125 | 125 | ||
126 | int __init pcmcia_neponset_init(struct sa1111_dev *sadev) | 126 | int pcmcia_neponset_init(struct sa1111_dev *sadev) |
127 | { | 127 | { |
128 | int ret = -ENODEV; | 128 | int ret = -ENODEV; |
129 | 129 | ||
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c index afdbdaaf80cb..a2a742c8ff7e 100644 --- a/drivers/platform/x86/sony-laptop.c +++ b/drivers/platform/x86/sony-laptop.c | |||
@@ -1211,15 +1211,6 @@ static int sony_nc_add(struct acpi_device *device) | |||
1211 | } | 1211 | } |
1212 | } | 1212 | } |
1213 | 1213 | ||
1214 | /* try to _INI the device if such method exists (ACPI spec 3.0-6.5.1 | ||
1215 | * should be respected as we already checked for the device presence above */ | ||
1216 | if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, METHOD_NAME__INI, &handle))) { | ||
1217 | dprintk("Invoking _INI\n"); | ||
1218 | if (ACPI_FAILURE(acpi_evaluate_object(sony_nc_acpi_handle, METHOD_NAME__INI, | ||
1219 | NULL, NULL))) | ||
1220 | dprintk("_INI Method failed\n"); | ||
1221 | } | ||
1222 | |||
1223 | if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "ECON", | 1214 | if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "ECON", |
1224 | &handle))) { | 1215 | &handle))) { |
1225 | if (acpi_callsetfunc(sony_nc_acpi_handle, "ECON", 1, NULL)) | 1216 | if (acpi_callsetfunc(sony_nc_acpi_handle, "ECON", 1, NULL)) |
@@ -1399,27 +1390,20 @@ struct sonypi_eventtypes { | |||
1399 | struct sonypi_event *events; | 1390 | struct sonypi_event *events; |
1400 | }; | 1391 | }; |
1401 | 1392 | ||
1402 | struct device_ctrl { | 1393 | struct sony_pic_dev { |
1394 | struct acpi_device *acpi_dev; | ||
1395 | struct sony_pic_irq *cur_irq; | ||
1396 | struct sony_pic_ioport *cur_ioport; | ||
1397 | struct list_head interrupts; | ||
1398 | struct list_head ioports; | ||
1399 | struct mutex lock; | ||
1400 | struct sonypi_eventtypes *event_types; | ||
1401 | int (*handle_irq)(const u8, const u8); | ||
1403 | int model; | 1402 | int model; |
1404 | int (*handle_irq)(const u8, const u8); | ||
1405 | u16 evport_offset; | 1403 | u16 evport_offset; |
1406 | u8 has_camera; | 1404 | u8 camera_power; |
1407 | u8 has_bluetooth; | 1405 | u8 bluetooth_power; |
1408 | u8 has_wwan; | 1406 | u8 wwan_power; |
1409 | struct sonypi_eventtypes *event_types; | ||
1410 | }; | ||
1411 | |||
1412 | struct sony_pic_dev { | ||
1413 | struct device_ctrl *control; | ||
1414 | struct acpi_device *acpi_dev; | ||
1415 | struct sony_pic_irq *cur_irq; | ||
1416 | struct sony_pic_ioport *cur_ioport; | ||
1417 | struct list_head interrupts; | ||
1418 | struct list_head ioports; | ||
1419 | struct mutex lock; | ||
1420 | u8 camera_power; | ||
1421 | u8 bluetooth_power; | ||
1422 | u8 wwan_power; | ||
1423 | }; | 1407 | }; |
1424 | 1408 | ||
1425 | static struct sony_pic_dev spic_dev = { | 1409 | static struct sony_pic_dev spic_dev = { |
@@ -1427,6 +1411,8 @@ static struct sony_pic_dev spic_dev = { | |||
1427 | .ioports = LIST_HEAD_INIT(spic_dev.ioports), | 1411 | .ioports = LIST_HEAD_INIT(spic_dev.ioports), |
1428 | }; | 1412 | }; |
1429 | 1413 | ||
1414 | static int spic_drv_registered; | ||
1415 | |||
1430 | /* Event masks */ | 1416 | /* Event masks */ |
1431 | #define SONYPI_JOGGER_MASK 0x00000001 | 1417 | #define SONYPI_JOGGER_MASK 0x00000001 |
1432 | #define SONYPI_CAPTURE_MASK 0x00000002 | 1418 | #define SONYPI_CAPTURE_MASK 0x00000002 |
@@ -1724,27 +1710,6 @@ static int type3_handle_irq(const u8 data_mask, const u8 ev) | |||
1724 | return 1; | 1710 | return 1; |
1725 | } | 1711 | } |
1726 | 1712 | ||
1727 | static struct device_ctrl spic_types[] = { | ||
1728 | { | ||
1729 | .model = SONYPI_DEVICE_TYPE1, | ||
1730 | .handle_irq = NULL, | ||
1731 | .evport_offset = SONYPI_TYPE1_OFFSET, | ||
1732 | .event_types = type1_events, | ||
1733 | }, | ||
1734 | { | ||
1735 | .model = SONYPI_DEVICE_TYPE2, | ||
1736 | .handle_irq = NULL, | ||
1737 | .evport_offset = SONYPI_TYPE2_OFFSET, | ||
1738 | .event_types = type2_events, | ||
1739 | }, | ||
1740 | { | ||
1741 | .model = SONYPI_DEVICE_TYPE3, | ||
1742 | .handle_irq = type3_handle_irq, | ||
1743 | .evport_offset = SONYPI_TYPE3_OFFSET, | ||
1744 | .event_types = type3_events, | ||
1745 | }, | ||
1746 | }; | ||
1747 | |||
1748 | static void sony_pic_detect_device_type(struct sony_pic_dev *dev) | 1713 | static void sony_pic_detect_device_type(struct sony_pic_dev *dev) |
1749 | { | 1714 | { |
1750 | struct pci_dev *pcidev; | 1715 | struct pci_dev *pcidev; |
@@ -1752,48 +1717,63 @@ static void sony_pic_detect_device_type(struct sony_pic_dev *dev) | |||
1752 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, | 1717 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, |
1753 | PCI_DEVICE_ID_INTEL_82371AB_3, NULL); | 1718 | PCI_DEVICE_ID_INTEL_82371AB_3, NULL); |
1754 | if (pcidev) { | 1719 | if (pcidev) { |
1755 | dev->control = &spic_types[0]; | 1720 | dev->model = SONYPI_DEVICE_TYPE1; |
1721 | dev->evport_offset = SONYPI_TYPE1_OFFSET; | ||
1722 | dev->event_types = type1_events; | ||
1756 | goto out; | 1723 | goto out; |
1757 | } | 1724 | } |
1758 | 1725 | ||
1759 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, | 1726 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, |
1760 | PCI_DEVICE_ID_INTEL_ICH6_1, NULL); | 1727 | PCI_DEVICE_ID_INTEL_ICH6_1, NULL); |
1761 | if (pcidev) { | 1728 | if (pcidev) { |
1762 | dev->control = &spic_types[2]; | 1729 | dev->model = SONYPI_DEVICE_TYPE2; |
1730 | dev->evport_offset = SONYPI_TYPE2_OFFSET; | ||
1731 | dev->event_types = type2_events; | ||
1763 | goto out; | 1732 | goto out; |
1764 | } | 1733 | } |
1765 | 1734 | ||
1766 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, | 1735 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, |
1767 | PCI_DEVICE_ID_INTEL_ICH7_1, NULL); | 1736 | PCI_DEVICE_ID_INTEL_ICH7_1, NULL); |
1768 | if (pcidev) { | 1737 | if (pcidev) { |
1769 | dev->control = &spic_types[2]; | 1738 | dev->model = SONYPI_DEVICE_TYPE3; |
1739 | dev->handle_irq = type3_handle_irq; | ||
1740 | dev->evport_offset = SONYPI_TYPE3_OFFSET; | ||
1741 | dev->event_types = type3_events; | ||
1770 | goto out; | 1742 | goto out; |
1771 | } | 1743 | } |
1772 | 1744 | ||
1773 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, | 1745 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, |
1774 | PCI_DEVICE_ID_INTEL_ICH8_4, NULL); | 1746 | PCI_DEVICE_ID_INTEL_ICH8_4, NULL); |
1775 | if (pcidev) { | 1747 | if (pcidev) { |
1776 | dev->control = &spic_types[2]; | 1748 | dev->model = SONYPI_DEVICE_TYPE3; |
1749 | dev->handle_irq = type3_handle_irq; | ||
1750 | dev->evport_offset = SONYPI_TYPE3_OFFSET; | ||
1751 | dev->event_types = type3_events; | ||
1777 | goto out; | 1752 | goto out; |
1778 | } | 1753 | } |
1779 | 1754 | ||
1780 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, | 1755 | pcidev = pci_get_device(PCI_VENDOR_ID_INTEL, |
1781 | PCI_DEVICE_ID_INTEL_ICH9_1, NULL); | 1756 | PCI_DEVICE_ID_INTEL_ICH9_1, NULL); |
1782 | if (pcidev) { | 1757 | if (pcidev) { |
1783 | dev->control = &spic_types[2]; | 1758 | dev->model = SONYPI_DEVICE_TYPE3; |
1759 | dev->handle_irq = type3_handle_irq; | ||
1760 | dev->evport_offset = SONYPI_TYPE3_OFFSET; | ||
1761 | dev->event_types = type3_events; | ||
1784 | goto out; | 1762 | goto out; |
1785 | } | 1763 | } |
1786 | 1764 | ||
1787 | /* default */ | 1765 | /* default */ |
1788 | dev->control = &spic_types[1]; | 1766 | dev->model = SONYPI_DEVICE_TYPE2; |
1767 | dev->evport_offset = SONYPI_TYPE2_OFFSET; | ||
1768 | dev->event_types = type2_events; | ||
1789 | 1769 | ||
1790 | out: | 1770 | out: |
1791 | if (pcidev) | 1771 | if (pcidev) |
1792 | pci_dev_put(pcidev); | 1772 | pci_dev_put(pcidev); |
1793 | 1773 | ||
1794 | printk(KERN_INFO DRV_PFX "detected Type%d model\n", | 1774 | printk(KERN_INFO DRV_PFX "detected Type%d model\n", |
1795 | dev->control->model == SONYPI_DEVICE_TYPE1 ? 1 : | 1775 | dev->model == SONYPI_DEVICE_TYPE1 ? 1 : |
1796 | dev->control->model == SONYPI_DEVICE_TYPE2 ? 2 : 3); | 1776 | dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3); |
1797 | } | 1777 | } |
1798 | 1778 | ||
1799 | /* camera tests and poweron/poweroff */ | 1779 | /* camera tests and poweron/poweroff */ |
@@ -2566,7 +2546,7 @@ static int sony_pic_enable(struct acpi_device *device, | |||
2566 | buffer.pointer = resource; | 2546 | buffer.pointer = resource; |
2567 | 2547 | ||
2568 | /* setup Type 1 resources */ | 2548 | /* setup Type 1 resources */ |
2569 | if (spic_dev.control->model == SONYPI_DEVICE_TYPE1) { | 2549 | if (spic_dev.model == SONYPI_DEVICE_TYPE1) { |
2570 | 2550 | ||
2571 | /* setup io resources */ | 2551 | /* setup io resources */ |
2572 | resource->res1.type = ACPI_RESOURCE_TYPE_IO; | 2552 | resource->res1.type = ACPI_RESOURCE_TYPE_IO; |
@@ -2649,29 +2629,28 @@ static irqreturn_t sony_pic_irq(int irq, void *dev_id) | |||
2649 | data_mask = inb_p(dev->cur_ioport->io2.minimum); | 2629 | data_mask = inb_p(dev->cur_ioport->io2.minimum); |
2650 | else | 2630 | else |
2651 | data_mask = inb_p(dev->cur_ioport->io1.minimum + | 2631 | data_mask = inb_p(dev->cur_ioport->io1.minimum + |
2652 | dev->control->evport_offset); | 2632 | dev->evport_offset); |
2653 | 2633 | ||
2654 | dprintk("event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n", | 2634 | dprintk("event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n", |
2655 | ev, data_mask, dev->cur_ioport->io1.minimum, | 2635 | ev, data_mask, dev->cur_ioport->io1.minimum, |
2656 | dev->control->evport_offset); | 2636 | dev->evport_offset); |
2657 | 2637 | ||
2658 | if (ev == 0x00 || ev == 0xff) | 2638 | if (ev == 0x00 || ev == 0xff) |
2659 | return IRQ_HANDLED; | 2639 | return IRQ_HANDLED; |
2660 | 2640 | ||
2661 | for (i = 0; dev->control->event_types[i].mask; i++) { | 2641 | for (i = 0; dev->event_types[i].mask; i++) { |
2662 | 2642 | ||
2663 | if ((data_mask & dev->control->event_types[i].data) != | 2643 | if ((data_mask & dev->event_types[i].data) != |
2664 | dev->control->event_types[i].data) | 2644 | dev->event_types[i].data) |
2665 | continue; | 2645 | continue; |
2666 | 2646 | ||
2667 | if (!(mask & dev->control->event_types[i].mask)) | 2647 | if (!(mask & dev->event_types[i].mask)) |
2668 | continue; | 2648 | continue; |
2669 | 2649 | ||
2670 | for (j = 0; dev->control->event_types[i].events[j].event; j++) { | 2650 | for (j = 0; dev->event_types[i].events[j].event; j++) { |
2671 | if (ev == dev->control->event_types[i].events[j].data) { | 2651 | if (ev == dev->event_types[i].events[j].data) { |
2672 | device_event = | 2652 | device_event = |
2673 | dev->control-> | 2653 | dev->event_types[i].events[j].event; |
2674 | event_types[i].events[j].event; | ||
2675 | goto found; | 2654 | goto found; |
2676 | } | 2655 | } |
2677 | } | 2656 | } |
@@ -2679,13 +2658,12 @@ static irqreturn_t sony_pic_irq(int irq, void *dev_id) | |||
2679 | /* Still not able to decode the event try to pass | 2658 | /* Still not able to decode the event try to pass |
2680 | * it over to the minidriver | 2659 | * it over to the minidriver |
2681 | */ | 2660 | */ |
2682 | if (dev->control->handle_irq && | 2661 | if (dev->handle_irq && dev->handle_irq(data_mask, ev) == 0) |
2683 | dev->control->handle_irq(data_mask, ev) == 0) | ||
2684 | return IRQ_HANDLED; | 2662 | return IRQ_HANDLED; |
2685 | 2663 | ||
2686 | dprintk("unknown event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n", | 2664 | dprintk("unknown event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n", |
2687 | ev, data_mask, dev->cur_ioport->io1.minimum, | 2665 | ev, data_mask, dev->cur_ioport->io1.minimum, |
2688 | dev->control->evport_offset); | 2666 | dev->evport_offset); |
2689 | return IRQ_HANDLED; | 2667 | return IRQ_HANDLED; |
2690 | 2668 | ||
2691 | found: | 2669 | found: |
@@ -2816,7 +2794,7 @@ static int sony_pic_add(struct acpi_device *device) | |||
2816 | /* request IRQ */ | 2794 | /* request IRQ */ |
2817 | list_for_each_entry_reverse(irq, &spic_dev.interrupts, list) { | 2795 | list_for_each_entry_reverse(irq, &spic_dev.interrupts, list) { |
2818 | if (!request_irq(irq->irq.interrupts[0], sony_pic_irq, | 2796 | if (!request_irq(irq->irq.interrupts[0], sony_pic_irq, |
2819 | IRQF_SHARED, "sony-laptop", &spic_dev)) { | 2797 | IRQF_DISABLED, "sony-laptop", &spic_dev)) { |
2820 | dprintk("IRQ: %d - triggering: %d - " | 2798 | dprintk("IRQ: %d - triggering: %d - " |
2821 | "polarity: %d - shr: %d\n", | 2799 | "polarity: %d - shr: %d\n", |
2822 | irq->irq.interrupts[0], | 2800 | irq->irq.interrupts[0], |
@@ -2949,6 +2927,7 @@ static int __init sony_laptop_init(void) | |||
2949 | "Unable to register SPIC driver."); | 2927 | "Unable to register SPIC driver."); |
2950 | goto out; | 2928 | goto out; |
2951 | } | 2929 | } |
2930 | spic_drv_registered = 1; | ||
2952 | } | 2931 | } |
2953 | 2932 | ||
2954 | result = acpi_bus_register_driver(&sony_nc_driver); | 2933 | result = acpi_bus_register_driver(&sony_nc_driver); |
@@ -2960,7 +2939,7 @@ static int __init sony_laptop_init(void) | |||
2960 | return 0; | 2939 | return 0; |
2961 | 2940 | ||
2962 | out_unregister_pic: | 2941 | out_unregister_pic: |
2963 | if (!no_spic) | 2942 | if (spic_drv_registered) |
2964 | acpi_bus_unregister_driver(&sony_pic_driver); | 2943 | acpi_bus_unregister_driver(&sony_pic_driver); |
2965 | out: | 2944 | out: |
2966 | return result; | 2945 | return result; |
@@ -2969,7 +2948,7 @@ out: | |||
2969 | static void __exit sony_laptop_exit(void) | 2948 | static void __exit sony_laptop_exit(void) |
2970 | { | 2949 | { |
2971 | acpi_bus_unregister_driver(&sony_nc_driver); | 2950 | acpi_bus_unregister_driver(&sony_nc_driver); |
2972 | if (!no_spic) | 2951 | if (spic_drv_registered) |
2973 | acpi_bus_unregister_driver(&sony_pic_driver); | 2952 | acpi_bus_unregister_driver(&sony_pic_driver); |
2974 | } | 2953 | } |
2975 | 2954 | ||
diff --git a/drivers/s390/cio/qdio_debug.c b/drivers/s390/cio/qdio_debug.c index 1b78f639ead3..76769978285f 100644 --- a/drivers/s390/cio/qdio_debug.c +++ b/drivers/s390/cio/qdio_debug.c | |||
@@ -125,7 +125,7 @@ static int qstat_seq_open(struct inode *inode, struct file *filp) | |||
125 | filp->f_path.dentry->d_inode->i_private); | 125 | filp->f_path.dentry->d_inode->i_private); |
126 | } | 126 | } |
127 | 127 | ||
128 | static struct file_operations debugfs_fops = { | 128 | static const struct file_operations debugfs_fops = { |
129 | .owner = THIS_MODULE, | 129 | .owner = THIS_MODULE, |
130 | .open = qstat_seq_open, | 130 | .open = qstat_seq_open, |
131 | .read = seq_read, | 131 | .read = seq_read, |
diff --git a/drivers/s390/cio/qdio_perf.c b/drivers/s390/cio/qdio_perf.c index eff943923c6f..968e3c7c2632 100644 --- a/drivers/s390/cio/qdio_perf.c +++ b/drivers/s390/cio/qdio_perf.c | |||
@@ -84,7 +84,7 @@ static int qdio_perf_seq_open(struct inode *inode, struct file *filp) | |||
84 | return single_open(filp, qdio_perf_proc_show, NULL); | 84 | return single_open(filp, qdio_perf_proc_show, NULL); |
85 | } | 85 | } |
86 | 86 | ||
87 | static struct file_operations qdio_perf_proc_fops = { | 87 | static const struct file_operations qdio_perf_proc_fops = { |
88 | .owner = THIS_MODULE, | 88 | .owner = THIS_MODULE, |
89 | .open = qdio_perf_seq_open, | 89 | .open = qdio_perf_seq_open, |
90 | .read = seq_read, | 90 | .read = seq_read, |
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c index 0cb049f5cc56..747a5e5c1276 100644 --- a/drivers/scsi/sg.c +++ b/drivers/scsi/sg.c | |||
@@ -1317,7 +1317,7 @@ static void sg_rq_end_io(struct request *rq, int uptodate) | |||
1317 | } | 1317 | } |
1318 | } | 1318 | } |
1319 | 1319 | ||
1320 | static struct file_operations sg_fops = { | 1320 | static const struct file_operations sg_fops = { |
1321 | .owner = THIS_MODULE, | 1321 | .owner = THIS_MODULE, |
1322 | .read = sg_read, | 1322 | .read = sg_read, |
1323 | .write = sg_write, | 1323 | .write = sg_write, |
@@ -2194,9 +2194,11 @@ static int sg_proc_seq_show_int(struct seq_file *s, void *v); | |||
2194 | static int sg_proc_single_open_adio(struct inode *inode, struct file *file); | 2194 | static int sg_proc_single_open_adio(struct inode *inode, struct file *file); |
2195 | static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer, | 2195 | static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer, |
2196 | size_t count, loff_t *off); | 2196 | size_t count, loff_t *off); |
2197 | static struct file_operations adio_fops = { | 2197 | static const struct file_operations adio_fops = { |
2198 | /* .owner, .read and .llseek added in sg_proc_init() */ | 2198 | .owner = THIS_MODULE, |
2199 | .open = sg_proc_single_open_adio, | 2199 | .open = sg_proc_single_open_adio, |
2200 | .read = seq_read, | ||
2201 | .llseek = seq_lseek, | ||
2200 | .write = sg_proc_write_adio, | 2202 | .write = sg_proc_write_adio, |
2201 | .release = single_release, | 2203 | .release = single_release, |
2202 | }; | 2204 | }; |
@@ -2204,23 +2206,32 @@ static struct file_operations adio_fops = { | |||
2204 | static int sg_proc_single_open_dressz(struct inode *inode, struct file *file); | 2206 | static int sg_proc_single_open_dressz(struct inode *inode, struct file *file); |
2205 | static ssize_t sg_proc_write_dressz(struct file *filp, | 2207 | static ssize_t sg_proc_write_dressz(struct file *filp, |
2206 | const char __user *buffer, size_t count, loff_t *off); | 2208 | const char __user *buffer, size_t count, loff_t *off); |
2207 | static struct file_operations dressz_fops = { | 2209 | static const struct file_operations dressz_fops = { |
2210 | .owner = THIS_MODULE, | ||
2208 | .open = sg_proc_single_open_dressz, | 2211 | .open = sg_proc_single_open_dressz, |
2212 | .read = seq_read, | ||
2213 | .llseek = seq_lseek, | ||
2209 | .write = sg_proc_write_dressz, | 2214 | .write = sg_proc_write_dressz, |
2210 | .release = single_release, | 2215 | .release = single_release, |
2211 | }; | 2216 | }; |
2212 | 2217 | ||
2213 | static int sg_proc_seq_show_version(struct seq_file *s, void *v); | 2218 | static int sg_proc_seq_show_version(struct seq_file *s, void *v); |
2214 | static int sg_proc_single_open_version(struct inode *inode, struct file *file); | 2219 | static int sg_proc_single_open_version(struct inode *inode, struct file *file); |
2215 | static struct file_operations version_fops = { | 2220 | static const struct file_operations version_fops = { |
2221 | .owner = THIS_MODULE, | ||
2216 | .open = sg_proc_single_open_version, | 2222 | .open = sg_proc_single_open_version, |
2223 | .read = seq_read, | ||
2224 | .llseek = seq_lseek, | ||
2217 | .release = single_release, | 2225 | .release = single_release, |
2218 | }; | 2226 | }; |
2219 | 2227 | ||
2220 | static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v); | 2228 | static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v); |
2221 | static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file); | 2229 | static int sg_proc_single_open_devhdr(struct inode *inode, struct file *file); |
2222 | static struct file_operations devhdr_fops = { | 2230 | static const struct file_operations devhdr_fops = { |
2231 | .owner = THIS_MODULE, | ||
2223 | .open = sg_proc_single_open_devhdr, | 2232 | .open = sg_proc_single_open_devhdr, |
2233 | .read = seq_read, | ||
2234 | .llseek = seq_lseek, | ||
2224 | .release = single_release, | 2235 | .release = single_release, |
2225 | }; | 2236 | }; |
2226 | 2237 | ||
@@ -2229,8 +2240,11 @@ static int sg_proc_open_dev(struct inode *inode, struct file *file); | |||
2229 | static void * dev_seq_start(struct seq_file *s, loff_t *pos); | 2240 | static void * dev_seq_start(struct seq_file *s, loff_t *pos); |
2230 | static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos); | 2241 | static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos); |
2231 | static void dev_seq_stop(struct seq_file *s, void *v); | 2242 | static void dev_seq_stop(struct seq_file *s, void *v); |
2232 | static struct file_operations dev_fops = { | 2243 | static const struct file_operations dev_fops = { |
2244 | .owner = THIS_MODULE, | ||
2233 | .open = sg_proc_open_dev, | 2245 | .open = sg_proc_open_dev, |
2246 | .read = seq_read, | ||
2247 | .llseek = seq_lseek, | ||
2234 | .release = seq_release, | 2248 | .release = seq_release, |
2235 | }; | 2249 | }; |
2236 | static const struct seq_operations dev_seq_ops = { | 2250 | static const struct seq_operations dev_seq_ops = { |
@@ -2242,8 +2256,11 @@ static const struct seq_operations dev_seq_ops = { | |||
2242 | 2256 | ||
2243 | static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v); | 2257 | static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v); |
2244 | static int sg_proc_open_devstrs(struct inode *inode, struct file *file); | 2258 | static int sg_proc_open_devstrs(struct inode *inode, struct file *file); |
2245 | static struct file_operations devstrs_fops = { | 2259 | static const struct file_operations devstrs_fops = { |
2260 | .owner = THIS_MODULE, | ||
2246 | .open = sg_proc_open_devstrs, | 2261 | .open = sg_proc_open_devstrs, |
2262 | .read = seq_read, | ||
2263 | .llseek = seq_lseek, | ||
2247 | .release = seq_release, | 2264 | .release = seq_release, |
2248 | }; | 2265 | }; |
2249 | static const struct seq_operations devstrs_seq_ops = { | 2266 | static const struct seq_operations devstrs_seq_ops = { |
@@ -2255,8 +2272,11 @@ static const struct seq_operations devstrs_seq_ops = { | |||
2255 | 2272 | ||
2256 | static int sg_proc_seq_show_debug(struct seq_file *s, void *v); | 2273 | static int sg_proc_seq_show_debug(struct seq_file *s, void *v); |
2257 | static int sg_proc_open_debug(struct inode *inode, struct file *file); | 2274 | static int sg_proc_open_debug(struct inode *inode, struct file *file); |
2258 | static struct file_operations debug_fops = { | 2275 | static const struct file_operations debug_fops = { |
2276 | .owner = THIS_MODULE, | ||
2259 | .open = sg_proc_open_debug, | 2277 | .open = sg_proc_open_debug, |
2278 | .read = seq_read, | ||
2279 | .llseek = seq_lseek, | ||
2260 | .release = seq_release, | 2280 | .release = seq_release, |
2261 | }; | 2281 | }; |
2262 | static const struct seq_operations debug_seq_ops = { | 2282 | static const struct seq_operations debug_seq_ops = { |
@@ -2269,7 +2289,7 @@ static const struct seq_operations debug_seq_ops = { | |||
2269 | 2289 | ||
2270 | struct sg_proc_leaf { | 2290 | struct sg_proc_leaf { |
2271 | const char * name; | 2291 | const char * name; |
2272 | struct file_operations * fops; | 2292 | const struct file_operations * fops; |
2273 | }; | 2293 | }; |
2274 | 2294 | ||
2275 | static struct sg_proc_leaf sg_proc_leaf_arr[] = { | 2295 | static struct sg_proc_leaf sg_proc_leaf_arr[] = { |
@@ -2295,9 +2315,6 @@ sg_proc_init(void) | |||
2295 | for (k = 0; k < num_leaves; ++k) { | 2315 | for (k = 0; k < num_leaves; ++k) { |
2296 | leaf = &sg_proc_leaf_arr[k]; | 2316 | leaf = &sg_proc_leaf_arr[k]; |
2297 | mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO; | 2317 | mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO; |
2298 | leaf->fops->owner = THIS_MODULE; | ||
2299 | leaf->fops->read = seq_read; | ||
2300 | leaf->fops->llseek = seq_lseek; | ||
2301 | proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops); | 2318 | proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops); |
2302 | } | 2319 | } |
2303 | return 0; | 2320 | return 0; |
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c index 2209620d2349..b1ae774016f1 100644 --- a/drivers/serial/8250.c +++ b/drivers/serial/8250.c | |||
@@ -64,6 +64,8 @@ static int serial_index(struct uart_port *port) | |||
64 | return (serial8250_reg.minor - 64) + port->line; | 64 | return (serial8250_reg.minor - 64) + port->line; |
65 | } | 65 | } |
66 | 66 | ||
67 | static unsigned int skip_txen_test; /* force skip of txen test at init time */ | ||
68 | |||
67 | /* | 69 | /* |
68 | * Debugging. | 70 | * Debugging. |
69 | */ | 71 | */ |
@@ -2108,7 +2110,7 @@ static int serial8250_startup(struct uart_port *port) | |||
2108 | is variable. So, let's just don't test if we receive | 2110 | is variable. So, let's just don't test if we receive |
2109 | TX irq. This way, we'll never enable UART_BUG_TXEN. | 2111 | TX irq. This way, we'll never enable UART_BUG_TXEN. |
2110 | */ | 2112 | */ |
2111 | if (up->port.flags & UPF_NO_TXEN_TEST) | 2113 | if (skip_txen_test || up->port.flags & UPF_NO_TXEN_TEST) |
2112 | goto dont_test_tx_en; | 2114 | goto dont_test_tx_en; |
2113 | 2115 | ||
2114 | /* | 2116 | /* |
@@ -3248,6 +3250,9 @@ MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices" | |||
3248 | module_param(nr_uarts, uint, 0644); | 3250 | module_param(nr_uarts, uint, 0644); |
3249 | MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")"); | 3251 | MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")"); |
3250 | 3252 | ||
3253 | module_param(skip_txen_test, uint, 0644); | ||
3254 | MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time"); | ||
3255 | |||
3251 | #ifdef CONFIG_SERIAL_8250_RSA | 3256 | #ifdef CONFIG_SERIAL_8250_RSA |
3252 | module_param_array(probe_rsa, ulong, &probe_rsa_count, 0444); | 3257 | module_param_array(probe_rsa, ulong, &probe_rsa_count, 0444); |
3253 | MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA"); | 3258 | MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA"); |
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig index e70712044a7e..e52257257279 100644 --- a/drivers/serial/Kconfig +++ b/drivers/serial/Kconfig | |||
@@ -862,7 +862,7 @@ config SERIAL_IMX_CONSOLE | |||
862 | 862 | ||
863 | config SERIAL_UARTLITE | 863 | config SERIAL_UARTLITE |
864 | tristate "Xilinx uartlite serial port support" | 864 | tristate "Xilinx uartlite serial port support" |
865 | depends on PPC32 || MICROBLAZE | 865 | depends on PPC32 || MICROBLAZE || MFD_TIMBERDALE |
866 | select SERIAL_CORE | 866 | select SERIAL_CORE |
867 | help | 867 | help |
868 | Say Y here if you want to use the Xilinx uartlite serial controller. | 868 | Say Y here if you want to use the Xilinx uartlite serial controller. |
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c index 2d7feecaf492..0028b6f89ce6 100644 --- a/drivers/serial/icom.c +++ b/drivers/serial/icom.c | |||
@@ -307,7 +307,7 @@ static void stop_processor(struct icom_port *icom_port) | |||
307 | if (port < 4) { | 307 | if (port < 4) { |
308 | temp = readl(stop_proc[port].global_control_reg); | 308 | temp = readl(stop_proc[port].global_control_reg); |
309 | temp = | 309 | temp = |
310 | (temp & ~start_proc[port].processor_id) | stop_proc[port].processor_id; | 310 | (temp & ~start_proc[port].processor_id) | stop_proc[port].processor_id; |
311 | writel(temp, stop_proc[port].global_control_reg); | 311 | writel(temp, stop_proc[port].global_control_reg); |
312 | 312 | ||
313 | /* write flush */ | 313 | /* write flush */ |
@@ -336,7 +336,7 @@ static void start_processor(struct icom_port *icom_port) | |||
336 | if (port < 4) { | 336 | if (port < 4) { |
337 | temp = readl(start_proc[port].global_control_reg); | 337 | temp = readl(start_proc[port].global_control_reg); |
338 | temp = | 338 | temp = |
339 | (temp & ~stop_proc[port].processor_id) | start_proc[port].processor_id; | 339 | (temp & ~stop_proc[port].processor_id) | start_proc[port].processor_id; |
340 | writel(temp, start_proc[port].global_control_reg); | 340 | writel(temp, start_proc[port].global_control_reg); |
341 | 341 | ||
342 | /* write flush */ | 342 | /* write flush */ |
@@ -509,8 +509,8 @@ static void load_code(struct icom_port *icom_port) | |||
509 | dev_err(&icom_port->adapter->pci_dev->dev,"Port not opertional\n"); | 509 | dev_err(&icom_port->adapter->pci_dev->dev,"Port not opertional\n"); |
510 | } | 510 | } |
511 | 511 | ||
512 | if (new_page != NULL) | 512 | if (new_page != NULL) |
513 | pci_free_consistent(dev, 4096, new_page, temp_pci); | 513 | pci_free_consistent(dev, 4096, new_page, temp_pci); |
514 | } | 514 | } |
515 | 515 | ||
516 | static int startup(struct icom_port *icom_port) | 516 | static int startup(struct icom_port *icom_port) |
@@ -1493,15 +1493,15 @@ static int __devinit icom_probe(struct pci_dev *dev, | |||
1493 | const struct pci_device_id *ent) | 1493 | const struct pci_device_id *ent) |
1494 | { | 1494 | { |
1495 | int index; | 1495 | int index; |
1496 | unsigned int command_reg; | 1496 | unsigned int command_reg; |
1497 | int retval; | 1497 | int retval; |
1498 | struct icom_adapter *icom_adapter; | 1498 | struct icom_adapter *icom_adapter; |
1499 | struct icom_port *icom_port; | 1499 | struct icom_port *icom_port; |
1500 | 1500 | ||
1501 | retval = pci_enable_device(dev); | 1501 | retval = pci_enable_device(dev); |
1502 | if (retval) { | 1502 | if (retval) { |
1503 | dev_err(&dev->dev, "Device enable FAILED\n"); | 1503 | dev_err(&dev->dev, "Device enable FAILED\n"); |
1504 | return retval; | 1504 | return retval; |
1505 | } | 1505 | } |
1506 | 1506 | ||
1507 | if ( (retval = pci_request_regions(dev, "icom"))) { | 1507 | if ( (retval = pci_request_regions(dev, "icom"))) { |
@@ -1510,23 +1510,23 @@ static int __devinit icom_probe(struct pci_dev *dev, | |||
1510 | return retval; | 1510 | return retval; |
1511 | } | 1511 | } |
1512 | 1512 | ||
1513 | pci_set_master(dev); | 1513 | pci_set_master(dev); |
1514 | 1514 | ||
1515 | if ( (retval = pci_read_config_dword(dev, PCI_COMMAND, &command_reg))) { | 1515 | if ( (retval = pci_read_config_dword(dev, PCI_COMMAND, &command_reg))) { |
1516 | dev_err(&dev->dev, "PCI Config read FAILED\n"); | 1516 | dev_err(&dev->dev, "PCI Config read FAILED\n"); |
1517 | return retval; | 1517 | return retval; |
1518 | } | 1518 | } |
1519 | 1519 | ||
1520 | pci_write_config_dword(dev, PCI_COMMAND, | 1520 | pci_write_config_dword(dev, PCI_COMMAND, |
1521 | command_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | 1521 | command_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
1522 | | PCI_COMMAND_PARITY | PCI_COMMAND_SERR); | 1522 | | PCI_COMMAND_PARITY | PCI_COMMAND_SERR); |
1523 | 1523 | ||
1524 | if (ent->driver_data == ADAPTER_V1) { | 1524 | if (ent->driver_data == ADAPTER_V1) { |
1525 | pci_write_config_dword(dev, 0x44, 0x8300830A); | 1525 | pci_write_config_dword(dev, 0x44, 0x8300830A); |
1526 | } else { | 1526 | } else { |
1527 | pci_write_config_dword(dev, 0x44, 0x42004200); | 1527 | pci_write_config_dword(dev, 0x44, 0x42004200); |
1528 | pci_write_config_dword(dev, 0x48, 0x42004200); | 1528 | pci_write_config_dword(dev, 0x48, 0x42004200); |
1529 | } | 1529 | } |
1530 | 1530 | ||
1531 | 1531 | ||
1532 | retval = icom_alloc_adapter(&icom_adapter); | 1532 | retval = icom_alloc_adapter(&icom_adapter); |
@@ -1536,10 +1536,10 @@ static int __devinit icom_probe(struct pci_dev *dev, | |||
1536 | goto probe_exit0; | 1536 | goto probe_exit0; |
1537 | } | 1537 | } |
1538 | 1538 | ||
1539 | icom_adapter->base_addr_pci = pci_resource_start(dev, 0); | 1539 | icom_adapter->base_addr_pci = pci_resource_start(dev, 0); |
1540 | icom_adapter->pci_dev = dev; | 1540 | icom_adapter->pci_dev = dev; |
1541 | icom_adapter->version = ent->driver_data; | 1541 | icom_adapter->version = ent->driver_data; |
1542 | icom_adapter->subsystem_id = ent->subdevice; | 1542 | icom_adapter->subsystem_id = ent->subdevice; |
1543 | 1543 | ||
1544 | 1544 | ||
1545 | retval = icom_init_ports(icom_adapter); | 1545 | retval = icom_init_ports(icom_adapter); |
@@ -1548,7 +1548,7 @@ static int __devinit icom_probe(struct pci_dev *dev, | |||
1548 | goto probe_exit1; | 1548 | goto probe_exit1; |
1549 | } | 1549 | } |
1550 | 1550 | ||
1551 | icom_adapter->base_addr = pci_ioremap_bar(dev, 0); | 1551 | icom_adapter->base_addr = pci_ioremap_bar(dev, 0); |
1552 | 1552 | ||
1553 | if (!icom_adapter->base_addr) | 1553 | if (!icom_adapter->base_addr) |
1554 | goto probe_exit1; | 1554 | goto probe_exit1; |
@@ -1562,7 +1562,7 @@ static int __devinit icom_probe(struct pci_dev *dev, | |||
1562 | 1562 | ||
1563 | retval = icom_load_ports(icom_adapter); | 1563 | retval = icom_load_ports(icom_adapter); |
1564 | 1564 | ||
1565 | for (index = 0; index < icom_adapter->numb_ports; index++) { | 1565 | for (index = 0; index < icom_adapter->numb_ports; index++) { |
1566 | icom_port = &icom_adapter->port_info[index]; | 1566 | icom_port = &icom_adapter->port_info[index]; |
1567 | 1567 | ||
1568 | if (icom_port->status == ICOM_PORT_ACTIVE) { | 1568 | if (icom_port->status == ICOM_PORT_ACTIVE) { |
@@ -1579,7 +1579,7 @@ static int __devinit icom_probe(struct pci_dev *dev, | |||
1579 | icom_port->status = ICOM_PORT_OFF; | 1579 | icom_port->status = ICOM_PORT_OFF; |
1580 | dev_err(&dev->dev, "Device add failed\n"); | 1580 | dev_err(&dev->dev, "Device add failed\n"); |
1581 | } else | 1581 | } else |
1582 | dev_info(&dev->dev, "Device added\n"); | 1582 | dev_info(&dev->dev, "Device added\n"); |
1583 | } | 1583 | } |
1584 | } | 1584 | } |
1585 | 1585 | ||
@@ -1595,9 +1595,7 @@ probe_exit0: | |||
1595 | pci_release_regions(dev); | 1595 | pci_release_regions(dev); |
1596 | pci_disable_device(dev); | 1596 | pci_disable_device(dev); |
1597 | 1597 | ||
1598 | return retval; | 1598 | return retval; |
1599 | |||
1600 | |||
1601 | } | 1599 | } |
1602 | 1600 | ||
1603 | static void __devexit icom_remove(struct pci_dev *dev) | 1601 | static void __devexit icom_remove(struct pci_dev *dev) |
diff --git a/drivers/serial/sa1100.c b/drivers/serial/sa1100.c index 7f5e26873220..2199d819a987 100644 --- a/drivers/serial/sa1100.c +++ b/drivers/serial/sa1100.c | |||
@@ -638,7 +638,7 @@ static void __init sa1100_init_ports(void) | |||
638 | PPSR |= PPC_TXD1 | PPC_TXD3; | 638 | PPSR |= PPC_TXD1 | PPC_TXD3; |
639 | } | 639 | } |
640 | 640 | ||
641 | void __init sa1100_register_uart_fns(struct sa1100_port_fns *fns) | 641 | void __devinit sa1100_register_uart_fns(struct sa1100_port_fns *fns) |
642 | { | 642 | { |
643 | if (fns->get_mctrl) | 643 | if (fns->get_mctrl) |
644 | sa1100_pops.get_mctrl = fns->get_mctrl; | 644 | sa1100_pops.get_mctrl = fns->get_mctrl; |
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c index a3bb49031a7f..ff4617e21426 100644 --- a/drivers/serial/serial_cs.c +++ b/drivers/serial/serial_cs.c | |||
@@ -873,10 +873,10 @@ static struct pcmcia_device_id serial_ids[] = { | |||
873 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "cis/PCMLM28.cis"), | 873 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "cis/PCMLM28.cis"), |
874 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "cis/PCMLM28.cis"), | 874 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "cis/PCMLM28.cis"), |
875 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "cis/PCMLM28.cis"), | 875 | PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "cis/PCMLM28.cis"), |
876 | PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"), | 876 | PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "cis/DP83903.cis"), |
877 | PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"), | 877 | PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "cis/DP83903.cis"), |
878 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "cis/3CCFEM556.cis"), | 878 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "cis/3CCFEM556.cis"), |
879 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"), | 879 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "cis/DP83903.cis"), |
880 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "cis/3CXEM556.cis"), | 880 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "cis/3CXEM556.cis"), |
881 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "cis/3CXEM556.cis"), | 881 | PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "cis/3CXEM556.cis"), |
882 | PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC850", 0xd85f6206, 0x42a2c018, "SW_8xx_SER.cis"), /* Sierra Wireless AC850 3G Network Adapter R1 */ | 882 | PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC850", 0xd85f6206, 0x42a2c018, "SW_8xx_SER.cis"), /* Sierra Wireless AC850 3G Network Adapter R1 */ |
@@ -884,9 +884,9 @@ static struct pcmcia_device_id serial_ids[] = { | |||
884 | PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */ | 884 | PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */ |
885 | PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */ | 885 | PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */ |
886 | PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "cis/MT5634ZLX.cis"), | 886 | PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "cis/MT5634ZLX.cis"), |
887 | PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-2", 0x96913a85, 0x27ab5437, "COMpad2.cis"), | 887 | PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-2", 0x96913a85, 0x27ab5437, "cis/COMpad2.cis"), |
888 | PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"), | 888 | PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "cis/COMpad4.cis"), |
889 | PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"), | 889 | PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "cis/COMpad2.cis"), |
890 | PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"), | 890 | PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"), |
891 | PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "GLOBETROTTER.cis"), | 891 | PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "GLOBETROTTER.cis"), |
892 | PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100 1.00.",0x19ca78af,0xf964f42b), | 892 | PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100 1.00.",0x19ca78af,0xf964f42b), |
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c index 0f7cf4c453e6..c50e9fbbf743 100644 --- a/drivers/serial/serial_txx9.c +++ b/drivers/serial/serial_txx9.c | |||
@@ -221,21 +221,26 @@ sio_quot_set(struct uart_txx9_port *up, int quot) | |||
221 | sio_out(up, TXX9_SIBGR, 0xff | TXX9_SIBGR_BCLK_T6); | 221 | sio_out(up, TXX9_SIBGR, 0xff | TXX9_SIBGR_BCLK_T6); |
222 | } | 222 | } |
223 | 223 | ||
224 | static struct uart_txx9_port *to_uart_txx9_port(struct uart_port *port) | ||
225 | { | ||
226 | return container_of(port, struct uart_txx9_port, port); | ||
227 | } | ||
228 | |||
224 | static void serial_txx9_stop_tx(struct uart_port *port) | 229 | static void serial_txx9_stop_tx(struct uart_port *port) |
225 | { | 230 | { |
226 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 231 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
227 | sio_mask(up, TXX9_SIDICR, TXX9_SIDICR_TIE); | 232 | sio_mask(up, TXX9_SIDICR, TXX9_SIDICR_TIE); |
228 | } | 233 | } |
229 | 234 | ||
230 | static void serial_txx9_start_tx(struct uart_port *port) | 235 | static void serial_txx9_start_tx(struct uart_port *port) |
231 | { | 236 | { |
232 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 237 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
233 | sio_set(up, TXX9_SIDICR, TXX9_SIDICR_TIE); | 238 | sio_set(up, TXX9_SIDICR, TXX9_SIDICR_TIE); |
234 | } | 239 | } |
235 | 240 | ||
236 | static void serial_txx9_stop_rx(struct uart_port *port) | 241 | static void serial_txx9_stop_rx(struct uart_port *port) |
237 | { | 242 | { |
238 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 243 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
239 | up->port.read_status_mask &= ~TXX9_SIDISR_RDIS; | 244 | up->port.read_status_mask &= ~TXX9_SIDISR_RDIS; |
240 | } | 245 | } |
241 | 246 | ||
@@ -246,7 +251,7 @@ static void serial_txx9_enable_ms(struct uart_port *port) | |||
246 | 251 | ||
247 | static void serial_txx9_initialize(struct uart_port *port) | 252 | static void serial_txx9_initialize(struct uart_port *port) |
248 | { | 253 | { |
249 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 254 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
250 | unsigned int tmout = 10000; | 255 | unsigned int tmout = 10000; |
251 | 256 | ||
252 | sio_out(up, TXX9_SIFCR, TXX9_SIFCR_SWRST); | 257 | sio_out(up, TXX9_SIFCR, TXX9_SIFCR_SWRST); |
@@ -414,7 +419,7 @@ static irqreturn_t serial_txx9_interrupt(int irq, void *dev_id) | |||
414 | 419 | ||
415 | static unsigned int serial_txx9_tx_empty(struct uart_port *port) | 420 | static unsigned int serial_txx9_tx_empty(struct uart_port *port) |
416 | { | 421 | { |
417 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 422 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
418 | unsigned long flags; | 423 | unsigned long flags; |
419 | unsigned int ret; | 424 | unsigned int ret; |
420 | 425 | ||
@@ -427,7 +432,7 @@ static unsigned int serial_txx9_tx_empty(struct uart_port *port) | |||
427 | 432 | ||
428 | static unsigned int serial_txx9_get_mctrl(struct uart_port *port) | 433 | static unsigned int serial_txx9_get_mctrl(struct uart_port *port) |
429 | { | 434 | { |
430 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 435 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
431 | unsigned int ret; | 436 | unsigned int ret; |
432 | 437 | ||
433 | /* no modem control lines */ | 438 | /* no modem control lines */ |
@@ -440,7 +445,7 @@ static unsigned int serial_txx9_get_mctrl(struct uart_port *port) | |||
440 | 445 | ||
441 | static void serial_txx9_set_mctrl(struct uart_port *port, unsigned int mctrl) | 446 | static void serial_txx9_set_mctrl(struct uart_port *port, unsigned int mctrl) |
442 | { | 447 | { |
443 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 448 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
444 | 449 | ||
445 | if (mctrl & TIOCM_RTS) | 450 | if (mctrl & TIOCM_RTS) |
446 | sio_mask(up, TXX9_SIFLCR, TXX9_SIFLCR_RTSSC); | 451 | sio_mask(up, TXX9_SIFLCR, TXX9_SIFLCR_RTSSC); |
@@ -450,7 +455,7 @@ static void serial_txx9_set_mctrl(struct uart_port *port, unsigned int mctrl) | |||
450 | 455 | ||
451 | static void serial_txx9_break_ctl(struct uart_port *port, int break_state) | 456 | static void serial_txx9_break_ctl(struct uart_port *port, int break_state) |
452 | { | 457 | { |
453 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 458 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
454 | unsigned long flags; | 459 | unsigned long flags; |
455 | 460 | ||
456 | spin_lock_irqsave(&up->port.lock, flags); | 461 | spin_lock_irqsave(&up->port.lock, flags); |
@@ -494,7 +499,7 @@ static int serial_txx9_get_poll_char(struct uart_port *port) | |||
494 | { | 499 | { |
495 | unsigned int ier; | 500 | unsigned int ier; |
496 | unsigned char c; | 501 | unsigned char c; |
497 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 502 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
498 | 503 | ||
499 | /* | 504 | /* |
500 | * First save the IER then disable the interrupts | 505 | * First save the IER then disable the interrupts |
@@ -520,7 +525,7 @@ static int serial_txx9_get_poll_char(struct uart_port *port) | |||
520 | static void serial_txx9_put_poll_char(struct uart_port *port, unsigned char c) | 525 | static void serial_txx9_put_poll_char(struct uart_port *port, unsigned char c) |
521 | { | 526 | { |
522 | unsigned int ier; | 527 | unsigned int ier; |
523 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 528 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
524 | 529 | ||
525 | /* | 530 | /* |
526 | * First save the IER then disable the interrupts | 531 | * First save the IER then disable the interrupts |
@@ -551,7 +556,7 @@ static void serial_txx9_put_poll_char(struct uart_port *port, unsigned char c) | |||
551 | 556 | ||
552 | static int serial_txx9_startup(struct uart_port *port) | 557 | static int serial_txx9_startup(struct uart_port *port) |
553 | { | 558 | { |
554 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 559 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
555 | unsigned long flags; | 560 | unsigned long flags; |
556 | int retval; | 561 | int retval; |
557 | 562 | ||
@@ -596,7 +601,7 @@ static int serial_txx9_startup(struct uart_port *port) | |||
596 | 601 | ||
597 | static void serial_txx9_shutdown(struct uart_port *port) | 602 | static void serial_txx9_shutdown(struct uart_port *port) |
598 | { | 603 | { |
599 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 604 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
600 | unsigned long flags; | 605 | unsigned long flags; |
601 | 606 | ||
602 | /* | 607 | /* |
@@ -636,7 +641,7 @@ static void | |||
636 | serial_txx9_set_termios(struct uart_port *port, struct ktermios *termios, | 641 | serial_txx9_set_termios(struct uart_port *port, struct ktermios *termios, |
637 | struct ktermios *old) | 642 | struct ktermios *old) |
638 | { | 643 | { |
639 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 644 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
640 | unsigned int cval, fcr = 0; | 645 | unsigned int cval, fcr = 0; |
641 | unsigned long flags; | 646 | unsigned long flags; |
642 | unsigned int baud, quot; | 647 | unsigned int baud, quot; |
@@ -814,19 +819,19 @@ static void serial_txx9_release_resource(struct uart_txx9_port *up) | |||
814 | 819 | ||
815 | static void serial_txx9_release_port(struct uart_port *port) | 820 | static void serial_txx9_release_port(struct uart_port *port) |
816 | { | 821 | { |
817 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 822 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
818 | serial_txx9_release_resource(up); | 823 | serial_txx9_release_resource(up); |
819 | } | 824 | } |
820 | 825 | ||
821 | static int serial_txx9_request_port(struct uart_port *port) | 826 | static int serial_txx9_request_port(struct uart_port *port) |
822 | { | 827 | { |
823 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 828 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
824 | return serial_txx9_request_resource(up); | 829 | return serial_txx9_request_resource(up); |
825 | } | 830 | } |
826 | 831 | ||
827 | static void serial_txx9_config_port(struct uart_port *port, int uflags) | 832 | static void serial_txx9_config_port(struct uart_port *port, int uflags) |
828 | { | 833 | { |
829 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 834 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
830 | int ret; | 835 | int ret; |
831 | 836 | ||
832 | /* | 837 | /* |
@@ -897,7 +902,7 @@ static void __init serial_txx9_register_ports(struct uart_driver *drv, | |||
897 | 902 | ||
898 | static void serial_txx9_console_putchar(struct uart_port *port, int ch) | 903 | static void serial_txx9_console_putchar(struct uart_port *port, int ch) |
899 | { | 904 | { |
900 | struct uart_txx9_port *up = (struct uart_txx9_port *)port; | 905 | struct uart_txx9_port *up = to_uart_txx9_port(port); |
901 | 906 | ||
902 | wait_for_xmitr(up); | 907 | wait_for_xmitr(up); |
903 | sio_out(up, TXX9_SITFIFO, ch); | 908 | sio_out(up, TXX9_SITFIFO, ch); |
diff --git a/drivers/sfi/sfi_core.c b/drivers/sfi/sfi_core.c index d3b496800477..b204a0929139 100644 --- a/drivers/sfi/sfi_core.c +++ b/drivers/sfi/sfi_core.c | |||
@@ -90,7 +90,11 @@ static struct sfi_table_simple *syst_va __read_mostly; | |||
90 | */ | 90 | */ |
91 | static u32 sfi_use_ioremap __read_mostly; | 91 | static u32 sfi_use_ioremap __read_mostly; |
92 | 92 | ||
93 | static void __iomem *sfi_map_memory(u64 phys, u32 size) | 93 | /* |
94 | * sfi_un/map_memory calls early_ioremap/iounmap which is a __init function | ||
95 | * and introduces section mismatch. So use __ref to make it calm. | ||
96 | */ | ||
97 | static void __iomem * __ref sfi_map_memory(u64 phys, u32 size) | ||
94 | { | 98 | { |
95 | if (!phys || !size) | 99 | if (!phys || !size) |
96 | return NULL; | 100 | return NULL; |
@@ -101,7 +105,7 @@ static void __iomem *sfi_map_memory(u64 phys, u32 size) | |||
101 | return early_ioremap(phys, size); | 105 | return early_ioremap(phys, size); |
102 | } | 106 | } |
103 | 107 | ||
104 | static void sfi_unmap_memory(void __iomem *virt, u32 size) | 108 | static void __ref sfi_unmap_memory(void __iomem *virt, u32 size) |
105 | { | 109 | { |
106 | if (!virt || !size) | 110 | if (!virt || !size) |
107 | return; | 111 | return; |
@@ -125,7 +129,7 @@ static void sfi_print_table_header(unsigned long long pa, | |||
125 | * sfi_verify_table() | 129 | * sfi_verify_table() |
126 | * Sanity check table lengh, calculate checksum | 130 | * Sanity check table lengh, calculate checksum |
127 | */ | 131 | */ |
128 | static __init int sfi_verify_table(struct sfi_table_header *table) | 132 | static int sfi_verify_table(struct sfi_table_header *table) |
129 | { | 133 | { |
130 | 134 | ||
131 | u8 checksum = 0; | 135 | u8 checksum = 0; |
@@ -213,12 +217,17 @@ static int sfi_table_check_key(struct sfi_table_header *th, | |||
213 | * the mapped virt address will be returned, and the virt space | 217 | * the mapped virt address will be returned, and the virt space |
214 | * will be released by call sfi_put_table() later | 218 | * will be released by call sfi_put_table() later |
215 | * | 219 | * |
220 | * This two cases are from two different functions with two different | ||
221 | * sections and causes section mismatch warning. So use __ref to tell | ||
222 | * modpost not to make any noise. | ||
223 | * | ||
216 | * Return value: | 224 | * Return value: |
217 | * NULL: when can't find a table matching the key | 225 | * NULL: when can't find a table matching the key |
218 | * ERR_PTR(error): error value | 226 | * ERR_PTR(error): error value |
219 | * virt table address: when a matched table is found | 227 | * virt table address: when a matched table is found |
220 | */ | 228 | */ |
221 | struct sfi_table_header *sfi_check_table(u64 pa, struct sfi_table_key *key) | 229 | struct sfi_table_header * |
230 | __ref sfi_check_table(u64 pa, struct sfi_table_key *key) | ||
222 | { | 231 | { |
223 | struct sfi_table_header *th; | 232 | struct sfi_table_header *th; |
224 | void *ret = NULL; | 233 | void *ret = NULL; |
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile index 6d7a3f82c54b..21a118269cac 100644 --- a/drivers/spi/Makefile +++ b/drivers/spi/Makefile | |||
@@ -17,7 +17,7 @@ obj-$(CONFIG_SPI_BITBANG) += spi_bitbang.o | |||
17 | obj-$(CONFIG_SPI_AU1550) += au1550_spi.o | 17 | obj-$(CONFIG_SPI_AU1550) += au1550_spi.o |
18 | obj-$(CONFIG_SPI_BUTTERFLY) += spi_butterfly.o | 18 | obj-$(CONFIG_SPI_BUTTERFLY) += spi_butterfly.o |
19 | obj-$(CONFIG_SPI_GPIO) += spi_gpio.o | 19 | obj-$(CONFIG_SPI_GPIO) += spi_gpio.o |
20 | obj-$(CONFIG_SPI_IMX) += mxc_spi.o | 20 | obj-$(CONFIG_SPI_IMX) += spi_imx.o |
21 | obj-$(CONFIG_SPI_LM70_LLP) += spi_lm70llp.o | 21 | obj-$(CONFIG_SPI_LM70_LLP) += spi_lm70llp.o |
22 | obj-$(CONFIG_SPI_PXA2XX) += pxa2xx_spi.o | 22 | obj-$(CONFIG_SPI_PXA2XX) += pxa2xx_spi.o |
23 | obj-$(CONFIG_SPI_OMAP_UWIRE) += omap_uwire.o | 23 | obj-$(CONFIG_SPI_OMAP_UWIRE) += omap_uwire.o |
diff --git a/drivers/spi/mxc_spi.c b/drivers/spi/spi_imx.c index b1447236ae81..89c22efedfb0 100644 --- a/drivers/spi/mxc_spi.c +++ b/drivers/spi/spi_imx.c | |||
@@ -48,14 +48,14 @@ | |||
48 | #define MXC_INT_RR (1 << 0) /* Receive data ready interrupt */ | 48 | #define MXC_INT_RR (1 << 0) /* Receive data ready interrupt */ |
49 | #define MXC_INT_TE (1 << 1) /* Transmit FIFO empty interrupt */ | 49 | #define MXC_INT_TE (1 << 1) /* Transmit FIFO empty interrupt */ |
50 | 50 | ||
51 | struct mxc_spi_config { | 51 | struct spi_imx_config { |
52 | unsigned int speed_hz; | 52 | unsigned int speed_hz; |
53 | unsigned int bpw; | 53 | unsigned int bpw; |
54 | unsigned int mode; | 54 | unsigned int mode; |
55 | int cs; | 55 | int cs; |
56 | }; | 56 | }; |
57 | 57 | ||
58 | struct mxc_spi_data { | 58 | struct spi_imx_data { |
59 | struct spi_bitbang bitbang; | 59 | struct spi_bitbang bitbang; |
60 | 60 | ||
61 | struct completion xfer_done; | 61 | struct completion xfer_done; |
@@ -66,43 +66,43 @@ struct mxc_spi_data { | |||
66 | int *chipselect; | 66 | int *chipselect; |
67 | 67 | ||
68 | unsigned int count; | 68 | unsigned int count; |
69 | void (*tx)(struct mxc_spi_data *); | 69 | void (*tx)(struct spi_imx_data *); |
70 | void (*rx)(struct mxc_spi_data *); | 70 | void (*rx)(struct spi_imx_data *); |
71 | void *rx_buf; | 71 | void *rx_buf; |
72 | const void *tx_buf; | 72 | const void *tx_buf; |
73 | unsigned int txfifo; /* number of words pushed in tx FIFO */ | 73 | unsigned int txfifo; /* number of words pushed in tx FIFO */ |
74 | 74 | ||
75 | /* SoC specific functions */ | 75 | /* SoC specific functions */ |
76 | void (*intctrl)(struct mxc_spi_data *, int); | 76 | void (*intctrl)(struct spi_imx_data *, int); |
77 | int (*config)(struct mxc_spi_data *, struct mxc_spi_config *); | 77 | int (*config)(struct spi_imx_data *, struct spi_imx_config *); |
78 | void (*trigger)(struct mxc_spi_data *); | 78 | void (*trigger)(struct spi_imx_data *); |
79 | int (*rx_available)(struct mxc_spi_data *); | 79 | int (*rx_available)(struct spi_imx_data *); |
80 | }; | 80 | }; |
81 | 81 | ||
82 | #define MXC_SPI_BUF_RX(type) \ | 82 | #define MXC_SPI_BUF_RX(type) \ |
83 | static void mxc_spi_buf_rx_##type(struct mxc_spi_data *mxc_spi) \ | 83 | static void spi_imx_buf_rx_##type(struct spi_imx_data *spi_imx) \ |
84 | { \ | 84 | { \ |
85 | unsigned int val = readl(mxc_spi->base + MXC_CSPIRXDATA); \ | 85 | unsigned int val = readl(spi_imx->base + MXC_CSPIRXDATA); \ |
86 | \ | 86 | \ |
87 | if (mxc_spi->rx_buf) { \ | 87 | if (spi_imx->rx_buf) { \ |
88 | *(type *)mxc_spi->rx_buf = val; \ | 88 | *(type *)spi_imx->rx_buf = val; \ |
89 | mxc_spi->rx_buf += sizeof(type); \ | 89 | spi_imx->rx_buf += sizeof(type); \ |
90 | } \ | 90 | } \ |
91 | } | 91 | } |
92 | 92 | ||
93 | #define MXC_SPI_BUF_TX(type) \ | 93 | #define MXC_SPI_BUF_TX(type) \ |
94 | static void mxc_spi_buf_tx_##type(struct mxc_spi_data *mxc_spi) \ | 94 | static void spi_imx_buf_tx_##type(struct spi_imx_data *spi_imx) \ |
95 | { \ | 95 | { \ |
96 | type val = 0; \ | 96 | type val = 0; \ |
97 | \ | 97 | \ |
98 | if (mxc_spi->tx_buf) { \ | 98 | if (spi_imx->tx_buf) { \ |
99 | val = *(type *)mxc_spi->tx_buf; \ | 99 | val = *(type *)spi_imx->tx_buf; \ |
100 | mxc_spi->tx_buf += sizeof(type); \ | 100 | spi_imx->tx_buf += sizeof(type); \ |
101 | } \ | 101 | } \ |
102 | \ | 102 | \ |
103 | mxc_spi->count -= sizeof(type); \ | 103 | spi_imx->count -= sizeof(type); \ |
104 | \ | 104 | \ |
105 | writel(val, mxc_spi->base + MXC_CSPITXDATA); \ | 105 | writel(val, spi_imx->base + MXC_CSPITXDATA); \ |
106 | } | 106 | } |
107 | 107 | ||
108 | MXC_SPI_BUF_RX(u8) | 108 | MXC_SPI_BUF_RX(u8) |
@@ -119,7 +119,7 @@ static int mxc_clkdivs[] = {0, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, | |||
119 | 256, 384, 512, 768, 1024}; | 119 | 256, 384, 512, 768, 1024}; |
120 | 120 | ||
121 | /* MX21, MX27 */ | 121 | /* MX21, MX27 */ |
122 | static unsigned int mxc_spi_clkdiv_1(unsigned int fin, | 122 | static unsigned int spi_imx_clkdiv_1(unsigned int fin, |
123 | unsigned int fspi) | 123 | unsigned int fspi) |
124 | { | 124 | { |
125 | int i, max; | 125 | int i, max; |
@@ -137,7 +137,7 @@ static unsigned int mxc_spi_clkdiv_1(unsigned int fin, | |||
137 | } | 137 | } |
138 | 138 | ||
139 | /* MX1, MX31, MX35 */ | 139 | /* MX1, MX31, MX35 */ |
140 | static unsigned int mxc_spi_clkdiv_2(unsigned int fin, | 140 | static unsigned int spi_imx_clkdiv_2(unsigned int fin, |
141 | unsigned int fspi) | 141 | unsigned int fspi) |
142 | { | 142 | { |
143 | int i, div = 4; | 143 | int i, div = 4; |
@@ -174,7 +174,7 @@ static unsigned int mxc_spi_clkdiv_2(unsigned int fin, | |||
174 | * the i.MX35 has a slightly different register layout for bits | 174 | * the i.MX35 has a slightly different register layout for bits |
175 | * we do not use here. | 175 | * we do not use here. |
176 | */ | 176 | */ |
177 | static void mx31_intctrl(struct mxc_spi_data *mxc_spi, int enable) | 177 | static void mx31_intctrl(struct spi_imx_data *spi_imx, int enable) |
178 | { | 178 | { |
179 | unsigned int val = 0; | 179 | unsigned int val = 0; |
180 | 180 | ||
@@ -183,24 +183,24 @@ static void mx31_intctrl(struct mxc_spi_data *mxc_spi, int enable) | |||
183 | if (enable & MXC_INT_RR) | 183 | if (enable & MXC_INT_RR) |
184 | val |= MX31_INTREG_RREN; | 184 | val |= MX31_INTREG_RREN; |
185 | 185 | ||
186 | writel(val, mxc_spi->base + MXC_CSPIINT); | 186 | writel(val, spi_imx->base + MXC_CSPIINT); |
187 | } | 187 | } |
188 | 188 | ||
189 | static void mx31_trigger(struct mxc_spi_data *mxc_spi) | 189 | static void mx31_trigger(struct spi_imx_data *spi_imx) |
190 | { | 190 | { |
191 | unsigned int reg; | 191 | unsigned int reg; |
192 | 192 | ||
193 | reg = readl(mxc_spi->base + MXC_CSPICTRL); | 193 | reg = readl(spi_imx->base + MXC_CSPICTRL); |
194 | reg |= MX31_CSPICTRL_XCH; | 194 | reg |= MX31_CSPICTRL_XCH; |
195 | writel(reg, mxc_spi->base + MXC_CSPICTRL); | 195 | writel(reg, spi_imx->base + MXC_CSPICTRL); |
196 | } | 196 | } |
197 | 197 | ||
198 | static int mx31_config(struct mxc_spi_data *mxc_spi, | 198 | static int mx31_config(struct spi_imx_data *spi_imx, |
199 | struct mxc_spi_config *config) | 199 | struct spi_imx_config *config) |
200 | { | 200 | { |
201 | unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER; | 201 | unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER; |
202 | 202 | ||
203 | reg |= mxc_spi_clkdiv_2(mxc_spi->spi_clk, config->speed_hz) << | 203 | reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) << |
204 | MX31_CSPICTRL_DR_SHIFT; | 204 | MX31_CSPICTRL_DR_SHIFT; |
205 | 205 | ||
206 | if (cpu_is_mx31()) | 206 | if (cpu_is_mx31()) |
@@ -223,14 +223,14 @@ static int mx31_config(struct mxc_spi_data *mxc_spi, | |||
223 | reg |= (config->cs + 32) << MX35_CSPICTRL_CS_SHIFT; | 223 | reg |= (config->cs + 32) << MX35_CSPICTRL_CS_SHIFT; |
224 | } | 224 | } |
225 | 225 | ||
226 | writel(reg, mxc_spi->base + MXC_CSPICTRL); | 226 | writel(reg, spi_imx->base + MXC_CSPICTRL); |
227 | 227 | ||
228 | return 0; | 228 | return 0; |
229 | } | 229 | } |
230 | 230 | ||
231 | static int mx31_rx_available(struct mxc_spi_data *mxc_spi) | 231 | static int mx31_rx_available(struct spi_imx_data *spi_imx) |
232 | { | 232 | { |
233 | return readl(mxc_spi->base + MX31_CSPISTATUS) & MX31_STATUS_RR; | 233 | return readl(spi_imx->base + MX31_CSPISTATUS) & MX31_STATUS_RR; |
234 | } | 234 | } |
235 | 235 | ||
236 | #define MX27_INTREG_RR (1 << 4) | 236 | #define MX27_INTREG_RR (1 << 4) |
@@ -246,7 +246,7 @@ static int mx31_rx_available(struct mxc_spi_data *mxc_spi) | |||
246 | #define MX27_CSPICTRL_DR_SHIFT 14 | 246 | #define MX27_CSPICTRL_DR_SHIFT 14 |
247 | #define MX27_CSPICTRL_CS_SHIFT 19 | 247 | #define MX27_CSPICTRL_CS_SHIFT 19 |
248 | 248 | ||
249 | static void mx27_intctrl(struct mxc_spi_data *mxc_spi, int enable) | 249 | static void mx27_intctrl(struct spi_imx_data *spi_imx, int enable) |
250 | { | 250 | { |
251 | unsigned int val = 0; | 251 | unsigned int val = 0; |
252 | 252 | ||
@@ -255,24 +255,24 @@ static void mx27_intctrl(struct mxc_spi_data *mxc_spi, int enable) | |||
255 | if (enable & MXC_INT_RR) | 255 | if (enable & MXC_INT_RR) |
256 | val |= MX27_INTREG_RREN; | 256 | val |= MX27_INTREG_RREN; |
257 | 257 | ||
258 | writel(val, mxc_spi->base + MXC_CSPIINT); | 258 | writel(val, spi_imx->base + MXC_CSPIINT); |
259 | } | 259 | } |
260 | 260 | ||
261 | static void mx27_trigger(struct mxc_spi_data *mxc_spi) | 261 | static void mx27_trigger(struct spi_imx_data *spi_imx) |
262 | { | 262 | { |
263 | unsigned int reg; | 263 | unsigned int reg; |
264 | 264 | ||
265 | reg = readl(mxc_spi->base + MXC_CSPICTRL); | 265 | reg = readl(spi_imx->base + MXC_CSPICTRL); |
266 | reg |= MX27_CSPICTRL_XCH; | 266 | reg |= MX27_CSPICTRL_XCH; |
267 | writel(reg, mxc_spi->base + MXC_CSPICTRL); | 267 | writel(reg, spi_imx->base + MXC_CSPICTRL); |
268 | } | 268 | } |
269 | 269 | ||
270 | static int mx27_config(struct mxc_spi_data *mxc_spi, | 270 | static int mx27_config(struct spi_imx_data *spi_imx, |
271 | struct mxc_spi_config *config) | 271 | struct spi_imx_config *config) |
272 | { | 272 | { |
273 | unsigned int reg = MX27_CSPICTRL_ENABLE | MX27_CSPICTRL_MASTER; | 273 | unsigned int reg = MX27_CSPICTRL_ENABLE | MX27_CSPICTRL_MASTER; |
274 | 274 | ||
275 | reg |= mxc_spi_clkdiv_1(mxc_spi->spi_clk, config->speed_hz) << | 275 | reg |= spi_imx_clkdiv_1(spi_imx->spi_clk, config->speed_hz) << |
276 | MX27_CSPICTRL_DR_SHIFT; | 276 | MX27_CSPICTRL_DR_SHIFT; |
277 | reg |= config->bpw - 1; | 277 | reg |= config->bpw - 1; |
278 | 278 | ||
@@ -285,14 +285,14 @@ static int mx27_config(struct mxc_spi_data *mxc_spi, | |||
285 | if (config->cs < 0) | 285 | if (config->cs < 0) |
286 | reg |= (config->cs + 32) << MX27_CSPICTRL_CS_SHIFT; | 286 | reg |= (config->cs + 32) << MX27_CSPICTRL_CS_SHIFT; |
287 | 287 | ||
288 | writel(reg, mxc_spi->base + MXC_CSPICTRL); | 288 | writel(reg, spi_imx->base + MXC_CSPICTRL); |
289 | 289 | ||
290 | return 0; | 290 | return 0; |
291 | } | 291 | } |
292 | 292 | ||
293 | static int mx27_rx_available(struct mxc_spi_data *mxc_spi) | 293 | static int mx27_rx_available(struct spi_imx_data *spi_imx) |
294 | { | 294 | { |
295 | return readl(mxc_spi->base + MXC_CSPIINT) & MX27_INTREG_RR; | 295 | return readl(spi_imx->base + MXC_CSPIINT) & MX27_INTREG_RR; |
296 | } | 296 | } |
297 | 297 | ||
298 | #define MX1_INTREG_RR (1 << 3) | 298 | #define MX1_INTREG_RR (1 << 3) |
@@ -306,7 +306,7 @@ static int mx27_rx_available(struct mxc_spi_data *mxc_spi) | |||
306 | #define MX1_CSPICTRL_MASTER (1 << 10) | 306 | #define MX1_CSPICTRL_MASTER (1 << 10) |
307 | #define MX1_CSPICTRL_DR_SHIFT 13 | 307 | #define MX1_CSPICTRL_DR_SHIFT 13 |
308 | 308 | ||
309 | static void mx1_intctrl(struct mxc_spi_data *mxc_spi, int enable) | 309 | static void mx1_intctrl(struct spi_imx_data *spi_imx, int enable) |
310 | { | 310 | { |
311 | unsigned int val = 0; | 311 | unsigned int val = 0; |
312 | 312 | ||
@@ -315,24 +315,24 @@ static void mx1_intctrl(struct mxc_spi_data *mxc_spi, int enable) | |||
315 | if (enable & MXC_INT_RR) | 315 | if (enable & MXC_INT_RR) |
316 | val |= MX1_INTREG_RREN; | 316 | val |= MX1_INTREG_RREN; |
317 | 317 | ||
318 | writel(val, mxc_spi->base + MXC_CSPIINT); | 318 | writel(val, spi_imx->base + MXC_CSPIINT); |
319 | } | 319 | } |
320 | 320 | ||
321 | static void mx1_trigger(struct mxc_spi_data *mxc_spi) | 321 | static void mx1_trigger(struct spi_imx_data *spi_imx) |
322 | { | 322 | { |
323 | unsigned int reg; | 323 | unsigned int reg; |
324 | 324 | ||
325 | reg = readl(mxc_spi->base + MXC_CSPICTRL); | 325 | reg = readl(spi_imx->base + MXC_CSPICTRL); |
326 | reg |= MX1_CSPICTRL_XCH; | 326 | reg |= MX1_CSPICTRL_XCH; |
327 | writel(reg, mxc_spi->base + MXC_CSPICTRL); | 327 | writel(reg, spi_imx->base + MXC_CSPICTRL); |
328 | } | 328 | } |
329 | 329 | ||
330 | static int mx1_config(struct mxc_spi_data *mxc_spi, | 330 | static int mx1_config(struct spi_imx_data *spi_imx, |
331 | struct mxc_spi_config *config) | 331 | struct spi_imx_config *config) |
332 | { | 332 | { |
333 | unsigned int reg = MX1_CSPICTRL_ENABLE | MX1_CSPICTRL_MASTER; | 333 | unsigned int reg = MX1_CSPICTRL_ENABLE | MX1_CSPICTRL_MASTER; |
334 | 334 | ||
335 | reg |= mxc_spi_clkdiv_2(mxc_spi->spi_clk, config->speed_hz) << | 335 | reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) << |
336 | MX1_CSPICTRL_DR_SHIFT; | 336 | MX1_CSPICTRL_DR_SHIFT; |
337 | reg |= config->bpw - 1; | 337 | reg |= config->bpw - 1; |
338 | 338 | ||
@@ -341,156 +341,151 @@ static int mx1_config(struct mxc_spi_data *mxc_spi, | |||
341 | if (config->mode & SPI_CPOL) | 341 | if (config->mode & SPI_CPOL) |
342 | reg |= MX1_CSPICTRL_POL; | 342 | reg |= MX1_CSPICTRL_POL; |
343 | 343 | ||
344 | writel(reg, mxc_spi->base + MXC_CSPICTRL); | 344 | writel(reg, spi_imx->base + MXC_CSPICTRL); |
345 | 345 | ||
346 | return 0; | 346 | return 0; |
347 | } | 347 | } |
348 | 348 | ||
349 | static int mx1_rx_available(struct mxc_spi_data *mxc_spi) | 349 | static int mx1_rx_available(struct spi_imx_data *spi_imx) |
350 | { | 350 | { |
351 | return readl(mxc_spi->base + MXC_CSPIINT) & MX1_INTREG_RR; | 351 | return readl(spi_imx->base + MXC_CSPIINT) & MX1_INTREG_RR; |
352 | } | 352 | } |
353 | 353 | ||
354 | static void mxc_spi_chipselect(struct spi_device *spi, int is_active) | 354 | static void spi_imx_chipselect(struct spi_device *spi, int is_active) |
355 | { | 355 | { |
356 | struct mxc_spi_data *mxc_spi = spi_master_get_devdata(spi->master); | 356 | struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master); |
357 | unsigned int cs = 0; | 357 | int gpio = spi_imx->chipselect[spi->chip_select]; |
358 | int gpio = mxc_spi->chipselect[spi->chip_select]; | 358 | int active = is_active != BITBANG_CS_INACTIVE; |
359 | struct mxc_spi_config config; | 359 | int dev_is_lowactive = !(spi->mode & SPI_CS_HIGH); |
360 | 360 | ||
361 | if (spi->mode & SPI_CS_HIGH) | 361 | if (gpio < 0) |
362 | cs = 1; | ||
363 | |||
364 | if (is_active == BITBANG_CS_INACTIVE) { | ||
365 | if (gpio >= 0) | ||
366 | gpio_set_value(gpio, !cs); | ||
367 | return; | 362 | return; |
368 | } | ||
369 | |||
370 | config.bpw = spi->bits_per_word; | ||
371 | config.speed_hz = spi->max_speed_hz; | ||
372 | config.mode = spi->mode; | ||
373 | config.cs = mxc_spi->chipselect[spi->chip_select]; | ||
374 | |||
375 | mxc_spi->config(mxc_spi, &config); | ||
376 | |||
377 | /* Initialize the functions for transfer */ | ||
378 | if (config.bpw <= 8) { | ||
379 | mxc_spi->rx = mxc_spi_buf_rx_u8; | ||
380 | mxc_spi->tx = mxc_spi_buf_tx_u8; | ||
381 | } else if (config.bpw <= 16) { | ||
382 | mxc_spi->rx = mxc_spi_buf_rx_u16; | ||
383 | mxc_spi->tx = mxc_spi_buf_tx_u16; | ||
384 | } else if (config.bpw <= 32) { | ||
385 | mxc_spi->rx = mxc_spi_buf_rx_u32; | ||
386 | mxc_spi->tx = mxc_spi_buf_tx_u32; | ||
387 | } else | ||
388 | BUG(); | ||
389 | 363 | ||
390 | if (gpio >= 0) | 364 | gpio_set_value(gpio, dev_is_lowactive ^ active); |
391 | gpio_set_value(gpio, cs); | ||
392 | |||
393 | return; | ||
394 | } | 365 | } |
395 | 366 | ||
396 | static void mxc_spi_push(struct mxc_spi_data *mxc_spi) | 367 | static void spi_imx_push(struct spi_imx_data *spi_imx) |
397 | { | 368 | { |
398 | while (mxc_spi->txfifo < 8) { | 369 | while (spi_imx->txfifo < 8) { |
399 | if (!mxc_spi->count) | 370 | if (!spi_imx->count) |
400 | break; | 371 | break; |
401 | mxc_spi->tx(mxc_spi); | 372 | spi_imx->tx(spi_imx); |
402 | mxc_spi->txfifo++; | 373 | spi_imx->txfifo++; |
403 | } | 374 | } |
404 | 375 | ||
405 | mxc_spi->trigger(mxc_spi); | 376 | spi_imx->trigger(spi_imx); |
406 | } | 377 | } |
407 | 378 | ||
408 | static irqreturn_t mxc_spi_isr(int irq, void *dev_id) | 379 | static irqreturn_t spi_imx_isr(int irq, void *dev_id) |
409 | { | 380 | { |
410 | struct mxc_spi_data *mxc_spi = dev_id; | 381 | struct spi_imx_data *spi_imx = dev_id; |
411 | 382 | ||
412 | while (mxc_spi->rx_available(mxc_spi)) { | 383 | while (spi_imx->rx_available(spi_imx)) { |
413 | mxc_spi->rx(mxc_spi); | 384 | spi_imx->rx(spi_imx); |
414 | mxc_spi->txfifo--; | 385 | spi_imx->txfifo--; |
415 | } | 386 | } |
416 | 387 | ||
417 | if (mxc_spi->count) { | 388 | if (spi_imx->count) { |
418 | mxc_spi_push(mxc_spi); | 389 | spi_imx_push(spi_imx); |
419 | return IRQ_HANDLED; | 390 | return IRQ_HANDLED; |
420 | } | 391 | } |
421 | 392 | ||
422 | if (mxc_spi->txfifo) { | 393 | if (spi_imx->txfifo) { |
423 | /* No data left to push, but still waiting for rx data, | 394 | /* No data left to push, but still waiting for rx data, |
424 | * enable receive data available interrupt. | 395 | * enable receive data available interrupt. |
425 | */ | 396 | */ |
426 | mxc_spi->intctrl(mxc_spi, MXC_INT_RR); | 397 | spi_imx->intctrl(spi_imx, MXC_INT_RR); |
427 | return IRQ_HANDLED; | 398 | return IRQ_HANDLED; |
428 | } | 399 | } |
429 | 400 | ||
430 | mxc_spi->intctrl(mxc_spi, 0); | 401 | spi_imx->intctrl(spi_imx, 0); |
431 | complete(&mxc_spi->xfer_done); | 402 | complete(&spi_imx->xfer_done); |
432 | 403 | ||
433 | return IRQ_HANDLED; | 404 | return IRQ_HANDLED; |
434 | } | 405 | } |
435 | 406 | ||
436 | static int mxc_spi_setupxfer(struct spi_device *spi, | 407 | static int spi_imx_setupxfer(struct spi_device *spi, |
437 | struct spi_transfer *t) | 408 | struct spi_transfer *t) |
438 | { | 409 | { |
439 | struct mxc_spi_data *mxc_spi = spi_master_get_devdata(spi->master); | 410 | struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master); |
440 | struct mxc_spi_config config; | 411 | struct spi_imx_config config; |
441 | 412 | ||
442 | config.bpw = t ? t->bits_per_word : spi->bits_per_word; | 413 | config.bpw = t ? t->bits_per_word : spi->bits_per_word; |
443 | config.speed_hz = t ? t->speed_hz : spi->max_speed_hz; | 414 | config.speed_hz = t ? t->speed_hz : spi->max_speed_hz; |
444 | config.mode = spi->mode; | 415 | config.mode = spi->mode; |
416 | config.cs = spi_imx->chipselect[spi->chip_select]; | ||
417 | |||
418 | if (!config.speed_hz) | ||
419 | config.speed_hz = spi->max_speed_hz; | ||
420 | if (!config.bpw) | ||
421 | config.bpw = spi->bits_per_word; | ||
422 | if (!config.speed_hz) | ||
423 | config.speed_hz = spi->max_speed_hz; | ||
424 | |||
425 | /* Initialize the functions for transfer */ | ||
426 | if (config.bpw <= 8) { | ||
427 | spi_imx->rx = spi_imx_buf_rx_u8; | ||
428 | spi_imx->tx = spi_imx_buf_tx_u8; | ||
429 | } else if (config.bpw <= 16) { | ||
430 | spi_imx->rx = spi_imx_buf_rx_u16; | ||
431 | spi_imx->tx = spi_imx_buf_tx_u16; | ||
432 | } else if (config.bpw <= 32) { | ||
433 | spi_imx->rx = spi_imx_buf_rx_u32; | ||
434 | spi_imx->tx = spi_imx_buf_tx_u32; | ||
435 | } else | ||
436 | BUG(); | ||
445 | 437 | ||
446 | mxc_spi->config(mxc_spi, &config); | 438 | spi_imx->config(spi_imx, &config); |
447 | 439 | ||
448 | return 0; | 440 | return 0; |
449 | } | 441 | } |
450 | 442 | ||
451 | static int mxc_spi_transfer(struct spi_device *spi, | 443 | static int spi_imx_transfer(struct spi_device *spi, |
452 | struct spi_transfer *transfer) | 444 | struct spi_transfer *transfer) |
453 | { | 445 | { |
454 | struct mxc_spi_data *mxc_spi = spi_master_get_devdata(spi->master); | 446 | struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master); |
455 | 447 | ||
456 | mxc_spi->tx_buf = transfer->tx_buf; | 448 | spi_imx->tx_buf = transfer->tx_buf; |
457 | mxc_spi->rx_buf = transfer->rx_buf; | 449 | spi_imx->rx_buf = transfer->rx_buf; |
458 | mxc_spi->count = transfer->len; | 450 | spi_imx->count = transfer->len; |
459 | mxc_spi->txfifo = 0; | 451 | spi_imx->txfifo = 0; |
460 | 452 | ||
461 | init_completion(&mxc_spi->xfer_done); | 453 | init_completion(&spi_imx->xfer_done); |
462 | 454 | ||
463 | mxc_spi_push(mxc_spi); | 455 | spi_imx_push(spi_imx); |
464 | 456 | ||
465 | mxc_spi->intctrl(mxc_spi, MXC_INT_TE); | 457 | spi_imx->intctrl(spi_imx, MXC_INT_TE); |
466 | 458 | ||
467 | wait_for_completion(&mxc_spi->xfer_done); | 459 | wait_for_completion(&spi_imx->xfer_done); |
468 | 460 | ||
469 | return transfer->len; | 461 | return transfer->len; |
470 | } | 462 | } |
471 | 463 | ||
472 | static int mxc_spi_setup(struct spi_device *spi) | 464 | static int spi_imx_setup(struct spi_device *spi) |
473 | { | 465 | { |
474 | if (!spi->bits_per_word) | 466 | struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master); |
475 | spi->bits_per_word = 8; | 467 | int gpio = spi_imx->chipselect[spi->chip_select]; |
476 | 468 | ||
477 | pr_debug("%s: mode %d, %u bpw, %d hz\n", __func__, | 469 | pr_debug("%s: mode %d, %u bpw, %d hz\n", __func__, |
478 | spi->mode, spi->bits_per_word, spi->max_speed_hz); | 470 | spi->mode, spi->bits_per_word, spi->max_speed_hz); |
479 | 471 | ||
480 | mxc_spi_chipselect(spi, BITBANG_CS_INACTIVE); | 472 | if (gpio >= 0) |
473 | gpio_direction_output(gpio, spi->mode & SPI_CS_HIGH ? 0 : 1); | ||
474 | |||
475 | spi_imx_chipselect(spi, BITBANG_CS_INACTIVE); | ||
481 | 476 | ||
482 | return 0; | 477 | return 0; |
483 | } | 478 | } |
484 | 479 | ||
485 | static void mxc_spi_cleanup(struct spi_device *spi) | 480 | static void spi_imx_cleanup(struct spi_device *spi) |
486 | { | 481 | { |
487 | } | 482 | } |
488 | 483 | ||
489 | static int __init mxc_spi_probe(struct platform_device *pdev) | 484 | static int __init spi_imx_probe(struct platform_device *pdev) |
490 | { | 485 | { |
491 | struct spi_imx_master *mxc_platform_info; | 486 | struct spi_imx_master *mxc_platform_info; |
492 | struct spi_master *master; | 487 | struct spi_master *master; |
493 | struct mxc_spi_data *mxc_spi; | 488 | struct spi_imx_data *spi_imx; |
494 | struct resource *res; | 489 | struct resource *res; |
495 | int i, ret; | 490 | int i, ret; |
496 | 491 | ||
@@ -500,7 +495,7 @@ static int __init mxc_spi_probe(struct platform_device *pdev) | |||
500 | return -EINVAL; | 495 | return -EINVAL; |
501 | } | 496 | } |
502 | 497 | ||
503 | master = spi_alloc_master(&pdev->dev, sizeof(struct mxc_spi_data)); | 498 | master = spi_alloc_master(&pdev->dev, sizeof(struct spi_imx_data)); |
504 | if (!master) | 499 | if (!master) |
505 | return -ENOMEM; | 500 | return -ENOMEM; |
506 | 501 | ||
@@ -509,32 +504,32 @@ static int __init mxc_spi_probe(struct platform_device *pdev) | |||
509 | master->bus_num = pdev->id; | 504 | master->bus_num = pdev->id; |
510 | master->num_chipselect = mxc_platform_info->num_chipselect; | 505 | master->num_chipselect = mxc_platform_info->num_chipselect; |
511 | 506 | ||
512 | mxc_spi = spi_master_get_devdata(master); | 507 | spi_imx = spi_master_get_devdata(master); |
513 | mxc_spi->bitbang.master = spi_master_get(master); | 508 | spi_imx->bitbang.master = spi_master_get(master); |
514 | mxc_spi->chipselect = mxc_platform_info->chipselect; | 509 | spi_imx->chipselect = mxc_platform_info->chipselect; |
515 | 510 | ||
516 | for (i = 0; i < master->num_chipselect; i++) { | 511 | for (i = 0; i < master->num_chipselect; i++) { |
517 | if (mxc_spi->chipselect[i] < 0) | 512 | if (spi_imx->chipselect[i] < 0) |
518 | continue; | 513 | continue; |
519 | ret = gpio_request(mxc_spi->chipselect[i], DRIVER_NAME); | 514 | ret = gpio_request(spi_imx->chipselect[i], DRIVER_NAME); |
520 | if (ret) { | 515 | if (ret) { |
521 | i--; | 516 | i--; |
522 | while (i > 0) | 517 | while (i > 0) |
523 | if (mxc_spi->chipselect[i] >= 0) | 518 | if (spi_imx->chipselect[i] >= 0) |
524 | gpio_free(mxc_spi->chipselect[i--]); | 519 | gpio_free(spi_imx->chipselect[i--]); |
525 | dev_err(&pdev->dev, "can't get cs gpios"); | 520 | dev_err(&pdev->dev, "can't get cs gpios"); |
526 | goto out_master_put; | 521 | goto out_master_put; |
527 | } | 522 | } |
528 | gpio_direction_output(mxc_spi->chipselect[i], 1); | ||
529 | } | 523 | } |
530 | 524 | ||
531 | mxc_spi->bitbang.chipselect = mxc_spi_chipselect; | 525 | spi_imx->bitbang.chipselect = spi_imx_chipselect; |
532 | mxc_spi->bitbang.setup_transfer = mxc_spi_setupxfer; | 526 | spi_imx->bitbang.setup_transfer = spi_imx_setupxfer; |
533 | mxc_spi->bitbang.txrx_bufs = mxc_spi_transfer; | 527 | spi_imx->bitbang.txrx_bufs = spi_imx_transfer; |
534 | mxc_spi->bitbang.master->setup = mxc_spi_setup; | 528 | spi_imx->bitbang.master->setup = spi_imx_setup; |
535 | mxc_spi->bitbang.master->cleanup = mxc_spi_cleanup; | 529 | spi_imx->bitbang.master->cleanup = spi_imx_cleanup; |
530 | spi_imx->bitbang.master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH; | ||
536 | 531 | ||
537 | init_completion(&mxc_spi->xfer_done); | 532 | init_completion(&spi_imx->xfer_done); |
538 | 533 | ||
539 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | 534 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
540 | if (!res) { | 535 | if (!res) { |
@@ -549,58 +544,58 @@ static int __init mxc_spi_probe(struct platform_device *pdev) | |||
549 | goto out_gpio_free; | 544 | goto out_gpio_free; |
550 | } | 545 | } |
551 | 546 | ||
552 | mxc_spi->base = ioremap(res->start, resource_size(res)); | 547 | spi_imx->base = ioremap(res->start, resource_size(res)); |
553 | if (!mxc_spi->base) { | 548 | if (!spi_imx->base) { |
554 | ret = -EINVAL; | 549 | ret = -EINVAL; |
555 | goto out_release_mem; | 550 | goto out_release_mem; |
556 | } | 551 | } |
557 | 552 | ||
558 | mxc_spi->irq = platform_get_irq(pdev, 0); | 553 | spi_imx->irq = platform_get_irq(pdev, 0); |
559 | if (!mxc_spi->irq) { | 554 | if (!spi_imx->irq) { |
560 | ret = -EINVAL; | 555 | ret = -EINVAL; |
561 | goto out_iounmap; | 556 | goto out_iounmap; |
562 | } | 557 | } |
563 | 558 | ||
564 | ret = request_irq(mxc_spi->irq, mxc_spi_isr, 0, DRIVER_NAME, mxc_spi); | 559 | ret = request_irq(spi_imx->irq, spi_imx_isr, 0, DRIVER_NAME, spi_imx); |
565 | if (ret) { | 560 | if (ret) { |
566 | dev_err(&pdev->dev, "can't get irq%d: %d\n", mxc_spi->irq, ret); | 561 | dev_err(&pdev->dev, "can't get irq%d: %d\n", spi_imx->irq, ret); |
567 | goto out_iounmap; | 562 | goto out_iounmap; |
568 | } | 563 | } |
569 | 564 | ||
570 | if (cpu_is_mx31() || cpu_is_mx35()) { | 565 | if (cpu_is_mx31() || cpu_is_mx35()) { |
571 | mxc_spi->intctrl = mx31_intctrl; | 566 | spi_imx->intctrl = mx31_intctrl; |
572 | mxc_spi->config = mx31_config; | 567 | spi_imx->config = mx31_config; |
573 | mxc_spi->trigger = mx31_trigger; | 568 | spi_imx->trigger = mx31_trigger; |
574 | mxc_spi->rx_available = mx31_rx_available; | 569 | spi_imx->rx_available = mx31_rx_available; |
575 | } else if (cpu_is_mx27() || cpu_is_mx21()) { | 570 | } else if (cpu_is_mx27() || cpu_is_mx21()) { |
576 | mxc_spi->intctrl = mx27_intctrl; | 571 | spi_imx->intctrl = mx27_intctrl; |
577 | mxc_spi->config = mx27_config; | 572 | spi_imx->config = mx27_config; |
578 | mxc_spi->trigger = mx27_trigger; | 573 | spi_imx->trigger = mx27_trigger; |
579 | mxc_spi->rx_available = mx27_rx_available; | 574 | spi_imx->rx_available = mx27_rx_available; |
580 | } else if (cpu_is_mx1()) { | 575 | } else if (cpu_is_mx1()) { |
581 | mxc_spi->intctrl = mx1_intctrl; | 576 | spi_imx->intctrl = mx1_intctrl; |
582 | mxc_spi->config = mx1_config; | 577 | spi_imx->config = mx1_config; |
583 | mxc_spi->trigger = mx1_trigger; | 578 | spi_imx->trigger = mx1_trigger; |
584 | mxc_spi->rx_available = mx1_rx_available; | 579 | spi_imx->rx_available = mx1_rx_available; |
585 | } else | 580 | } else |
586 | BUG(); | 581 | BUG(); |
587 | 582 | ||
588 | mxc_spi->clk = clk_get(&pdev->dev, NULL); | 583 | spi_imx->clk = clk_get(&pdev->dev, NULL); |
589 | if (IS_ERR(mxc_spi->clk)) { | 584 | if (IS_ERR(spi_imx->clk)) { |
590 | dev_err(&pdev->dev, "unable to get clock\n"); | 585 | dev_err(&pdev->dev, "unable to get clock\n"); |
591 | ret = PTR_ERR(mxc_spi->clk); | 586 | ret = PTR_ERR(spi_imx->clk); |
592 | goto out_free_irq; | 587 | goto out_free_irq; |
593 | } | 588 | } |
594 | 589 | ||
595 | clk_enable(mxc_spi->clk); | 590 | clk_enable(spi_imx->clk); |
596 | mxc_spi->spi_clk = clk_get_rate(mxc_spi->clk); | 591 | spi_imx->spi_clk = clk_get_rate(spi_imx->clk); |
597 | 592 | ||
598 | if (!cpu_is_mx31() || !cpu_is_mx35()) | 593 | if (!cpu_is_mx31() || !cpu_is_mx35()) |
599 | writel(1, mxc_spi->base + MXC_RESET); | 594 | writel(1, spi_imx->base + MXC_RESET); |
600 | 595 | ||
601 | mxc_spi->intctrl(mxc_spi, 0); | 596 | spi_imx->intctrl(spi_imx, 0); |
602 | 597 | ||
603 | ret = spi_bitbang_start(&mxc_spi->bitbang); | 598 | ret = spi_bitbang_start(&spi_imx->bitbang); |
604 | if (ret) { | 599 | if (ret) { |
605 | dev_err(&pdev->dev, "bitbang start failed with %d\n", ret); | 600 | dev_err(&pdev->dev, "bitbang start failed with %d\n", ret); |
606 | goto out_clk_put; | 601 | goto out_clk_put; |
@@ -611,18 +606,18 @@ static int __init mxc_spi_probe(struct platform_device *pdev) | |||
611 | return ret; | 606 | return ret; |
612 | 607 | ||
613 | out_clk_put: | 608 | out_clk_put: |
614 | clk_disable(mxc_spi->clk); | 609 | clk_disable(spi_imx->clk); |
615 | clk_put(mxc_spi->clk); | 610 | clk_put(spi_imx->clk); |
616 | out_free_irq: | 611 | out_free_irq: |
617 | free_irq(mxc_spi->irq, mxc_spi); | 612 | free_irq(spi_imx->irq, spi_imx); |
618 | out_iounmap: | 613 | out_iounmap: |
619 | iounmap(mxc_spi->base); | 614 | iounmap(spi_imx->base); |
620 | out_release_mem: | 615 | out_release_mem: |
621 | release_mem_region(res->start, resource_size(res)); | 616 | release_mem_region(res->start, resource_size(res)); |
622 | out_gpio_free: | 617 | out_gpio_free: |
623 | for (i = 0; i < master->num_chipselect; i++) | 618 | for (i = 0; i < master->num_chipselect; i++) |
624 | if (mxc_spi->chipselect[i] >= 0) | 619 | if (spi_imx->chipselect[i] >= 0) |
625 | gpio_free(mxc_spi->chipselect[i]); | 620 | gpio_free(spi_imx->chipselect[i]); |
626 | out_master_put: | 621 | out_master_put: |
627 | spi_master_put(master); | 622 | spi_master_put(master); |
628 | kfree(master); | 623 | kfree(master); |
@@ -630,24 +625,24 @@ out_master_put: | |||
630 | return ret; | 625 | return ret; |
631 | } | 626 | } |
632 | 627 | ||
633 | static int __exit mxc_spi_remove(struct platform_device *pdev) | 628 | static int __exit spi_imx_remove(struct platform_device *pdev) |
634 | { | 629 | { |
635 | struct spi_master *master = platform_get_drvdata(pdev); | 630 | struct spi_master *master = platform_get_drvdata(pdev); |
636 | struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | 631 | struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
637 | struct mxc_spi_data *mxc_spi = spi_master_get_devdata(master); | 632 | struct spi_imx_data *spi_imx = spi_master_get_devdata(master); |
638 | int i; | 633 | int i; |
639 | 634 | ||
640 | spi_bitbang_stop(&mxc_spi->bitbang); | 635 | spi_bitbang_stop(&spi_imx->bitbang); |
641 | 636 | ||
642 | writel(0, mxc_spi->base + MXC_CSPICTRL); | 637 | writel(0, spi_imx->base + MXC_CSPICTRL); |
643 | clk_disable(mxc_spi->clk); | 638 | clk_disable(spi_imx->clk); |
644 | clk_put(mxc_spi->clk); | 639 | clk_put(spi_imx->clk); |
645 | free_irq(mxc_spi->irq, mxc_spi); | 640 | free_irq(spi_imx->irq, spi_imx); |
646 | iounmap(mxc_spi->base); | 641 | iounmap(spi_imx->base); |
647 | 642 | ||
648 | for (i = 0; i < master->num_chipselect; i++) | 643 | for (i = 0; i < master->num_chipselect; i++) |
649 | if (mxc_spi->chipselect[i] >= 0) | 644 | if (spi_imx->chipselect[i] >= 0) |
650 | gpio_free(mxc_spi->chipselect[i]); | 645 | gpio_free(spi_imx->chipselect[i]); |
651 | 646 | ||
652 | spi_master_put(master); | 647 | spi_master_put(master); |
653 | 648 | ||
@@ -658,27 +653,27 @@ static int __exit mxc_spi_remove(struct platform_device *pdev) | |||
658 | return 0; | 653 | return 0; |
659 | } | 654 | } |
660 | 655 | ||
661 | static struct platform_driver mxc_spi_driver = { | 656 | static struct platform_driver spi_imx_driver = { |
662 | .driver = { | 657 | .driver = { |
663 | .name = DRIVER_NAME, | 658 | .name = DRIVER_NAME, |
664 | .owner = THIS_MODULE, | 659 | .owner = THIS_MODULE, |
665 | }, | 660 | }, |
666 | .probe = mxc_spi_probe, | 661 | .probe = spi_imx_probe, |
667 | .remove = __exit_p(mxc_spi_remove), | 662 | .remove = __exit_p(spi_imx_remove), |
668 | }; | 663 | }; |
669 | 664 | ||
670 | static int __init mxc_spi_init(void) | 665 | static int __init spi_imx_init(void) |
671 | { | 666 | { |
672 | return platform_driver_register(&mxc_spi_driver); | 667 | return platform_driver_register(&spi_imx_driver); |
673 | } | 668 | } |
674 | 669 | ||
675 | static void __exit mxc_spi_exit(void) | 670 | static void __exit spi_imx_exit(void) |
676 | { | 671 | { |
677 | platform_driver_unregister(&mxc_spi_driver); | 672 | platform_driver_unregister(&spi_imx_driver); |
678 | } | 673 | } |
679 | 674 | ||
680 | module_init(mxc_spi_init); | 675 | module_init(spi_imx_init); |
681 | module_exit(mxc_spi_exit); | 676 | module_exit(spi_imx_exit); |
682 | 677 | ||
683 | MODULE_DESCRIPTION("SPI Master Controller driver"); | 678 | MODULE_DESCRIPTION("SPI Master Controller driver"); |
684 | MODULE_AUTHOR("Sascha Hauer, Pengutronix"); | 679 | MODULE_AUTHOR("Sascha Hauer, Pengutronix"); |
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c index f921bd1109e1..5d23983f02fc 100644 --- a/drivers/spi/spidev.c +++ b/drivers/spi/spidev.c | |||
@@ -537,7 +537,7 @@ static int spidev_release(struct inode *inode, struct file *filp) | |||
537 | return status; | 537 | return status; |
538 | } | 538 | } |
539 | 539 | ||
540 | static struct file_operations spidev_fops = { | 540 | static const struct file_operations spidev_fops = { |
541 | .owner = THIS_MODULE, | 541 | .owner = THIS_MODULE, |
542 | /* REVISIT switch to aio primitives, so that userspace | 542 | /* REVISIT switch to aio primitives, so that userspace |
543 | * gets more complete API coverage. It'll simplify things | 543 | * gets more complete API coverage. It'll simplify things |
diff --git a/drivers/staging/dst/dcore.c b/drivers/staging/dst/dcore.c index ac8577358ba0..c24e4e0367a2 100644 --- a/drivers/staging/dst/dcore.c +++ b/drivers/staging/dst/dcore.c | |||
@@ -102,7 +102,7 @@ static int dst_request(struct request_queue *q, struct bio *bio) | |||
102 | struct dst_node *n = q->queuedata; | 102 | struct dst_node *n = q->queuedata; |
103 | int err = -EIO; | 103 | int err = -EIO; |
104 | 104 | ||
105 | if (bio_empty_barrier(bio) && !q->prepare_discard_fn) { | 105 | if (bio_empty_barrier(bio) && !blk_queue_discard(q)) { |
106 | /* | 106 | /* |
107 | * This is a dirty^Wnice hack, but if we complete this | 107 | * This is a dirty^Wnice hack, but if we complete this |
108 | * operation with -EOPNOTSUPP like intended, XFS | 108 | * operation with -EOPNOTSUPP like intended, XFS |
@@ -847,7 +847,7 @@ static dst_command_func dst_commands[] = { | |||
847 | /* | 847 | /* |
848 | * Configuration parser. | 848 | * Configuration parser. |
849 | */ | 849 | */ |
850 | static void cn_dst_callback(struct cn_msg *msg) | 850 | static void cn_dst_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) |
851 | { | 851 | { |
852 | struct dst_ctl *ctl; | 852 | struct dst_ctl *ctl; |
853 | int err; | 853 | int err; |
@@ -855,6 +855,11 @@ static void cn_dst_callback(struct cn_msg *msg) | |||
855 | struct dst_node *n = NULL, *tmp; | 855 | struct dst_node *n = NULL, *tmp; |
856 | unsigned int hash; | 856 | unsigned int hash; |
857 | 857 | ||
858 | if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN)) { | ||
859 | err = -EPERM; | ||
860 | goto out; | ||
861 | } | ||
862 | |||
858 | if (msg->len < sizeof(struct dst_ctl)) { | 863 | if (msg->len < sizeof(struct dst_ctl)) { |
859 | err = -EBADMSG; | 864 | err = -EBADMSG; |
860 | goto out; | 865 | goto out; |
diff --git a/drivers/staging/iio/light/tsl2561.c b/drivers/staging/iio/light/tsl2561.c index ea8a5efc19bc..fc2107f4c049 100644 --- a/drivers/staging/iio/light/tsl2561.c +++ b/drivers/staging/iio/light/tsl2561.c | |||
@@ -239,10 +239,6 @@ static int __devexit tsl2561_remove(struct i2c_client *client) | |||
239 | return tsl2561_powerdown(client); | 239 | return tsl2561_powerdown(client); |
240 | } | 240 | } |
241 | 241 | ||
242 | static unsigned short normal_i2c[] = { 0x29, 0x39, 0x49, I2C_CLIENT_END }; | ||
243 | |||
244 | I2C_CLIENT_INSMOD; | ||
245 | |||
246 | static const struct i2c_device_id tsl2561_id[] = { | 242 | static const struct i2c_device_id tsl2561_id[] = { |
247 | { "tsl2561", 0 }, | 243 | { "tsl2561", 0 }, |
248 | { } | 244 | { } |
diff --git a/drivers/staging/pohmelfs/config.c b/drivers/staging/pohmelfs/config.c index 90f962ee5fd8..5d04bf5b021a 100644 --- a/drivers/staging/pohmelfs/config.c +++ b/drivers/staging/pohmelfs/config.c | |||
@@ -527,10 +527,13 @@ out_unlock: | |||
527 | return err; | 527 | return err; |
528 | } | 528 | } |
529 | 529 | ||
530 | static void pohmelfs_cn_callback(struct cn_msg *msg) | 530 | static void pohmelfs_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) |
531 | { | 531 | { |
532 | int err; | 532 | int err; |
533 | 533 | ||
534 | if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN)) | ||
535 | return; | ||
536 | |||
534 | switch (msg->flags) { | 537 | switch (msg->flags) { |
535 | case POHMELFS_FLAGS_ADD: | 538 | case POHMELFS_FLAGS_ADD: |
536 | case POHMELFS_FLAGS_DEL: | 539 | case POHMELFS_FLAGS_DEL: |
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c index 333ee02e7b2b..864f0ba6a344 100644 --- a/drivers/usb/class/usbtmc.c +++ b/drivers/usb/class/usbtmc.c | |||
@@ -993,7 +993,7 @@ skip_io_on_zombie: | |||
993 | return retval; | 993 | return retval; |
994 | } | 994 | } |
995 | 995 | ||
996 | static struct file_operations fops = { | 996 | static const struct file_operations fops = { |
997 | .owner = THIS_MODULE, | 997 | .owner = THIS_MODULE, |
998 | .read = usbtmc_read, | 998 | .read = usbtmc_read, |
999 | .write = usbtmc_write, | 999 | .write = usbtmc_write, |
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c index c44367fea185..bf0f6520c6df 100644 --- a/drivers/usb/gadget/inode.c +++ b/drivers/usb/gadget/inode.c | |||
@@ -30,6 +30,7 @@ | |||
30 | #include <linux/wait.h> | 30 | #include <linux/wait.h> |
31 | #include <linux/compiler.h> | 31 | #include <linux/compiler.h> |
32 | #include <asm/uaccess.h> | 32 | #include <asm/uaccess.h> |
33 | #include <linux/sched.h> | ||
33 | #include <linux/slab.h> | 34 | #include <linux/slab.h> |
34 | #include <linux/poll.h> | 35 | #include <linux/poll.h> |
35 | #include <linux/smp_lock.h> | 36 | #include <linux/smp_lock.h> |
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c index 29500154d00c..2d867fd22413 100644 --- a/drivers/usb/gadget/printer.c +++ b/drivers/usb/gadget/printer.c | |||
@@ -875,7 +875,7 @@ printer_ioctl(struct file *fd, unsigned int code, unsigned long arg) | |||
875 | } | 875 | } |
876 | 876 | ||
877 | /* used after endpoint configuration */ | 877 | /* used after endpoint configuration */ |
878 | static struct file_operations printer_io_operations = { | 878 | static const struct file_operations printer_io_operations = { |
879 | .owner = THIS_MODULE, | 879 | .owner = THIS_MODULE, |
880 | .open = printer_open, | 880 | .open = printer_open, |
881 | .read = printer_read, | 881 | .read = printer_read, |
diff --git a/drivers/usb/host/whci/debug.c b/drivers/usb/host/whci/debug.c index cf2d45946c57..2273c815941f 100644 --- a/drivers/usb/host/whci/debug.c +++ b/drivers/usb/host/whci/debug.c | |||
@@ -134,7 +134,7 @@ static int pzl_open(struct inode *inode, struct file *file) | |||
134 | return single_open(file, pzl_print, inode->i_private); | 134 | return single_open(file, pzl_print, inode->i_private); |
135 | } | 135 | } |
136 | 136 | ||
137 | static struct file_operations di_fops = { | 137 | static const struct file_operations di_fops = { |
138 | .open = di_open, | 138 | .open = di_open, |
139 | .read = seq_read, | 139 | .read = seq_read, |
140 | .llseek = seq_lseek, | 140 | .llseek = seq_lseek, |
@@ -142,7 +142,7 @@ static struct file_operations di_fops = { | |||
142 | .owner = THIS_MODULE, | 142 | .owner = THIS_MODULE, |
143 | }; | 143 | }; |
144 | 144 | ||
145 | static struct file_operations asl_fops = { | 145 | static const struct file_operations asl_fops = { |
146 | .open = asl_open, | 146 | .open = asl_open, |
147 | .read = seq_read, | 147 | .read = seq_read, |
148 | .llseek = seq_lseek, | 148 | .llseek = seq_lseek, |
@@ -150,7 +150,7 @@ static struct file_operations asl_fops = { | |||
150 | .owner = THIS_MODULE, | 150 | .owner = THIS_MODULE, |
151 | }; | 151 | }; |
152 | 152 | ||
153 | static struct file_operations pzl_fops = { | 153 | static const struct file_operations pzl_fops = { |
154 | .open = pzl_open, | 154 | .open = pzl_open, |
155 | .read = seq_read, | 155 | .read = seq_read, |
156 | .llseek = seq_lseek, | 156 | .llseek = seq_lseek, |
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c index d645f3899fe1..32d0199d0c32 100644 --- a/drivers/usb/misc/rio500.c +++ b/drivers/usb/misc/rio500.c | |||
@@ -429,8 +429,7 @@ read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos) | |||
429 | return read_count; | 429 | return read_count; |
430 | } | 430 | } |
431 | 431 | ||
432 | static struct | 432 | static const struct file_operations usb_rio_fops = { |
433 | file_operations usb_rio_fops = { | ||
434 | .owner = THIS_MODULE, | 433 | .owner = THIS_MODULE, |
435 | .read = read_rio, | 434 | .read = read_rio, |
436 | .write = write_rio, | 435 | .write = write_rio, |
diff --git a/drivers/uwb/uwb-debug.c b/drivers/uwb/uwb-debug.c index 4a42993700c1..2eecec0c13c9 100644 --- a/drivers/uwb/uwb-debug.c +++ b/drivers/uwb/uwb-debug.c | |||
@@ -205,7 +205,7 @@ static ssize_t command_write(struct file *file, const char __user *buf, | |||
205 | return ret < 0 ? ret : len; | 205 | return ret < 0 ? ret : len; |
206 | } | 206 | } |
207 | 207 | ||
208 | static struct file_operations command_fops = { | 208 | static const struct file_operations command_fops = { |
209 | .open = command_open, | 209 | .open = command_open, |
210 | .write = command_write, | 210 | .write = command_write, |
211 | .read = NULL, | 211 | .read = NULL, |
@@ -255,7 +255,7 @@ static int reservations_open(struct inode *inode, struct file *file) | |||
255 | return single_open(file, reservations_print, inode->i_private); | 255 | return single_open(file, reservations_print, inode->i_private); |
256 | } | 256 | } |
257 | 257 | ||
258 | static struct file_operations reservations_fops = { | 258 | static const struct file_operations reservations_fops = { |
259 | .open = reservations_open, | 259 | .open = reservations_open, |
260 | .read = seq_read, | 260 | .read = seq_read, |
261 | .llseek = seq_lseek, | 261 | .llseek = seq_lseek, |
@@ -283,7 +283,7 @@ static int drp_avail_open(struct inode *inode, struct file *file) | |||
283 | return single_open(file, drp_avail_print, inode->i_private); | 283 | return single_open(file, drp_avail_print, inode->i_private); |
284 | } | 284 | } |
285 | 285 | ||
286 | static struct file_operations drp_avail_fops = { | 286 | static const struct file_operations drp_avail_fops = { |
287 | .open = drp_avail_open, | 287 | .open = drp_avail_open, |
288 | .read = seq_read, | 288 | .read = seq_read, |
289 | .llseek = seq_lseek, | 289 | .llseek = seq_lseek, |
diff --git a/drivers/video/da8xx-fb.c b/drivers/video/da8xx-fb.c index 42e1005e2916..d065894ce38f 100644 --- a/drivers/video/da8xx-fb.c +++ b/drivers/video/da8xx-fb.c | |||
@@ -26,7 +26,6 @@ | |||
26 | #include <linux/device.h> | 26 | #include <linux/device.h> |
27 | #include <linux/platform_device.h> | 27 | #include <linux/platform_device.h> |
28 | #include <linux/uaccess.h> | 28 | #include <linux/uaccess.h> |
29 | #include <linux/device.h> | ||
30 | #include <linux/interrupt.h> | 29 | #include <linux/interrupt.h> |
31 | #include <linux/clk.h> | 30 | #include <linux/clk.h> |
32 | #include <video/da8xx-fb.h> | 31 | #include <video/da8xx-fb.h> |
diff --git a/drivers/video/msm/mddi.c b/drivers/video/msm/mddi.c index f2de5a1acd6d..5c5a1ad1d397 100644 --- a/drivers/video/msm/mddi.c +++ b/drivers/video/msm/mddi.c | |||
@@ -27,8 +27,6 @@ | |||
27 | #include <mach/msm_iomap.h> | 27 | #include <mach/msm_iomap.h> |
28 | #include <mach/irqs.h> | 28 | #include <mach/irqs.h> |
29 | #include <mach/board.h> | 29 | #include <mach/board.h> |
30 | #include <linux/delay.h> | ||
31 | |||
32 | #include <mach/msm_fb.h> | 30 | #include <mach/msm_fb.h> |
33 | #include "mddi_hw.h" | 31 | #include "mddi_hw.h" |
34 | 32 | ||
diff --git a/drivers/video/omap/blizzard.c b/drivers/video/omap/blizzard.c index d5e59556f9e2..70dadf9d2334 100644 --- a/drivers/video/omap/blizzard.c +++ b/drivers/video/omap/blizzard.c | |||
@@ -93,7 +93,7 @@ struct blizzard_reg_list { | |||
93 | }; | 93 | }; |
94 | 94 | ||
95 | /* These need to be saved / restored separately from the rest. */ | 95 | /* These need to be saved / restored separately from the rest. */ |
96 | static struct blizzard_reg_list blizzard_pll_regs[] = { | 96 | static const struct blizzard_reg_list blizzard_pll_regs[] = { |
97 | { | 97 | { |
98 | .start = 0x04, /* Don't save PLL ctrl (0x0C) */ | 98 | .start = 0x04, /* Don't save PLL ctrl (0x0C) */ |
99 | .end = 0x0a, | 99 | .end = 0x0a, |
@@ -104,7 +104,7 @@ static struct blizzard_reg_list blizzard_pll_regs[] = { | |||
104 | }, | 104 | }, |
105 | }; | 105 | }; |
106 | 106 | ||
107 | static struct blizzard_reg_list blizzard_gen_regs[] = { | 107 | static const struct blizzard_reg_list blizzard_gen_regs[] = { |
108 | { | 108 | { |
109 | .start = 0x18, /* SDRAM control */ | 109 | .start = 0x18, /* SDRAM control */ |
110 | .end = 0x20, | 110 | .end = 0x20, |
@@ -191,7 +191,7 @@ struct blizzard_struct { | |||
191 | 191 | ||
192 | struct omapfb_device *fbdev; | 192 | struct omapfb_device *fbdev; |
193 | struct lcd_ctrl_extif *extif; | 193 | struct lcd_ctrl_extif *extif; |
194 | struct lcd_ctrl *int_ctrl; | 194 | const struct lcd_ctrl *int_ctrl; |
195 | 195 | ||
196 | void (*power_up)(struct device *dev); | 196 | void (*power_up)(struct device *dev); |
197 | void (*power_down)(struct device *dev); | 197 | void (*power_down)(struct device *dev); |
@@ -1372,7 +1372,7 @@ static void blizzard_get_caps(int plane, struct omapfb_caps *caps) | |||
1372 | (1 << OMAPFB_COLOR_YUV420); | 1372 | (1 << OMAPFB_COLOR_YUV420); |
1373 | } | 1373 | } |
1374 | 1374 | ||
1375 | static void _save_regs(struct blizzard_reg_list *list, int cnt) | 1375 | static void _save_regs(const struct blizzard_reg_list *list, int cnt) |
1376 | { | 1376 | { |
1377 | int i; | 1377 | int i; |
1378 | 1378 | ||
@@ -1383,7 +1383,7 @@ static void _save_regs(struct blizzard_reg_list *list, int cnt) | |||
1383 | } | 1383 | } |
1384 | } | 1384 | } |
1385 | 1385 | ||
1386 | static void _restore_regs(struct blizzard_reg_list *list, int cnt) | 1386 | static void _restore_regs(const struct blizzard_reg_list *list, int cnt) |
1387 | { | 1387 | { |
1388 | int i; | 1388 | int i; |
1389 | 1389 | ||
diff --git a/drivers/video/omap/omapfb_main.c b/drivers/video/omap/omapfb_main.c index 125e605b8c68..0d0c8c8b9b56 100644 --- a/drivers/video/omap/omapfb_main.c +++ b/drivers/video/omap/omapfb_main.c | |||
@@ -393,7 +393,7 @@ static void omapfb_sync(struct fb_info *fbi) | |||
393 | * Set fb_info.fix fields and also updates fbdev. | 393 | * Set fb_info.fix fields and also updates fbdev. |
394 | * When calling this fb_info.var must be set up already. | 394 | * When calling this fb_info.var must be set up already. |
395 | */ | 395 | */ |
396 | static void set_fb_fix(struct fb_info *fbi) | 396 | static void set_fb_fix(struct fb_info *fbi, int from_init) |
397 | { | 397 | { |
398 | struct fb_fix_screeninfo *fix = &fbi->fix; | 398 | struct fb_fix_screeninfo *fix = &fbi->fix; |
399 | struct fb_var_screeninfo *var = &fbi->var; | 399 | struct fb_var_screeninfo *var = &fbi->var; |
@@ -403,10 +403,16 @@ static void set_fb_fix(struct fb_info *fbi) | |||
403 | 403 | ||
404 | rg = &plane->fbdev->mem_desc.region[plane->idx]; | 404 | rg = &plane->fbdev->mem_desc.region[plane->idx]; |
405 | fbi->screen_base = rg->vaddr; | 405 | fbi->screen_base = rg->vaddr; |
406 | mutex_lock(&fbi->mm_lock); | 406 | |
407 | fix->smem_start = rg->paddr; | 407 | if (!from_init) { |
408 | fix->smem_len = rg->size; | 408 | mutex_lock(&fbi->mm_lock); |
409 | mutex_unlock(&fbi->mm_lock); | 409 | fix->smem_start = rg->paddr; |
410 | fix->smem_len = rg->size; | ||
411 | mutex_unlock(&fbi->mm_lock); | ||
412 | } else { | ||
413 | fix->smem_start = rg->paddr; | ||
414 | fix->smem_len = rg->size; | ||
415 | } | ||
410 | 416 | ||
411 | fix->type = FB_TYPE_PACKED_PIXELS; | 417 | fix->type = FB_TYPE_PACKED_PIXELS; |
412 | bpp = var->bits_per_pixel; | 418 | bpp = var->bits_per_pixel; |
@@ -704,7 +710,7 @@ static int omapfb_set_par(struct fb_info *fbi) | |||
704 | int r = 0; | 710 | int r = 0; |
705 | 711 | ||
706 | omapfb_rqueue_lock(fbdev); | 712 | omapfb_rqueue_lock(fbdev); |
707 | set_fb_fix(fbi); | 713 | set_fb_fix(fbi, 0); |
708 | r = ctrl_change_mode(fbi); | 714 | r = ctrl_change_mode(fbi); |
709 | omapfb_rqueue_unlock(fbdev); | 715 | omapfb_rqueue_unlock(fbdev); |
710 | 716 | ||
@@ -904,7 +910,7 @@ static int omapfb_setup_mem(struct fb_info *fbi, struct omapfb_mem_info *mi) | |||
904 | if (old_size != size) { | 910 | if (old_size != size) { |
905 | if (size) { | 911 | if (size) { |
906 | memcpy(&fbi->var, new_var, sizeof(fbi->var)); | 912 | memcpy(&fbi->var, new_var, sizeof(fbi->var)); |
907 | set_fb_fix(fbi); | 913 | set_fb_fix(fbi, 0); |
908 | } else { | 914 | } else { |
909 | /* | 915 | /* |
910 | * Set these explicitly to indicate that the | 916 | * Set these explicitly to indicate that the |
@@ -1504,7 +1510,7 @@ static int fbinfo_init(struct omapfb_device *fbdev, struct fb_info *info) | |||
1504 | var->bits_per_pixel = fbdev->panel->bpp; | 1510 | var->bits_per_pixel = fbdev->panel->bpp; |
1505 | 1511 | ||
1506 | set_fb_var(info, var); | 1512 | set_fb_var(info, var); |
1507 | set_fb_fix(info); | 1513 | set_fb_fix(info, 1); |
1508 | 1514 | ||
1509 | r = fb_alloc_cmap(&info->cmap, 16, 0); | 1515 | r = fb_alloc_cmap(&info->cmap, 16, 0); |
1510 | if (r != 0) | 1516 | if (r != 0) |
diff --git a/drivers/video/uvesafb.c b/drivers/video/uvesafb.c index e98baf6916b8..e35232a18571 100644 --- a/drivers/video/uvesafb.c +++ b/drivers/video/uvesafb.c | |||
@@ -67,11 +67,14 @@ static DEFINE_MUTEX(uvfb_lock); | |||
67 | * find the kernel part of the task struct, copy the registers and | 67 | * find the kernel part of the task struct, copy the registers and |
68 | * the buffer contents and then complete the task. | 68 | * the buffer contents and then complete the task. |
69 | */ | 69 | */ |
70 | static void uvesafb_cn_callback(struct cn_msg *msg) | 70 | static void uvesafb_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) |
71 | { | 71 | { |
72 | struct uvesafb_task *utask; | 72 | struct uvesafb_task *utask; |
73 | struct uvesafb_ktask *task; | 73 | struct uvesafb_ktask *task; |
74 | 74 | ||
75 | if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN)) | ||
76 | return; | ||
77 | |||
75 | if (msg->seq >= UVESAFB_TASKS_MAX) | 78 | if (msg->seq >= UVESAFB_TASKS_MAX) |
76 | return; | 79 | return; |
77 | 80 | ||
diff --git a/drivers/w1/masters/ds2482.c b/drivers/w1/masters/ds2482.c index df52cb355f7d..406caa6a71cb 100644 --- a/drivers/w1/masters/ds2482.c +++ b/drivers/w1/masters/ds2482.c | |||
@@ -24,19 +24,6 @@ | |||
24 | #include "../w1_int.h" | 24 | #include "../w1_int.h" |
25 | 25 | ||
26 | /** | 26 | /** |
27 | * Address is selected using 2 pins, resulting in 4 possible addresses. | ||
28 | * 0x18, 0x19, 0x1a, 0x1b | ||
29 | * However, the chip cannot be detected without doing an i2c write, | ||
30 | * so use the force module parameter. | ||
31 | */ | ||
32 | static const unsigned short normal_i2c[] = { I2C_CLIENT_END }; | ||
33 | |||
34 | /** | ||
35 | * Insmod parameters | ||
36 | */ | ||
37 | I2C_CLIENT_INSMOD_1(ds2482); | ||
38 | |||
39 | /** | ||
40 | * The DS2482 registers - there are 3 registers that are addressed by a read | 27 | * The DS2482 registers - there are 3 registers that are addressed by a read |
41 | * pointer. The read pointer is set by the last command executed. | 28 | * pointer. The read pointer is set by the last command executed. |
42 | * | 29 | * |
@@ -96,8 +83,6 @@ static const u8 ds2482_chan_rd[8] = | |||
96 | 83 | ||
97 | static int ds2482_probe(struct i2c_client *client, | 84 | static int ds2482_probe(struct i2c_client *client, |
98 | const struct i2c_device_id *id); | 85 | const struct i2c_device_id *id); |
99 | static int ds2482_detect(struct i2c_client *client, int kind, | ||
100 | struct i2c_board_info *info); | ||
101 | static int ds2482_remove(struct i2c_client *client); | 86 | static int ds2482_remove(struct i2c_client *client); |
102 | 87 | ||
103 | 88 | ||
@@ -117,8 +102,6 @@ static struct i2c_driver ds2482_driver = { | |||
117 | .probe = ds2482_probe, | 102 | .probe = ds2482_probe, |
118 | .remove = ds2482_remove, | 103 | .remove = ds2482_remove, |
119 | .id_table = ds2482_id, | 104 | .id_table = ds2482_id, |
120 | .detect = ds2482_detect, | ||
121 | .address_data = &addr_data, | ||
122 | }; | 105 | }; |
123 | 106 | ||
124 | /* | 107 | /* |
@@ -425,19 +408,6 @@ static u8 ds2482_w1_reset_bus(void *data) | |||
425 | } | 408 | } |
426 | 409 | ||
427 | 410 | ||
428 | static int ds2482_detect(struct i2c_client *client, int kind, | ||
429 | struct i2c_board_info *info) | ||
430 | { | ||
431 | if (!i2c_check_functionality(client->adapter, | ||
432 | I2C_FUNC_SMBUS_WRITE_BYTE_DATA | | ||
433 | I2C_FUNC_SMBUS_BYTE)) | ||
434 | return -ENODEV; | ||
435 | |||
436 | strlcpy(info->type, "ds2482", I2C_NAME_SIZE); | ||
437 | |||
438 | return 0; | ||
439 | } | ||
440 | |||
441 | static int ds2482_probe(struct i2c_client *client, | 411 | static int ds2482_probe(struct i2c_client *client, |
442 | const struct i2c_device_id *id) | 412 | const struct i2c_device_id *id) |
443 | { | 413 | { |
@@ -446,6 +416,11 @@ static int ds2482_probe(struct i2c_client *client, | |||
446 | int temp1; | 416 | int temp1; |
447 | int idx; | 417 | int idx; |
448 | 418 | ||
419 | if (!i2c_check_functionality(client->adapter, | ||
420 | I2C_FUNC_SMBUS_WRITE_BYTE_DATA | | ||
421 | I2C_FUNC_SMBUS_BYTE)) | ||
422 | return -ENODEV; | ||
423 | |||
449 | if (!(data = kzalloc(sizeof(struct ds2482_data), GFP_KERNEL))) { | 424 | if (!(data = kzalloc(sizeof(struct ds2482_data), GFP_KERNEL))) { |
450 | err = -ENOMEM; | 425 | err = -ENOMEM; |
451 | goto exit; | 426 | goto exit; |
diff --git a/drivers/w1/w1_netlink.c b/drivers/w1/w1_netlink.c index 52ccb3d3a963..45c126fea31d 100644 --- a/drivers/w1/w1_netlink.c +++ b/drivers/w1/w1_netlink.c | |||
@@ -306,7 +306,7 @@ static int w1_netlink_send_error(struct cn_msg *rcmsg, struct w1_netlink_msg *rm | |||
306 | return error; | 306 | return error; |
307 | } | 307 | } |
308 | 308 | ||
309 | static void w1_cn_callback(struct cn_msg *msg) | 309 | static void w1_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp) |
310 | { | 310 | { |
311 | struct w1_netlink_msg *m = (struct w1_netlink_msg *)(msg + 1); | 311 | struct w1_netlink_msg *m = (struct w1_netlink_msg *)(msg + 1); |
312 | struct w1_netlink_cmd *cmd; | 312 | struct w1_netlink_cmd *cmd; |
diff --git a/drivers/xen/xenfs/xenbus.c b/drivers/xen/xenfs/xenbus.c index a9592d981b10..6c4269b836b7 100644 --- a/drivers/xen/xenfs/xenbus.c +++ b/drivers/xen/xenfs/xenbus.c | |||
@@ -43,6 +43,7 @@ | |||
43 | #include <linux/fs.h> | 43 | #include <linux/fs.h> |
44 | #include <linux/poll.h> | 44 | #include <linux/poll.h> |
45 | #include <linux/mutex.h> | 45 | #include <linux/mutex.h> |
46 | #include <linux/sched.h> | ||
46 | #include <linux/spinlock.h> | 47 | #include <linux/spinlock.h> |
47 | #include <linux/mount.h> | 48 | #include <linux/mount.h> |
48 | #include <linux/pagemap.h> | 49 | #include <linux/pagemap.h> |