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 48 EXPORT_SYMBOL(adb_client_list); 49 50 extern struct adb_driver via_macii_driver; 51 extern struct adb_driver via_maciisi_driver; 52 extern struct adb_driver via_cuda_driver; 53 extern struct adb_driver adb_iop_driver; 54 extern struct adb_driver via_pmu_driver; 55 extern struct adb_driver macio_adb_driver; 56 57 static DEFINE_MUTEX(adb_mutex); 58 static 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 80 static struct class *adb_dev_class; 81 82 static struct adb_driver *adb_controller; 83 BLOCKING_NOTIFIER_HEAD(adb_client_list); 84 static int adb_got_sleep; 85 static int adb_inited; 86 static DEFINE_SEMAPHORE(adb_probe_mutex); 87 static int sleepy_trackpad; 88 static int autopoll_devs; 89 int __adb_probe_sync; 90 91 static int adb_scan_bus(void); 92 static int do_adb_reset_bus(void); 93 static void adbdev_init(void); 94 static int try_handler_change(int, int); 95 96 static 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 */ 112 static DEFINE_MUTEX(adb_handler_mutex); 113 static DEFINE_RWLOCK(adb_handler_lock); 114 115 #if 0 116 static 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 128 static 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 */ 228 static int 229 adb_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 240 static void 241 __adb_probe_task(struct work_struct *bullshit) 242 { 243 kthread_run(adb_probe_task, NULL, "kadbprobe"); 244 } 245 246 static DECLARE_WORK(adb_reset_work, __adb_probe_task); 247 248 int 249 adb_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 */ 265 static 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 278 static int adb_suspend(struct device *dev) 279 { 280 return __adb_suspend(to_platform_device(dev), PMSG_SUSPEND); 281 } 282 283 static int adb_freeze(struct device *dev) 284 { 285 return __adb_suspend(to_platform_device(dev), PMSG_FREEZE); 286 } 287 288 static 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 */ 296 static 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 305 static int adb_resume(struct device *dev) 306 { 307 return __adb_resume(to_platform_device(dev)); 308 } 309 #endif /* CONFIG_PM */ 310 311 static 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 357 device_initcall(adb_init); 358 359 static int 360 do_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 407 void 408 adb_poll(void) 409 { 410 if ((adb_controller == NULL)||(adb_controller->poll == NULL)) 411 return; 412 adb_controller->poll(); 413 } 414 EXPORT_SYMBOL(adb_poll); 415 416 static void adb_sync_req_done(struct adb_request *req) 417 { 418 struct completion *comp = req->arg; 419 420 complete(comp); 421 } 422 423 int 424 adb_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 } 464 EXPORT_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. */ 473 int 474 adb_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 } 500 EXPORT_SYMBOL(adb_register); 501 502 int 503 adb_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 } 522 EXPORT_SYMBOL(adb_unregister); 523 524 void 525 adb_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. */ 560 static 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 579 int 580 adb_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 } 589 EXPORT_SYMBOL(adb_try_handler_change); 590 591 int 592 adb_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 609 struct 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 617 static 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 646 static int 647 do_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 668 static 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 690 out: 691 mutex_unlock(&adb_mutex); 692 return ret; 693 } 694 695 static 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 717 static 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 777 static 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 843 out: 844 kfree(req); 845 return ret; 846 } 847 848 static 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 858 static 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 869 static 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 878 static struct platform_device adb_pfdev = { 879 .name = "adb", 880 }; 881 882 static int __init 883 adb_dummy_probe(struct platform_device *dev) 884 { 885 if (dev == &adb_pfdev) 886 return 0; 887 return -ENODEV; 888 } 889 890 static void __init 891 adbdev_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