1 | /* |
2 | * Core maple bus functionality |
3 | * |
4 | * Copyright (C) 2007 - 2009 Adrian McMenamin |
5 | * Copyright (C) 2001 - 2008 Paul Mundt |
6 | * Copyright (C) 2000 - 2001 YAEGASHI Takeshi |
7 | * Copyright (C) 2001 M. R. Brown |
8 | * |
9 | * This file is subject to the terms and conditions of the GNU General Public |
10 | * License. See the file "COPYING" in the main directory of this archive |
11 | * for more details. |
12 | */ |
13 | #include <linux/init.h> |
14 | #include <linux/kernel.h> |
15 | #include <linux/device.h> |
16 | #include <linux/interrupt.h> |
17 | #include <linux/list.h> |
18 | #include <linux/io.h> |
19 | #include <linux/slab.h> |
20 | #include <linux/maple.h> |
21 | #include <linux/dma-mapping.h> |
22 | #include <linux/delay.h> |
23 | #include <linux/module.h> |
24 | #include <asm/cacheflush.h> |
25 | #include <asm/dma.h> |
26 | #include <asm/io.h> |
27 | #include <mach/dma.h> |
28 | #include <mach/sysasic.h> |
29 | |
30 | MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>" ); |
31 | MODULE_DESCRIPTION("Maple bus driver for Dreamcast" ); |
32 | MODULE_LICENSE("GPL v2" ); |
33 | |
34 | static void maple_dma_handler(struct work_struct *work); |
35 | static void maple_vblank_handler(struct work_struct *work); |
36 | |
37 | static DECLARE_WORK(maple_dma_process, maple_dma_handler); |
38 | static DECLARE_WORK(maple_vblank_process, maple_vblank_handler); |
39 | |
40 | static LIST_HEAD(maple_waitq); |
41 | static LIST_HEAD(maple_sentq); |
42 | |
43 | /* mutex to protect queue of waiting packets */ |
44 | static DEFINE_MUTEX(maple_wlist_lock); |
45 | |
46 | static struct maple_driver maple_unsupported_device; |
47 | static struct device maple_bus; |
48 | static int subdevice_map[MAPLE_PORTS]; |
49 | static unsigned long *maple_sendbuf, *maple_sendptr, *maple_lastptr; |
50 | static unsigned long maple_pnp_time; |
51 | static int started, scanning, fullscan; |
52 | static struct kmem_cache *maple_queue_cache; |
53 | |
54 | struct maple_device_specify { |
55 | int port; |
56 | int unit; |
57 | }; |
58 | |
59 | static bool checked[MAPLE_PORTS]; |
60 | static bool empty[MAPLE_PORTS]; |
61 | static struct maple_device *baseunits[MAPLE_PORTS]; |
62 | static const struct bus_type maple_bus_type; |
63 | |
64 | /** |
65 | * maple_driver_register - register a maple driver |
66 | * @drv: maple driver to be registered. |
67 | * |
68 | * Registers the passed in @drv, while updating the bus type. |
69 | * Devices with matching function IDs will be automatically probed. |
70 | */ |
71 | int maple_driver_register(struct maple_driver *drv) |
72 | { |
73 | if (!drv) |
74 | return -EINVAL; |
75 | |
76 | drv->drv.bus = &maple_bus_type; |
77 | |
78 | return driver_register(drv: &drv->drv); |
79 | } |
80 | EXPORT_SYMBOL_GPL(maple_driver_register); |
81 | |
82 | /** |
83 | * maple_driver_unregister - unregister a maple driver. |
84 | * @drv: maple driver to unregister. |
85 | * |
86 | * Cleans up after maple_driver_register(). To be invoked in the exit |
87 | * path of any module drivers. |
88 | */ |
89 | void maple_driver_unregister(struct maple_driver *drv) |
90 | { |
91 | driver_unregister(drv: &drv->drv); |
92 | } |
93 | EXPORT_SYMBOL_GPL(maple_driver_unregister); |
94 | |
95 | /* set hardware registers to enable next round of dma */ |
96 | static void maple_dma_reset(void) |
97 | { |
98 | __raw_writel(val: MAPLE_MAGIC, addr: MAPLE_RESET); |
99 | /* set trig type to 0 for software trigger, 1 for hardware (VBLANK) */ |
100 | __raw_writel(val: 1, addr: MAPLE_TRIGTYPE); |
101 | /* |
102 | * Maple system register |
103 | * bits 31 - 16 timeout in units of 20nsec |
104 | * bit 12 hard trigger - set 0 to keep responding to VBLANK |
105 | * bits 9 - 8 set 00 for 2 Mbps, 01 for 1 Mbps |
106 | * bits 3 - 0 delay (in 1.3ms) between VBLANK and start of DMA |
107 | * max delay is 11 |
108 | */ |
109 | __raw_writel(val: MAPLE_2MBPS | MAPLE_TIMEOUT(0xFFFF), addr: MAPLE_SPEED); |
110 | __raw_writel(virt_to_phys(address: maple_sendbuf), addr: MAPLE_DMAADDR); |
111 | __raw_writel(val: 1, addr: MAPLE_ENABLE); |
112 | } |
113 | |
114 | /** |
115 | * maple_getcond_callback - setup handling MAPLE_COMMAND_GETCOND |
116 | * @dev: device responding |
117 | * @callback: handler callback |
118 | * @interval: interval in jiffies between callbacks |
119 | * @function: the function code for the device |
120 | */ |
121 | void maple_getcond_callback(struct maple_device *dev, |
122 | void (*callback) (struct mapleq *mq), |
123 | unsigned long interval, unsigned long function) |
124 | { |
125 | dev->callback = callback; |
126 | dev->interval = interval; |
127 | dev->function = cpu_to_be32(function); |
128 | dev->when = jiffies; |
129 | } |
130 | EXPORT_SYMBOL_GPL(maple_getcond_callback); |
131 | |
132 | static int maple_dma_done(void) |
133 | { |
134 | return (__raw_readl(MAPLE_STATE) & 1) == 0; |
135 | } |
136 | |
137 | static void maple_release_device(struct device *dev) |
138 | { |
139 | struct maple_device *mdev; |
140 | struct mapleq *mq; |
141 | |
142 | mdev = to_maple_dev(dev); |
143 | mq = mdev->mq; |
144 | kmem_cache_free(s: maple_queue_cache, objp: mq->recvbuf); |
145 | kfree(objp: mq); |
146 | kfree(objp: mdev); |
147 | } |
148 | |
149 | /** |
150 | * maple_add_packet - add a single instruction to the maple bus queue |
151 | * @mdev: maple device |
152 | * @function: function on device being queried |
153 | * @command: maple command to add |
154 | * @length: length of command string (in 32 bit words) |
155 | * @data: remainder of command string |
156 | */ |
157 | int maple_add_packet(struct maple_device *mdev, u32 function, u32 command, |
158 | size_t length, void *data) |
159 | { |
160 | int ret = 0; |
161 | void *sendbuf = NULL; |
162 | |
163 | if (length) { |
164 | sendbuf = kcalloc(n: length, size: 4, GFP_KERNEL); |
165 | if (!sendbuf) { |
166 | ret = -ENOMEM; |
167 | goto out; |
168 | } |
169 | ((__be32 *)sendbuf)[0] = cpu_to_be32(function); |
170 | } |
171 | |
172 | mdev->mq->command = command; |
173 | mdev->mq->length = length; |
174 | if (length > 1) |
175 | memcpy(sendbuf + 4, data, (length - 1) * 4); |
176 | mdev->mq->sendbuf = sendbuf; |
177 | |
178 | mutex_lock(&maple_wlist_lock); |
179 | list_add_tail(new: &mdev->mq->list, head: &maple_waitq); |
180 | mutex_unlock(lock: &maple_wlist_lock); |
181 | out: |
182 | return ret; |
183 | } |
184 | EXPORT_SYMBOL_GPL(maple_add_packet); |
185 | |
186 | static struct mapleq *maple_allocq(struct maple_device *mdev) |
187 | { |
188 | struct mapleq *mq; |
189 | |
190 | mq = kzalloc(size: sizeof(*mq), GFP_KERNEL); |
191 | if (!mq) |
192 | goto failed_nomem; |
193 | |
194 | INIT_LIST_HEAD(list: &mq->list); |
195 | mq->dev = mdev; |
196 | mq->recvbuf = kmem_cache_zalloc(k: maple_queue_cache, GFP_KERNEL); |
197 | if (!mq->recvbuf) |
198 | goto failed_p2; |
199 | mq->recvbuf->buf = &((mq->recvbuf->bufx)[0]); |
200 | |
201 | return mq; |
202 | |
203 | failed_p2: |
204 | kfree(objp: mq); |
205 | failed_nomem: |
206 | dev_err(&mdev->dev, "could not allocate memory for device (%d, %d)\n" , |
207 | mdev->port, mdev->unit); |
208 | return NULL; |
209 | } |
210 | |
211 | static struct maple_device *maple_alloc_dev(int port, int unit) |
212 | { |
213 | struct maple_device *mdev; |
214 | |
215 | /* zero this out to avoid kobj subsystem |
216 | * thinking it has already been registered */ |
217 | |
218 | mdev = kzalloc(size: sizeof(*mdev), GFP_KERNEL); |
219 | if (!mdev) |
220 | return NULL; |
221 | |
222 | mdev->port = port; |
223 | mdev->unit = unit; |
224 | |
225 | mdev->mq = maple_allocq(mdev); |
226 | |
227 | if (!mdev->mq) { |
228 | kfree(objp: mdev); |
229 | return NULL; |
230 | } |
231 | mdev->dev.bus = &maple_bus_type; |
232 | mdev->dev.parent = &maple_bus; |
233 | init_waitqueue_head(&mdev->maple_wait); |
234 | return mdev; |
235 | } |
236 | |
237 | static void maple_free_dev(struct maple_device *mdev) |
238 | { |
239 | kmem_cache_free(s: maple_queue_cache, objp: mdev->mq->recvbuf); |
240 | kfree(objp: mdev->mq); |
241 | kfree(objp: mdev); |
242 | } |
243 | |
244 | /* process the command queue into a maple command block |
245 | * terminating command has bit 32 of first long set to 0 |
246 | */ |
247 | static void maple_build_block(struct mapleq *mq) |
248 | { |
249 | int port, unit, from, to, len; |
250 | unsigned long *lsendbuf = mq->sendbuf; |
251 | |
252 | port = mq->dev->port & 3; |
253 | unit = mq->dev->unit; |
254 | len = mq->length; |
255 | from = port << 6; |
256 | to = (port << 6) | (unit > 0 ? (1 << (unit - 1)) & 0x1f : 0x20); |
257 | |
258 | *maple_lastptr &= 0x7fffffff; |
259 | maple_lastptr = maple_sendptr; |
260 | |
261 | *maple_sendptr++ = (port << 16) | len | 0x80000000; |
262 | *maple_sendptr++ = virt_to_phys(address: mq->recvbuf->buf); |
263 | *maple_sendptr++ = |
264 | mq->command | (to << 8) | (from << 16) | (len << 24); |
265 | while (len-- > 0) |
266 | *maple_sendptr++ = *lsendbuf++; |
267 | } |
268 | |
269 | /* build up command queue */ |
270 | static void maple_send(void) |
271 | { |
272 | int i, maple_packets = 0; |
273 | struct mapleq *mq, *nmq; |
274 | |
275 | if (!maple_dma_done()) |
276 | return; |
277 | |
278 | /* disable DMA */ |
279 | __raw_writel(val: 0, addr: MAPLE_ENABLE); |
280 | |
281 | if (!list_empty(head: &maple_sentq)) |
282 | goto finish; |
283 | |
284 | mutex_lock(&maple_wlist_lock); |
285 | if (list_empty(head: &maple_waitq)) { |
286 | mutex_unlock(lock: &maple_wlist_lock); |
287 | goto finish; |
288 | } |
289 | |
290 | maple_lastptr = maple_sendbuf; |
291 | maple_sendptr = maple_sendbuf; |
292 | |
293 | list_for_each_entry_safe(mq, nmq, &maple_waitq, list) { |
294 | maple_build_block(mq); |
295 | list_del_init(entry: &mq->list); |
296 | list_add_tail(new: &mq->list, head: &maple_sentq); |
297 | if (maple_packets++ > MAPLE_MAXPACKETS) |
298 | break; |
299 | } |
300 | mutex_unlock(lock: &maple_wlist_lock); |
301 | if (maple_packets > 0) { |
302 | for (i = 0; i < (1 << MAPLE_DMA_PAGES); i++) |
303 | __flush_purge_region(maple_sendbuf + i * PAGE_SIZE, |
304 | PAGE_SIZE); |
305 | } |
306 | |
307 | finish: |
308 | maple_dma_reset(); |
309 | } |
310 | |
311 | /* check if there is a driver registered likely to match this device */ |
312 | static int maple_check_matching_driver(struct device_driver *driver, |
313 | void *devptr) |
314 | { |
315 | struct maple_driver *maple_drv; |
316 | struct maple_device *mdev; |
317 | |
318 | mdev = devptr; |
319 | maple_drv = to_maple_driver(driver); |
320 | if (mdev->devinfo.function & cpu_to_be32(maple_drv->function)) |
321 | return 1; |
322 | return 0; |
323 | } |
324 | |
325 | static void maple_detach_driver(struct maple_device *mdev) |
326 | { |
327 | device_unregister(dev: &mdev->dev); |
328 | } |
329 | |
330 | /* process initial MAPLE_COMMAND_DEVINFO for each device or port */ |
331 | static void maple_attach_driver(struct maple_device *mdev) |
332 | { |
333 | char *p, *recvbuf; |
334 | unsigned long function; |
335 | int matched, error; |
336 | |
337 | recvbuf = mdev->mq->recvbuf->buf; |
338 | /* copy the data as individual elements in |
339 | * case of memory optimisation */ |
340 | memcpy(&mdev->devinfo.function, recvbuf + 4, 4); |
341 | memcpy(&mdev->devinfo.function_data[0], recvbuf + 8, 12); |
342 | memcpy(&mdev->devinfo.area_code, recvbuf + 20, 1); |
343 | memcpy(&mdev->devinfo.connector_direction, recvbuf + 21, 1); |
344 | memcpy(&mdev->devinfo.product_name[0], recvbuf + 22, 30); |
345 | memcpy(&mdev->devinfo.standby_power, recvbuf + 112, 2); |
346 | memcpy(&mdev->devinfo.max_power, recvbuf + 114, 2); |
347 | memcpy(mdev->product_name, mdev->devinfo.product_name, 30); |
348 | mdev->product_name[30] = '\0'; |
349 | memcpy(mdev->product_licence, mdev->devinfo.product_licence, 60); |
350 | mdev->product_licence[60] = '\0'; |
351 | |
352 | for (p = mdev->product_name + 29; mdev->product_name <= p; p--) |
353 | if (*p == ' ') |
354 | *p = '\0'; |
355 | else |
356 | break; |
357 | for (p = mdev->product_licence + 59; mdev->product_licence <= p; p--) |
358 | if (*p == ' ') |
359 | *p = '\0'; |
360 | else |
361 | break; |
362 | |
363 | function = be32_to_cpu(mdev->devinfo.function); |
364 | |
365 | dev_info(&mdev->dev, "detected %s: function 0x%lX: at (%d, %d)\n" , |
366 | mdev->product_name, function, mdev->port, mdev->unit); |
367 | |
368 | if (function > 0x200) { |
369 | /* Do this silently - as not a real device */ |
370 | function = 0; |
371 | mdev->driver = &maple_unsupported_device; |
372 | dev_set_name(dev: &mdev->dev, name: "%d:0.port" , mdev->port); |
373 | } else { |
374 | matched = |
375 | bus_for_each_drv(bus: &maple_bus_type, NULL, data: mdev, |
376 | fn: maple_check_matching_driver); |
377 | |
378 | if (matched == 0) { |
379 | /* Driver does not exist yet */ |
380 | dev_info(&mdev->dev, "no driver found\n" ); |
381 | mdev->driver = &maple_unsupported_device; |
382 | } |
383 | dev_set_name(dev: &mdev->dev, name: "%d:0%d.%lX" , mdev->port, |
384 | mdev->unit, function); |
385 | } |
386 | |
387 | mdev->function = function; |
388 | mdev->dev.release = &maple_release_device; |
389 | |
390 | atomic_set(v: &mdev->busy, i: 0); |
391 | error = device_register(dev: &mdev->dev); |
392 | if (error) { |
393 | dev_warn(&mdev->dev, "could not register device at" |
394 | " (%d, %d), with error 0x%X\n" , mdev->unit, |
395 | mdev->port, error); |
396 | maple_free_dev(mdev); |
397 | mdev = NULL; |
398 | return; |
399 | } |
400 | } |
401 | |
402 | /* |
403 | * if device has been registered for the given |
404 | * port and unit then return 1 - allows identification |
405 | * of which devices need to be attached or detached |
406 | */ |
407 | static int check_maple_device(struct device *device, void *portptr) |
408 | { |
409 | struct maple_device_specify *ds; |
410 | struct maple_device *mdev; |
411 | |
412 | ds = portptr; |
413 | mdev = to_maple_dev(device); |
414 | if (mdev->port == ds->port && mdev->unit == ds->unit) |
415 | return 1; |
416 | return 0; |
417 | } |
418 | |
419 | static int setup_maple_commands(struct device *device, void *ignored) |
420 | { |
421 | int add; |
422 | struct maple_device *mdev = to_maple_dev(device); |
423 | if (mdev->interval > 0 && atomic_read(v: &mdev->busy) == 0 && |
424 | time_after(jiffies, mdev->when)) { |
425 | /* bounce if we cannot add */ |
426 | add = maple_add_packet(mdev, |
427 | be32_to_cpu(mdev->devinfo.function), |
428 | MAPLE_COMMAND_GETCOND, 1, NULL); |
429 | if (!add) |
430 | mdev->when = jiffies + mdev->interval; |
431 | } else { |
432 | if (time_after(jiffies, maple_pnp_time)) |
433 | /* Ensure we don't have block reads and devinfo |
434 | * calls interfering with one another - so flag the |
435 | * device as busy */ |
436 | if (atomic_read(v: &mdev->busy) == 0) { |
437 | atomic_set(v: &mdev->busy, i: 1); |
438 | maple_add_packet(mdev, 0, |
439 | MAPLE_COMMAND_DEVINFO, 0, NULL); |
440 | } |
441 | } |
442 | return 0; |
443 | } |
444 | |
445 | /* VBLANK bottom half - implemented via workqueue */ |
446 | static void maple_vblank_handler(struct work_struct *work) |
447 | { |
448 | int x, locking; |
449 | struct maple_device *mdev; |
450 | |
451 | if (!maple_dma_done()) |
452 | return; |
453 | |
454 | __raw_writel(val: 0, addr: MAPLE_ENABLE); |
455 | |
456 | if (!list_empty(head: &maple_sentq)) |
457 | goto finish; |
458 | |
459 | /* |
460 | * Set up essential commands - to fetch data and |
461 | * check devices are still present |
462 | */ |
463 | bus_for_each_dev(bus: &maple_bus_type, NULL, NULL, |
464 | fn: setup_maple_commands); |
465 | |
466 | if (time_after(jiffies, maple_pnp_time)) { |
467 | /* |
468 | * Scan the empty ports - bus is flakey and may have |
469 | * mis-reported emptyness |
470 | */ |
471 | for (x = 0; x < MAPLE_PORTS; x++) { |
472 | if (checked[x] && empty[x]) { |
473 | mdev = baseunits[x]; |
474 | if (!mdev) |
475 | break; |
476 | atomic_set(v: &mdev->busy, i: 1); |
477 | locking = maple_add_packet(mdev, 0, |
478 | MAPLE_COMMAND_DEVINFO, 0, NULL); |
479 | if (!locking) |
480 | break; |
481 | } |
482 | } |
483 | |
484 | maple_pnp_time = jiffies + MAPLE_PNP_INTERVAL; |
485 | } |
486 | |
487 | finish: |
488 | maple_send(); |
489 | } |
490 | |
491 | /* handle devices added via hotplugs - placing them on queue for DEVINFO */ |
492 | static void maple_map_subunits(struct maple_device *mdev, int submask) |
493 | { |
494 | int retval, k, devcheck; |
495 | struct maple_device *mdev_add; |
496 | struct maple_device_specify ds; |
497 | |
498 | ds.port = mdev->port; |
499 | for (k = 0; k < 5; k++) { |
500 | ds.unit = k + 1; |
501 | retval = |
502 | bus_for_each_dev(bus: &maple_bus_type, NULL, data: &ds, |
503 | fn: check_maple_device); |
504 | if (retval) { |
505 | submask = submask >> 1; |
506 | continue; |
507 | } |
508 | devcheck = submask & 0x01; |
509 | if (devcheck) { |
510 | mdev_add = maple_alloc_dev(port: mdev->port, unit: k + 1); |
511 | if (!mdev_add) |
512 | return; |
513 | atomic_set(v: &mdev_add->busy, i: 1); |
514 | maple_add_packet(mdev_add, 0, MAPLE_COMMAND_DEVINFO, |
515 | 0, NULL); |
516 | /* mark that we are checking sub devices */ |
517 | scanning = 1; |
518 | } |
519 | submask = submask >> 1; |
520 | } |
521 | } |
522 | |
523 | /* mark a device as removed */ |
524 | static void maple_clean_submap(struct maple_device *mdev) |
525 | { |
526 | int killbit; |
527 | |
528 | killbit = (mdev->unit > 0 ? (1 << (mdev->unit - 1)) & 0x1f : 0x20); |
529 | killbit = ~killbit; |
530 | killbit &= 0xFF; |
531 | subdevice_map[mdev->port] = subdevice_map[mdev->port] & killbit; |
532 | } |
533 | |
534 | /* handle empty port or hotplug removal */ |
535 | static void maple_response_none(struct maple_device *mdev) |
536 | { |
537 | maple_clean_submap(mdev); |
538 | |
539 | if (likely(mdev->unit != 0)) { |
540 | /* |
541 | * Block devices play up |
542 | * and give the impression they have |
543 | * been removed even when still in place or |
544 | * trip the mtd layer when they have |
545 | * really gone - this code traps that eventuality |
546 | * and ensures we aren't overloaded with useless |
547 | * error messages |
548 | */ |
549 | if (mdev->can_unload) { |
550 | if (!mdev->can_unload(mdev)) { |
551 | atomic_set(v: &mdev->busy, i: 2); |
552 | wake_up(&mdev->maple_wait); |
553 | return; |
554 | } |
555 | } |
556 | |
557 | dev_info(&mdev->dev, "detaching device at (%d, %d)\n" , |
558 | mdev->port, mdev->unit); |
559 | maple_detach_driver(mdev); |
560 | return; |
561 | } else { |
562 | if (!started || !fullscan) { |
563 | if (checked[mdev->port] == false) { |
564 | checked[mdev->port] = true; |
565 | empty[mdev->port] = true; |
566 | dev_info(&mdev->dev, "no devices" |
567 | " to port %d\n" , mdev->port); |
568 | } |
569 | return; |
570 | } |
571 | } |
572 | /* Some hardware devices generate false detach messages on unit 0 */ |
573 | atomic_set(v: &mdev->busy, i: 0); |
574 | } |
575 | |
576 | /* preprocess hotplugs or scans */ |
577 | static void maple_response_devinfo(struct maple_device *mdev, |
578 | char *recvbuf) |
579 | { |
580 | char submask; |
581 | if (!started || (scanning == 2) || !fullscan) { |
582 | if ((mdev->unit == 0) && (checked[mdev->port] == false)) { |
583 | checked[mdev->port] = true; |
584 | maple_attach_driver(mdev); |
585 | } else { |
586 | if (mdev->unit != 0) |
587 | maple_attach_driver(mdev); |
588 | if (mdev->unit == 0) { |
589 | empty[mdev->port] = false; |
590 | maple_attach_driver(mdev); |
591 | } |
592 | } |
593 | } |
594 | if (mdev->unit == 0) { |
595 | submask = recvbuf[2] & 0x1F; |
596 | if (submask ^ subdevice_map[mdev->port]) { |
597 | maple_map_subunits(mdev, submask); |
598 | subdevice_map[mdev->port] = submask; |
599 | } |
600 | } |
601 | } |
602 | |
603 | static void maple_response_fileerr(struct maple_device *mdev, void *recvbuf) |
604 | { |
605 | if (mdev->fileerr_handler) { |
606 | mdev->fileerr_handler(mdev, recvbuf); |
607 | return; |
608 | } else |
609 | dev_warn(&mdev->dev, "device at (%d, %d) reports" |
610 | "file error 0x%X\n" , mdev->port, mdev->unit, |
611 | ((int *)recvbuf)[1]); |
612 | } |
613 | |
614 | static void maple_port_rescan(void) |
615 | { |
616 | int i; |
617 | struct maple_device *mdev; |
618 | |
619 | fullscan = 1; |
620 | for (i = 0; i < MAPLE_PORTS; i++) { |
621 | if (checked[i] == false) { |
622 | fullscan = 0; |
623 | mdev = baseunits[i]; |
624 | maple_add_packet(mdev, 0, MAPLE_COMMAND_DEVINFO, |
625 | 0, NULL); |
626 | } |
627 | } |
628 | } |
629 | |
630 | /* maple dma end bottom half - implemented via workqueue */ |
631 | static void maple_dma_handler(struct work_struct *work) |
632 | { |
633 | struct mapleq *mq, *nmq; |
634 | struct maple_device *mdev; |
635 | char *recvbuf; |
636 | enum maple_code code; |
637 | |
638 | if (!maple_dma_done()) |
639 | return; |
640 | __raw_writel(val: 0, addr: MAPLE_ENABLE); |
641 | if (!list_empty(head: &maple_sentq)) { |
642 | list_for_each_entry_safe(mq, nmq, &maple_sentq, list) { |
643 | mdev = mq->dev; |
644 | recvbuf = mq->recvbuf->buf; |
645 | __flush_invalidate_region(sh_cacheop_vaddr(recvbuf), |
646 | 0x400); |
647 | code = recvbuf[0]; |
648 | kfree(objp: mq->sendbuf); |
649 | list_del_init(entry: &mq->list); |
650 | switch (code) { |
651 | case MAPLE_RESPONSE_NONE: |
652 | maple_response_none(mdev); |
653 | break; |
654 | |
655 | case MAPLE_RESPONSE_DEVINFO: |
656 | maple_response_devinfo(mdev, recvbuf); |
657 | atomic_set(v: &mdev->busy, i: 0); |
658 | break; |
659 | |
660 | case MAPLE_RESPONSE_DATATRF: |
661 | if (mdev->callback) |
662 | mdev->callback(mq); |
663 | atomic_set(v: &mdev->busy, i: 0); |
664 | wake_up(&mdev->maple_wait); |
665 | break; |
666 | |
667 | case MAPLE_RESPONSE_FILEERR: |
668 | maple_response_fileerr(mdev, recvbuf); |
669 | atomic_set(v: &mdev->busy, i: 0); |
670 | wake_up(&mdev->maple_wait); |
671 | break; |
672 | |
673 | case MAPLE_RESPONSE_AGAIN: |
674 | case MAPLE_RESPONSE_BADCMD: |
675 | case MAPLE_RESPONSE_BADFUNC: |
676 | dev_warn(&mdev->dev, "non-fatal error" |
677 | " 0x%X at (%d, %d)\n" , code, |
678 | mdev->port, mdev->unit); |
679 | atomic_set(v: &mdev->busy, i: 0); |
680 | break; |
681 | |
682 | case MAPLE_RESPONSE_ALLINFO: |
683 | dev_notice(&mdev->dev, "extended" |
684 | " device information request for (%d, %d)" |
685 | " but call is not supported\n" , mdev->port, |
686 | mdev->unit); |
687 | atomic_set(v: &mdev->busy, i: 0); |
688 | break; |
689 | |
690 | case MAPLE_RESPONSE_OK: |
691 | atomic_set(v: &mdev->busy, i: 0); |
692 | wake_up(&mdev->maple_wait); |
693 | break; |
694 | |
695 | default: |
696 | break; |
697 | } |
698 | } |
699 | /* if scanning is 1 then we have subdevices to check */ |
700 | if (scanning == 1) { |
701 | maple_send(); |
702 | scanning = 2; |
703 | } else |
704 | scanning = 0; |
705 | /*check if we have actually tested all ports yet */ |
706 | if (!fullscan) |
707 | maple_port_rescan(); |
708 | /* mark that we have been through the first scan */ |
709 | started = 1; |
710 | } |
711 | maple_send(); |
712 | } |
713 | |
714 | static irqreturn_t maple_dma_interrupt(int irq, void *dev_id) |
715 | { |
716 | /* Load everything into the bottom half */ |
717 | schedule_work(work: &maple_dma_process); |
718 | return IRQ_HANDLED; |
719 | } |
720 | |
721 | static irqreturn_t maple_vblank_interrupt(int irq, void *dev_id) |
722 | { |
723 | schedule_work(work: &maple_vblank_process); |
724 | return IRQ_HANDLED; |
725 | } |
726 | |
727 | static int maple_set_dma_interrupt_handler(void) |
728 | { |
729 | return request_irq(irq: HW_EVENT_MAPLE_DMA, handler: maple_dma_interrupt, |
730 | IRQF_SHARED, name: "maple bus DMA" , dev: &maple_unsupported_device); |
731 | } |
732 | |
733 | static int maple_set_vblank_interrupt_handler(void) |
734 | { |
735 | return request_irq(irq: HW_EVENT_VSYNC, handler: maple_vblank_interrupt, |
736 | IRQF_SHARED, name: "maple bus VBLANK" , dev: &maple_unsupported_device); |
737 | } |
738 | |
739 | static int maple_get_dma_buffer(void) |
740 | { |
741 | maple_sendbuf = |
742 | (void *) __get_free_pages(GFP_KERNEL | __GFP_ZERO, |
743 | MAPLE_DMA_PAGES); |
744 | if (!maple_sendbuf) |
745 | return -ENOMEM; |
746 | return 0; |
747 | } |
748 | |
749 | static int maple_match_bus_driver(struct device *devptr, |
750 | struct device_driver *drvptr) |
751 | { |
752 | struct maple_driver *maple_drv = to_maple_driver(drvptr); |
753 | struct maple_device *maple_dev = to_maple_dev(devptr); |
754 | |
755 | /* Trap empty port case */ |
756 | if (maple_dev->devinfo.function == 0xFFFFFFFF) |
757 | return 0; |
758 | else if (maple_dev->devinfo.function & |
759 | cpu_to_be32(maple_drv->function)) |
760 | return 1; |
761 | return 0; |
762 | } |
763 | |
764 | static void maple_bus_release(struct device *dev) |
765 | { |
766 | } |
767 | |
768 | static struct maple_driver maple_unsupported_device = { |
769 | .drv = { |
770 | .name = "maple_unsupported_device" , |
771 | .bus = &maple_bus_type, |
772 | }, |
773 | }; |
774 | /* |
775 | * maple_bus_type - core maple bus structure |
776 | */ |
777 | static const struct bus_type maple_bus_type = { |
778 | .name = "maple" , |
779 | .match = maple_match_bus_driver, |
780 | }; |
781 | |
782 | static struct device maple_bus = { |
783 | .init_name = "maple" , |
784 | .release = maple_bus_release, |
785 | }; |
786 | |
787 | static int __init maple_bus_init(void) |
788 | { |
789 | int retval, i; |
790 | struct maple_device *mdev[MAPLE_PORTS]; |
791 | |
792 | __raw_writel(val: 0, addr: MAPLE_ENABLE); |
793 | |
794 | retval = device_register(dev: &maple_bus); |
795 | if (retval) |
796 | goto cleanup; |
797 | |
798 | retval = bus_register(bus: &maple_bus_type); |
799 | if (retval) |
800 | goto cleanup_device; |
801 | |
802 | retval = driver_register(drv: &maple_unsupported_device.drv); |
803 | if (retval) |
804 | goto cleanup_bus; |
805 | |
806 | /* allocate memory for maple bus dma */ |
807 | retval = maple_get_dma_buffer(); |
808 | if (retval) { |
809 | dev_err(&maple_bus, "failed to allocate DMA buffers\n" ); |
810 | goto cleanup_basic; |
811 | } |
812 | |
813 | /* set up DMA interrupt handler */ |
814 | retval = maple_set_dma_interrupt_handler(); |
815 | if (retval) { |
816 | dev_err(&maple_bus, "bus failed to grab maple " |
817 | "DMA IRQ\n" ); |
818 | goto cleanup_dma; |
819 | } |
820 | |
821 | /* set up VBLANK interrupt handler */ |
822 | retval = maple_set_vblank_interrupt_handler(); |
823 | if (retval) { |
824 | dev_err(&maple_bus, "bus failed to grab VBLANK IRQ\n" ); |
825 | goto cleanup_irq; |
826 | } |
827 | |
828 | maple_queue_cache = KMEM_CACHE(maple_buffer, SLAB_HWCACHE_ALIGN); |
829 | |
830 | if (!maple_queue_cache) { |
831 | retval = -ENOMEM; |
832 | goto cleanup_bothirqs; |
833 | } |
834 | |
835 | INIT_LIST_HEAD(list: &maple_waitq); |
836 | INIT_LIST_HEAD(list: &maple_sentq); |
837 | |
838 | /* setup maple ports */ |
839 | for (i = 0; i < MAPLE_PORTS; i++) { |
840 | checked[i] = false; |
841 | empty[i] = false; |
842 | mdev[i] = maple_alloc_dev(port: i, unit: 0); |
843 | if (!mdev[i]) { |
844 | while (i-- > 0) |
845 | maple_free_dev(mdev: mdev[i]); |
846 | retval = -ENOMEM; |
847 | goto cleanup_cache; |
848 | } |
849 | baseunits[i] = mdev[i]; |
850 | atomic_set(v: &mdev[i]->busy, i: 1); |
851 | maple_add_packet(mdev[i], 0, MAPLE_COMMAND_DEVINFO, 0, NULL); |
852 | subdevice_map[i] = 0; |
853 | } |
854 | |
855 | maple_pnp_time = jiffies + HZ; |
856 | /* prepare initial queue */ |
857 | maple_send(); |
858 | dev_info(&maple_bus, "bus core now registered\n" ); |
859 | |
860 | return 0; |
861 | |
862 | cleanup_cache: |
863 | kmem_cache_destroy(s: maple_queue_cache); |
864 | |
865 | cleanup_bothirqs: |
866 | free_irq(HW_EVENT_VSYNC, 0); |
867 | |
868 | cleanup_irq: |
869 | free_irq(HW_EVENT_MAPLE_DMA, 0); |
870 | |
871 | cleanup_dma: |
872 | free_pages(addr: (unsigned long) maple_sendbuf, order: MAPLE_DMA_PAGES); |
873 | |
874 | cleanup_basic: |
875 | driver_unregister(drv: &maple_unsupported_device.drv); |
876 | |
877 | cleanup_bus: |
878 | bus_unregister(bus: &maple_bus_type); |
879 | |
880 | cleanup_device: |
881 | device_unregister(dev: &maple_bus); |
882 | |
883 | cleanup: |
884 | printk(KERN_ERR "Maple bus registration failed\n" ); |
885 | return retval; |
886 | } |
887 | /* Push init to later to ensure hardware gets detected */ |
888 | fs_initcall(maple_bus_init); |
889 | |