?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid beyond bounds copy while caching ACL
[zen-stable.git] / drivers / sh / maple / maple.c
blobbec81c2404f784e2cefd24a1cab92ab2aa845d88
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 MODULE_SUPPORTED_DEVICE("{{SEGA, Dreamcast/Maple}}");
34
35 static void maple_dma_handler(struct work_struct *work);
36 static void maple_vblank_handler(struct work_struct *work);
37
38 static DECLARE_WORK(maple_dma_process, maple_dma_handler);
39 static DECLARE_WORK(maple_vblank_process, maple_vblank_handler);
40
41 static LIST_HEAD(maple_waitq);
42 static LIST_HEAD(maple_sentq);
43
44 /* mutex to protect queue of waiting packets */
45 static DEFINE_MUTEX(maple_wlist_lock);
46
47 static struct maple_driver maple_unsupported_device;
48 static struct device maple_bus;
49 static int subdevice_map[MAPLE_PORTS];
50 static unsigned long *maple_sendbuf, *maple_sendptr, *maple_lastptr;
51 static unsigned long maple_pnp_time;
52 static int started, scanning, fullscan;
53 static struct kmem_cache *maple_queue_cache;
54
55 struct maple_device_specify {
56 int port;
57 int unit;
58 };
59
60 static bool checked[MAPLE_PORTS];
61 static bool empty[MAPLE_PORTS];
62 static struct maple_device *baseunits[MAPLE_PORTS];
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);
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);
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(MAPLE_MAGIC, MAPLE_RESET);
99 /* set trig type to 0 for software trigger, 1 for hardware (VBLANK) */
100 __raw_writel(1, 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(MAPLE_2MBPS | MAPLE_TIMEOUT(0xFFFF), MAPLE_SPEED);
110 __raw_writel(virt_to_phys(maple_sendbuf), MAPLE_DMAADDR);
111 __raw_writel(1, 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(maple_queue_cache, mq->recvbuf);
145 kfree(mq);
146 kfree(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 = kzalloc(length * 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(&mdev->mq->list, &maple_waitq);
180 mutex_unlock(&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(sizeof(*mq), GFP_KERNEL);
191 if (!mq)
192 goto failed_nomem;
193
194 INIT_LIST_HEAD(&mq->list);
195 mq->dev = mdev;
196 mq->recvbuf = kmem_cache_zalloc(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(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(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(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(maple_queue_cache, mdev->mq->recvbuf);
240 kfree(mdev->mq);
241 kfree(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(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(0, MAPLE_ENABLE);
280
281 if (!list_empty(&maple_sentq))
282 goto finish;
283
284 mutex_lock(&maple_wlist_lock);
285 if (list_empty(&maple_waitq)) {
286 mutex_unlock(&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(&mq->list);
296 list_add_tail(&mq->list, &maple_sentq);
297 if (maple_packets++ > MAPLE_MAXPACKETS)
298 break;
299 }
300 mutex_unlock(&maple_wlist_lock);
301 if (maple_packets > 0) {
302 for (i = 0; i < (1 << MAPLE_DMA_PAGES); i++)
303 dma_cache_sync(0, maple_sendbuf + i * PAGE_SIZE,
304 PAGE_SIZE, DMA_BIDIRECTIONAL);
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(&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(&mdev->dev, "%d:0.port", mdev->port);
373 } else {
374 matched =
375 bus_for_each_drv(&maple_bus_type, NULL, mdev,
376 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(&mdev->dev, "%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(&mdev->busy, 0);
391 error = device_register(&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(&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(&mdev->busy) == 0) {
437 atomic_set(&mdev->busy, 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(0, MAPLE_ENABLE);
455
456 if (!list_empty(&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(&maple_bus_type, NULL, NULL,
464 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(&mdev->busy, 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(&maple_bus_type, NULL, &ds,
503 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(mdev->port, k + 1);
511 if (!mdev_add)
512 return;
513 atomic_set(&mdev_add->busy, 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(&mdev->busy, 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(&mdev->busy, 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(0, MAPLE_ENABLE);
641 if (!list_empty(&maple_sentq)) {
642 list_for_each_entry_safe(mq, nmq, &maple_sentq, list) {
643 mdev = mq->dev;
644 recvbuf = mq->recvbuf->buf;
645 dma_cache_sync(&mdev->dev, recvbuf, 0x400,
646 DMA_FROM_DEVICE);
647 code = recvbuf[0];
648 kfree(mq->sendbuf);
649 list_del_init(&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(&mdev->busy, 0);
658 break;
659
660 case MAPLE_RESPONSE_DATATRF:
661 if (mdev->callback)
662 mdev->callback(mq);
663 atomic_set(&mdev->busy, 0);
664 wake_up(&mdev->maple_wait);
665 break;
666
667 case MAPLE_RESPONSE_FILEERR:
668 maple_response_fileerr(mdev, recvbuf);
669 atomic_set(&mdev->busy, 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(&mdev->busy, 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(&mdev->busy, 0);
688 break;
689
690 case MAPLE_RESPONSE_OK:
691 atomic_set(&mdev->busy, 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(&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(&maple_vblank_process);
724 return IRQ_HANDLED;
725 }
726
727 static int maple_set_dma_interrupt_handler(void)
728 {
729 return request_irq(HW_EVENT_MAPLE_DMA, maple_dma_interrupt,
730 IRQF_SHARED, "maple bus DMA", &maple_unsupported_device);
731 }
732
733 static int maple_set_vblank_interrupt_handler(void)
734 {
735 return request_irq(HW_EVENT_VSYNC, maple_vblank_interrupt,
736 IRQF_SHARED, "maple bus VBLANK", &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 int maple_bus_uevent(struct device *dev,
765 struct kobj_uevent_env *env)
766 {
767 return 0;
768 }
769
770 static void maple_bus_release(struct device *dev)
771 {
772 }
773
774 static struct maple_driver maple_unsupported_device = {
775 .drv = {
776 .name = "maple_unsupported_device",
777 .bus = &maple_bus_type,
778 },
779 };
780 /*
781 * maple_bus_type - core maple bus structure
782 */
783 struct bus_type maple_bus_type = {
784 .name = "maple",
785 .match = maple_match_bus_driver,
786 .uevent = maple_bus_uevent,
787 };
788 EXPORT_SYMBOL_GPL(maple_bus_type);
789
790 static struct device maple_bus = {
791 .init_name = "maple",
792 .release = maple_bus_release,
793 };
794
795 static int __init maple_bus_init(void)
796 {
797 int retval, i;
798 struct maple_device *mdev[MAPLE_PORTS];
799
800 __raw_writel(0, MAPLE_ENABLE);
801
802 retval = device_register(&maple_bus);
803 if (retval)
804 goto cleanup;
805
806 retval = bus_register(&maple_bus_type);
807 if (retval)
808 goto cleanup_device;
809
810 retval = driver_register(&maple_unsupported_device.drv);
811 if (retval)
812 goto cleanup_bus;
813
814 /* allocate memory for maple bus dma */
815 retval = maple_get_dma_buffer();
816 if (retval) {
817 dev_err(&maple_bus, "failed to allocate DMA buffers\n");
818 goto cleanup_basic;
819 }
820
821 /* set up DMA interrupt handler */
822 retval = maple_set_dma_interrupt_handler();
823 if (retval) {
824 dev_err(&maple_bus, "bus failed to grab maple "
825 "DMA IRQ\n");
826 goto cleanup_dma;
827 }
828
829 /* set up VBLANK interrupt handler */
830 retval = maple_set_vblank_interrupt_handler();
831 if (retval) {
832 dev_err(&maple_bus, "bus failed to grab VBLANK IRQ\n");
833 goto cleanup_irq;
834 }
835
836 maple_queue_cache = KMEM_CACHE(maple_buffer, SLAB_HWCACHE_ALIGN);
837
838 if (!maple_queue_cache)
839 goto cleanup_bothirqs;
840
841 INIT_LIST_HEAD(&maple_waitq);
842 INIT_LIST_HEAD(&maple_sentq);
843
844 /* setup maple ports */
845 for (i = 0; i < MAPLE_PORTS; i++) {
846 checked[i] = false;
847 empty[i] = false;
848 mdev[i] = maple_alloc_dev(i, 0);
849 if (!mdev[i]) {
850 while (i-- > 0)
851 maple_free_dev(mdev[i]);
852 goto cleanup_cache;
853 }
854 baseunits[i] = mdev[i];
855 atomic_set(&mdev[i]->busy, 1);
856 maple_add_packet(mdev[i], 0, MAPLE_COMMAND_DEVINFO, 0, NULL);
857 subdevice_map[i] = 0;
858 }
859
860 maple_pnp_time = jiffies + HZ;
861 /* prepare initial queue */
862 maple_send();
863 dev_info(&maple_bus, "bus core now registered\n");
864
865 return 0;
866
867 cleanup_cache:
868 kmem_cache_destroy(maple_queue_cache);
869
870 cleanup_bothirqs:
871 free_irq(HW_EVENT_VSYNC, 0);
872
873 cleanup_irq:
874 free_irq(HW_EVENT_MAPLE_DMA, 0);
875
876 cleanup_dma:
877 free_pages((unsigned long) maple_sendbuf, MAPLE_DMA_PAGES);
878
879 cleanup_basic:
880 driver_unregister(&maple_unsupported_device.drv);
881
882 cleanup_bus:
883 bus_unregister(&maple_bus_type);
884
885 cleanup_device:
886 device_unregister(&maple_bus);
887
888 cleanup:
889 printk(KERN_ERR "Maple bus registration failed\n");
890 return retval;
891 }
892 /* Push init to later to ensure hardware gets detected */
893 fs_initcall(maple_bus_init);