1/* 2 * Device driver for the Apple Desktop Bus 3 * and the /dev/adb device on macintoshes. 4 * 5 * Copyright (C) 1996 Paul Mackerras. 6 * 7 * Modified to declare controllers as structures, added 8 * client notification of bus reset and handles PowerBook 9 * sleep, by Benjamin Herrenschmidt. 10 * 11 * To do: 12 * 13 * - /sys/bus/adb to list the devices and infos 14 * - more /dev/adb to allow userland to receive the 15 * flow of auto-polling datas from a given device. 16 * - move bus probe to a kernel thread 17 */ 18 19#include <linux/types.h> 20#include <linux/errno.h> 21#include <linux/kernel.h> 22#include <linux/slab.h> 23#include <linux/module.h> 24#include <linux/fs.h> 25#include <linux/mm.h> 26#include <linux/sched.h> 27#include <linux/adb.h> 28#include <linux/cuda.h> 29#include <linux/pmu.h> 30#include <linux/notifier.h> 31#include <linux/wait.h> 32#include <linux/init.h> 33#include <linux/delay.h> 34#include <linux/spinlock.h> 35#include <linux/completion.h> 36#include <linux/device.h> 37#include <linux/kthread.h> 38#include <linux/platform_device.h> 39#include <linux/mutex.h> 40 41#include <linux/uaccess.h> 42#ifdef CONFIG_PPC 43#include <asm/prom.h> 44#include <asm/machdep.h> 45#endif 46 47 48EXPORT_SYMBOL(adb_client_list); 49 50extern struct adb_driver via_macii_driver; 51extern struct adb_driver via_maciisi_driver; 52extern struct adb_driver via_cuda_driver; 53extern struct adb_driver adb_iop_driver; 54extern struct adb_driver via_pmu_driver; 55extern struct adb_driver macio_adb_driver; 56 57static DEFINE_MUTEX(adb_mutex); 58static struct adb_driver *adb_driver_list[] = { 59#ifdef CONFIG_ADB_MACII 60 &via_macii_driver, 61#endif 62#ifdef CONFIG_ADB_MACIISI 63 &via_maciisi_driver, 64#endif 65#ifdef CONFIG_ADB_CUDA 66 &via_cuda_driver, 67#endif 68#ifdef CONFIG_ADB_IOP 69 &adb_iop_driver, 70#endif 71#if defined(CONFIG_ADB_PMU) || defined(CONFIG_ADB_PMU68K) 72 &via_pmu_driver, 73#endif 74#ifdef CONFIG_ADB_MACIO 75 &macio_adb_driver, 76#endif 77 NULL 78}; 79 80static struct class *adb_dev_class; 81 82static struct adb_driver *adb_controller; 83BLOCKING_NOTIFIER_HEAD(adb_client_list); 84static int adb_got_sleep; 85static int adb_inited; 86static DEFINE_SEMAPHORE(adb_probe_mutex); 87static int sleepy_trackpad; 88static int autopoll_devs; 89int __adb_probe_sync; 90 91static int adb_scan_bus(void); 92static int do_adb_reset_bus(void); 93static void adbdev_init(void); 94static int try_handler_change(int, int); 95 96static struct adb_handler { 97 void (*handler)(unsigned char *, int, int); 98 int original_address; 99 int handler_id; 100 int busy; 101} adb_handler[16]; 102 103/* 104 * The adb_handler_mutex mutex protects all accesses to the original_address 105 * and handler_id fields of adb_handler[i] for all i, and changes to the 106 * handler field. 107 * Accesses to the handler field are protected by the adb_handler_lock 108 * rwlock. It is held across all calls to any handler, so that by the 109 * time adb_unregister returns, we know that the old handler isn't being 110 * called. 111 */ 112static DEFINE_MUTEX(adb_handler_mutex); 113static DEFINE_RWLOCK(adb_handler_lock); 114 115#if 0 116static void printADBreply(struct adb_request *req) 117{ 118 int i; 119 120 printk("adb reply (%d)", req->reply_len); 121 for(i = 0; i < req->reply_len; i++) 122 printk(" %x", req->reply[i]); 123 printk("\n"); 124 125} 126#endif 127 128static int adb_scan_bus(void) 129{ 130 int i, highFree=0, noMovement; 131 int devmask = 0; 132 struct adb_request req; 133 134 /* assumes adb_handler[] is all zeroes at this point */ 135 for (i = 1; i < 16; i++) { 136 /* see if there is anything at address i */ 137 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 138 (i << 4) | 0xf); 139 if (req.reply_len > 1) 140 /* one or more devices at this address */ 141 adb_handler[i].original_address = i; 142 else if (i > highFree) 143 highFree = i; 144 } 145 146 /* Note we reset noMovement to 0 each time we move a device */ 147 for (noMovement = 1; noMovement < 2 && highFree > 0; noMovement++) { 148 for (i = 1; i < 16; i++) { 149 if (adb_handler[i].original_address == 0) 150 continue; 151 /* 152 * Send a "talk register 3" command to address i 153 * to provoke a collision if there is more than 154 * one device at this address. 155 */ 156 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 157 (i << 4) | 0xf); 158 /* 159 * Move the device(s) which didn't detect a 160 * collision to address `highFree'. Hopefully 161 * this only moves one device. 162 */ 163 adb_request(&req, NULL, ADBREQ_SYNC, 3, 164 (i<< 4) | 0xb, (highFree | 0x60), 0xfe); 165 /* 166 * See if anybody actually moved. This is suggested 167 * by HW TechNote 01: 168 * 169 * http://developer.apple.com/technotes/hw/hw_01.html 170 */ 171 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 172 (highFree << 4) | 0xf); 173 if (req.reply_len <= 1) continue; 174 /* 175 * Test whether there are any device(s) left 176 * at address i. 177 */ 178 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 179 (i << 4) | 0xf); 180 if (req.reply_len > 1) { 181 /* 182 * There are still one or more devices 183 * left at address i. Register the one(s) 184 * we moved to `highFree', and find a new 185 * value for highFree. 186 */ 187 adb_handler[highFree].original_address = 188 adb_handler[i].original_address; 189 while (highFree > 0 && 190 adb_handler[highFree].original_address) 191 highFree--; 192 if (highFree <= 0) 193 break; 194 195 noMovement = 0; 196 } else { 197 /* 198 * No devices left at address i; move the 199 * one(s) we moved to `highFree' back to i. 200 */ 201 adb_request(&req, NULL, ADBREQ_SYNC, 3, 202 (highFree << 4) | 0xb, 203 (i | 0x60), 0xfe); 204 } 205 } 206 } 207 208 /* Now fill in the handler_id field of the adb_handler entries. */ 209 printk(KERN_DEBUG "adb devices:"); 210 for (i = 1; i < 16; i++) { 211 if (adb_handler[i].original_address == 0) 212 continue; 213 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 214 (i << 4) | 0xf); 215 adb_handler[i].handler_id = req.reply[2]; 216 printk(" [%d]: %d %x", i, adb_handler[i].original_address, 217 adb_handler[i].handler_id); 218 devmask |= 1 << i; 219 } 220 printk("\n"); 221 return devmask; 222} 223 224/* 225 * This kernel task handles ADB probing. It dies once probing is 226 * completed. 227 */ 228static int 229adb_probe_task(void *x) 230{ 231 printk(KERN_INFO "adb: starting probe task...\n"); 232 do_adb_reset_bus(); 233 printk(KERN_INFO "adb: finished probe task...\n"); 234 235 up(&adb_probe_mutex); 236 237 return 0; 238} 239 240static void 241__adb_probe_task(struct work_struct *bullshit) 242{ 243 kthread_run(adb_probe_task, NULL, "kadbprobe"); 244} 245 246static DECLARE_WORK(adb_reset_work, __adb_probe_task); 247 248int 249adb_reset_bus(void) 250{ 251 if (__adb_probe_sync) { 252 do_adb_reset_bus(); 253 return 0; 254 } 255 256 down(&adb_probe_mutex); 257 schedule_work(&adb_reset_work); 258 return 0; 259} 260 261#ifdef CONFIG_PM 262/* 263 * notify clients before sleep 264 */ 265static int __adb_suspend(struct platform_device *dev, pm_message_t state) 266{ 267 adb_got_sleep = 1; 268 /* We need to get a lock on the probe thread */ 269 down(&adb_probe_mutex); 270 /* Stop autopoll */ 271 if (adb_controller->autopoll) 272 adb_controller->autopoll(0); 273 blocking_notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL); 274 275 return 0; 276} 277 278static int adb_suspend(struct device *dev) 279{ 280 return __adb_suspend(to_platform_device(dev), PMSG_SUSPEND); 281} 282 283static int adb_freeze(struct device *dev) 284{ 285 return __adb_suspend(to_platform_device(dev), PMSG_FREEZE); 286} 287 288static int adb_poweroff(struct device *dev) 289{ 290 return __adb_suspend(to_platform_device(dev), PMSG_HIBERNATE); 291} 292 293/* 294 * reset bus after sleep 295 */ 296static int __adb_resume(struct platform_device *dev) 297{ 298 adb_got_sleep = 0; 299 up(&adb_probe_mutex); 300 adb_reset_bus(); 301 302 return 0; 303} 304 305static int adb_resume(struct device *dev) 306{ 307 return __adb_resume(to_platform_device(dev)); 308} 309#endif /* CONFIG_PM */ 310 311static int __init adb_init(void) 312{ 313 struct adb_driver *driver; 314 int i; 315 316#ifdef CONFIG_PPC32 317 if (!machine_is(chrp) && !machine_is(powermac)) 318 return 0; 319#endif 320#ifdef CONFIG_MAC 321 if (!MACH_IS_MAC) 322 return 0; 323#endif 324 325 /* xmon may do early-init */ 326 if (adb_inited) 327 return 0; 328 adb_inited = 1; 329 330 adb_controller = NULL; 331 332 i = 0; 333 while ((driver = adb_driver_list[i++]) != NULL) { 334 if (!driver->probe()) { 335 adb_controller = driver; 336 break; 337 } 338 } 339 if (adb_controller != NULL && adb_controller->init && 340 adb_controller->init()) 341 adb_controller = NULL; 342 if (adb_controller == NULL) { 343 printk(KERN_WARNING "Warning: no ADB interface detected\n"); 344 } else { 345#ifdef CONFIG_PPC 346 if (of_machine_is_compatible("AAPL,PowerBook1998") || 347 of_machine_is_compatible("PowerBook1,1")) 348 sleepy_trackpad = 1; 349#endif /* CONFIG_PPC */ 350 351 adbdev_init(); 352 adb_reset_bus(); 353 } 354 return 0; 355} 356 357device_initcall(adb_init); 358 359static int 360do_adb_reset_bus(void) 361{ 362 int ret; 363 364 if (adb_controller == NULL) 365 return -ENXIO; 366 367 if (adb_controller->autopoll) 368 adb_controller->autopoll(0); 369 370 blocking_notifier_call_chain(&adb_client_list, 371 ADB_MSG_PRE_RESET, NULL); 372 373 if (sleepy_trackpad) { 374 /* Let the trackpad settle down */ 375 msleep(500); 376 } 377 378 mutex_lock(&adb_handler_mutex); 379 write_lock_irq(&adb_handler_lock); 380 memset(adb_handler, 0, sizeof(adb_handler)); 381 write_unlock_irq(&adb_handler_lock); 382 383 /* That one is still a bit synchronous, oh well... */ 384 if (adb_controller->reset_bus) 385 ret = adb_controller->reset_bus(); 386 else 387 ret = 0; 388 389 if (sleepy_trackpad) { 390 /* Let the trackpad settle down */ 391 msleep(1500); 392 } 393 394 if (!ret) { 395 autopoll_devs = adb_scan_bus(); 396 if (adb_controller->autopoll) 397 adb_controller->autopoll(autopoll_devs); 398 } 399 mutex_unlock(&adb_handler_mutex); 400 401 blocking_notifier_call_chain(&adb_client_list, 402 ADB_MSG_POST_RESET, NULL); 403 404 return ret; 405} 406 407void 408adb_poll(void) 409{ 410 if ((adb_controller == NULL)||(adb_controller->poll == NULL)) 411 return; 412 adb_controller->poll(); 413} 414EXPORT_SYMBOL(adb_poll); 415 416static void adb_sync_req_done(struct adb_request *req) 417{ 418 struct completion *comp = req->arg; 419 420 complete(comp); 421} 422 423int 424adb_request(struct adb_request *req, void (*done)(struct adb_request *), 425 int flags, int nbytes, ...) 426{ 427 va_list list; 428 int i; 429 int rc; 430 struct completion comp; 431 432 if ((adb_controller == NULL) || (adb_controller->send_request == NULL)) 433 return -ENXIO; 434 if (nbytes < 1) 435 return -EINVAL; 436 437 req->nbytes = nbytes+1; 438 req->done = done; 439 req->reply_expected = flags & ADBREQ_REPLY; 440 req->data[0] = ADB_PACKET; 441 va_start(list, nbytes); 442 for (i = 0; i < nbytes; ++i) 443 req->data[i+1] = va_arg(list, int); 444 va_end(list); 445 446 if (flags & ADBREQ_NOSEND) 447 return 0; 448 449 /* Synchronous requests block using an on-stack completion */ 450 if (flags & ADBREQ_SYNC) { 451 WARN_ON(done); 452 req->done = adb_sync_req_done; 453 req->arg = ∁ 454 init_completion(&comp); 455 } 456 457 rc = adb_controller->send_request(req, 0); 458 459 if ((flags & ADBREQ_SYNC) && !rc && !req->complete) 460 wait_for_completion(&comp); 461 462 return rc; 463} 464EXPORT_SYMBOL(adb_request); 465 466 /* Ultimately this should return the number of devices with 467 the given default id. 468 And it does it now ! Note: changed behaviour: This function 469 will now register if default_id _and_ handler_id both match 470 but handler_id can be left to 0 to match with default_id only. 471 When handler_id is set, this function will try to adjust 472 the handler_id id it doesn't match. */ 473int 474adb_register(int default_id, int handler_id, struct adb_ids *ids, 475 void (*handler)(unsigned char *, int, int)) 476{ 477 int i; 478 479 mutex_lock(&adb_handler_mutex); 480 ids->nids = 0; 481 for (i = 1; i < 16; i++) { 482 if ((adb_handler[i].original_address == default_id) && 483 (!handler_id || (handler_id == adb_handler[i].handler_id) || 484 try_handler_change(i, handler_id))) { 485 if (adb_handler[i].handler != 0) { 486 printk(KERN_ERR 487 "Two handlers for ADB device %d\n", 488 default_id); 489 continue; 490 } 491 write_lock_irq(&adb_handler_lock); 492 adb_handler[i].handler = handler; 493 write_unlock_irq(&adb_handler_lock); 494 ids->id[ids->nids++] = i; 495 } 496 } 497 mutex_unlock(&adb_handler_mutex); 498 return ids->nids; 499} 500EXPORT_SYMBOL(adb_register); 501 502int 503adb_unregister(int index) 504{ 505 int ret = -ENODEV; 506 507 mutex_lock(&adb_handler_mutex); 508 write_lock_irq(&adb_handler_lock); 509 if (adb_handler[index].handler) { 510 while(adb_handler[index].busy) { 511 write_unlock_irq(&adb_handler_lock); 512 yield(); 513 write_lock_irq(&adb_handler_lock); 514 } 515 ret = 0; 516 adb_handler[index].handler = NULL; 517 } 518 write_unlock_irq(&adb_handler_lock); 519 mutex_unlock(&adb_handler_mutex); 520 return ret; 521} 522EXPORT_SYMBOL(adb_unregister); 523 524void 525adb_input(unsigned char *buf, int nb, int autopoll) 526{ 527 int i, id; 528 static int dump_adb_input; 529 unsigned long flags; 530 531 void (*handler)(unsigned char *, int, int); 532 533 /* We skip keystrokes and mouse moves when the sleep process 534 * has been started. We stop autopoll, but this is another security 535 */ 536 if (adb_got_sleep) 537 return; 538 539 id = buf[0] >> 4; 540 if (dump_adb_input) { 541 printk(KERN_INFO "adb packet: "); 542 for (i = 0; i < nb; ++i) 543 printk(" %x", buf[i]); 544 printk(", id = %d\n", id); 545 } 546 write_lock_irqsave(&adb_handler_lock, flags); 547 handler = adb_handler[id].handler; 548 if (handler != NULL) 549 adb_handler[id].busy = 1; 550 write_unlock_irqrestore(&adb_handler_lock, flags); 551 if (handler != NULL) { 552 (*handler)(buf, nb, autopoll); 553 wmb(); 554 adb_handler[id].busy = 0; 555 } 556 557} 558 559/* Try to change handler to new_id. Will return 1 if successful. */ 560static int try_handler_change(int address, int new_id) 561{ 562 struct adb_request req; 563 564 if (adb_handler[address].handler_id == new_id) 565 return 1; 566 adb_request(&req, NULL, ADBREQ_SYNC, 3, 567 ADB_WRITEREG(address, 3), address | 0x20, new_id); 568 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 569 ADB_READREG(address, 3)); 570 if (req.reply_len < 2) 571 return 0; 572 if (req.reply[2] != new_id) 573 return 0; 574 adb_handler[address].handler_id = req.reply[2]; 575 576 return 1; 577} 578 579int 580adb_try_handler_change(int address, int new_id) 581{ 582 int ret; 583 584 mutex_lock(&adb_handler_mutex); 585 ret = try_handler_change(address, new_id); 586 mutex_unlock(&adb_handler_mutex); 587 return ret; 588} 589EXPORT_SYMBOL(adb_try_handler_change); 590 591int 592adb_get_infos(int address, int *original_address, int *handler_id) 593{ 594 mutex_lock(&adb_handler_mutex); 595 *original_address = adb_handler[address].original_address; 596 *handler_id = adb_handler[address].handler_id; 597 mutex_unlock(&adb_handler_mutex); 598 599 return (*original_address != 0); 600} 601 602 603/* 604 * /dev/adb device driver. 605 */ 606 607#define ADB_MAJOR 56 /* major number for /dev/adb */ 608 609struct adbdev_state { 610 spinlock_t lock; 611 atomic_t n_pending; 612 struct adb_request *completed; 613 wait_queue_head_t wait_queue; 614 int inuse; 615}; 616 617static void adb_write_done(struct adb_request *req) 618{ 619 struct adbdev_state *state = (struct adbdev_state *) req->arg; 620 unsigned long flags; 621 622 if (!req->complete) { 623 req->reply_len = 0; 624 req->complete = 1; 625 } 626 spin_lock_irqsave(&state->lock, flags); 627 atomic_dec(&state->n_pending); 628 if (!state->inuse) { 629 kfree(req); 630 if (atomic_read(&state->n_pending) == 0) { 631 spin_unlock_irqrestore(&state->lock, flags); 632 kfree(state); 633 return; 634 } 635 } else { 636 struct adb_request **ap = &state->completed; 637 while (*ap != NULL) 638 ap = &(*ap)->next; 639 req->next = NULL; 640 *ap = req; 641 wake_up_interruptible(&state->wait_queue); 642 } 643 spin_unlock_irqrestore(&state->lock, flags); 644} 645 646static int 647do_adb_query(struct adb_request *req) 648{ 649 int ret = -EINVAL; 650 651 switch(req->data[1]) { 652 case ADB_QUERY_GETDEVINFO: 653 if (req->nbytes < 3) 654 break; 655 mutex_lock(&adb_handler_mutex); 656 req->reply[0] = adb_handler[req->data[2]].original_address; 657 req->reply[1] = adb_handler[req->data[2]].handler_id; 658 mutex_unlock(&adb_handler_mutex); 659 req->complete = 1; 660 req->reply_len = 2; 661 adb_write_done(req); 662 ret = 0; 663 break; 664 } 665 return ret; 666} 667 668static int adb_open(struct inode *inode, struct file *file) 669{ 670 struct adbdev_state *state; 671 int ret = 0; 672 673 mutex_lock(&adb_mutex); 674 if (iminor(inode) > 0 || adb_controller == NULL) { 675 ret = -ENXIO; 676 goto out; 677 } 678 state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL); 679 if (state == 0) { 680 ret = -ENOMEM; 681 goto out; 682 } 683 file->private_data = state; 684 spin_lock_init(&state->lock); 685 atomic_set(&state->n_pending, 0); 686 state->completed = NULL; 687 init_waitqueue_head(&state->wait_queue); 688 state->inuse = 1; 689 690out: 691 mutex_unlock(&adb_mutex); 692 return ret; 693} 694 695static int adb_release(struct inode *inode, struct file *file) 696{ 697 struct adbdev_state *state = file->private_data; 698 unsigned long flags; 699 700 mutex_lock(&adb_mutex); 701 if (state) { 702 file->private_data = NULL; 703 spin_lock_irqsave(&state->lock, flags); 704 if (atomic_read(&state->n_pending) == 0 705 && state->completed == NULL) { 706 spin_unlock_irqrestore(&state->lock, flags); 707 kfree(state); 708 } else { 709 state->inuse = 0; 710 spin_unlock_irqrestore(&state->lock, flags); 711 } 712 } 713 mutex_unlock(&adb_mutex); 714 return 0; 715} 716 717static ssize_t adb_read(struct file *file, char __user *buf, 718 size_t count, loff_t *ppos) 719{ 720 int ret = 0; 721 struct adbdev_state *state = file->private_data; 722 struct adb_request *req; 723 DECLARE_WAITQUEUE(wait, current); 724 unsigned long flags; 725 726 if (count < 2) 727 return -EINVAL; 728 if (count > sizeof(req->reply)) 729 count = sizeof(req->reply); 730 if (!access_ok(VERIFY_WRITE, buf, count)) 731 return -EFAULT; 732 733 req = NULL; 734 spin_lock_irqsave(&state->lock, flags); 735 add_wait_queue(&state->wait_queue, &wait); 736 set_current_state(TASK_INTERRUPTIBLE); 737 738 for (;;) { 739 req = state->completed; 740 if (req != NULL) 741 state->completed = req->next; 742 else if (atomic_read(&state->n_pending) == 0) 743 ret = -EIO; 744 if (req != NULL || ret != 0) 745 break; 746 747 if (file->f_flags & O_NONBLOCK) { 748 ret = -EAGAIN; 749 break; 750 } 751 if (signal_pending(current)) { 752 ret = -ERESTARTSYS; 753 break; 754 } 755 spin_unlock_irqrestore(&state->lock, flags); 756 schedule(); 757 spin_lock_irqsave(&state->lock, flags); 758 } 759 760 set_current_state(TASK_RUNNING); 761 remove_wait_queue(&state->wait_queue, &wait); 762 spin_unlock_irqrestore(&state->lock, flags); 763 764 if (ret) 765 return ret; 766 767 ret = req->reply_len; 768 if (ret > count) 769 ret = count; 770 if (ret > 0 && copy_to_user(buf, req->reply, ret)) 771 ret = -EFAULT; 772 773 kfree(req); 774 return ret; 775} 776 777static ssize_t adb_write(struct file *file, const char __user *buf, 778 size_t count, loff_t *ppos) 779{ 780 int ret/*, i*/; 781 struct adbdev_state *state = file->private_data; 782 struct adb_request *req; 783 784 if (count < 2 || count > sizeof(req->data)) 785 return -EINVAL; 786 if (adb_controller == NULL) 787 return -ENXIO; 788 if (!access_ok(VERIFY_READ, buf, count)) 789 return -EFAULT; 790 791 req = kmalloc(sizeof(struct adb_request), 792 GFP_KERNEL); 793 if (req == NULL) 794 return -ENOMEM; 795 796 req->nbytes = count; 797 req->done = adb_write_done; 798 req->arg = (void *) state; 799 req->complete = 0; 800 801 ret = -EFAULT; 802 if (copy_from_user(req->data, buf, count)) 803 goto out; 804 805 atomic_inc(&state->n_pending); 806 807 /* If a probe is in progress or we are sleeping, wait for it to complete */ 808 down(&adb_probe_mutex); 809 810 /* Queries are special requests sent to the ADB driver itself */ 811 if (req->data[0] == ADB_QUERY) { 812 if (count > 1) 813 ret = do_adb_query(req); 814 else 815 ret = -EINVAL; 816 up(&adb_probe_mutex); 817 } 818 /* Special case for ADB_BUSRESET request, all others are sent to 819 the controller */ 820 else if ((req->data[0] == ADB_PACKET) && (count > 1) 821 && (req->data[1] == ADB_BUSRESET)) { 822 ret = do_adb_reset_bus(); 823 up(&adb_probe_mutex); 824 atomic_dec(&state->n_pending); 825 if (ret == 0) 826 ret = count; 827 goto out; 828 } else { 829 req->reply_expected = ((req->data[1] & 0xc) == 0xc); 830 if (adb_controller && adb_controller->send_request) 831 ret = adb_controller->send_request(req, 0); 832 else 833 ret = -ENXIO; 834 up(&adb_probe_mutex); 835 } 836 837 if (ret != 0) { 838 atomic_dec(&state->n_pending); 839 goto out; 840 } 841 return count; 842 843out: 844 kfree(req); 845 return ret; 846} 847 848static const struct file_operations adb_fops = { 849 .owner = THIS_MODULE, 850 .llseek = no_llseek, 851 .read = adb_read, 852 .write = adb_write, 853 .open = adb_open, 854 .release = adb_release, 855}; 856 857#ifdef CONFIG_PM 858static const struct dev_pm_ops adb_dev_pm_ops = { 859 .suspend = adb_suspend, 860 .resume = adb_resume, 861 /* Hibernate hooks */ 862 .freeze = adb_freeze, 863 .thaw = adb_resume, 864 .poweroff = adb_poweroff, 865 .restore = adb_resume, 866}; 867#endif 868 869static struct platform_driver adb_pfdrv = { 870 .driver = { 871 .name = "adb", 872#ifdef CONFIG_PM 873 .pm = &adb_dev_pm_ops, 874#endif 875 }, 876}; 877 878static struct platform_device adb_pfdev = { 879 .name = "adb", 880}; 881 882static int __init 883adb_dummy_probe(struct platform_device *dev) 884{ 885 if (dev == &adb_pfdev) 886 return 0; 887 return -ENODEV; 888} 889 890static void __init 891adbdev_init(void) 892{ 893 if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) { 894 printk(KERN_ERR "adb: unable to get major %d\n", ADB_MAJOR); 895 return; 896 } 897 898 adb_dev_class = class_create(THIS_MODULE, "adb"); 899 if (IS_ERR(adb_dev_class)) 900 return; 901 device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), NULL, "adb"); 902 903 platform_device_register(&adb_pfdev); 904 platform_driver_probe(&adb_pfdrv, adb_dummy_probe); 905} 906