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/smp_lock.h> 28 #include <linux/adb.h> 29 #include <linux/cuda.h> 30 #include <linux/pmu.h> 31 #include <linux/notifier.h> 32 #include <linux/wait.h> 33 #include <linux/init.h> 34 #include <linux/delay.h> 35 #include <linux/spinlock.h> 36 #include <linux/completion.h> 37 #include <linux/device.h> 38 #include <linux/kthread.h> 39 #include <linux/platform_device.h> 40 #include <linux/mutex.h> 41 42 #include <asm/uaccess.h> 43 #ifdef CONFIG_PPC 44 #include <asm/prom.h> 45 #include <asm/machdep.h> 46 #endif 47 48 49 EXPORT_SYMBOL(adb_client_list); 50 51 extern struct adb_driver via_macii_driver; 52 extern struct adb_driver via_maciisi_driver; 53 extern struct adb_driver via_cuda_driver; 54 extern struct adb_driver adb_iop_driver; 55 extern struct adb_driver via_pmu_driver; 56 extern struct adb_driver macio_adb_driver; 57 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 DECLARE_MUTEX(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 } 197 else { 198 /* 199 * No devices left at address i; move the 200 * one(s) we moved to `highFree' back to i. 201 */ 202 adb_request(&req, NULL, ADBREQ_SYNC, 3, 203 (highFree << 4) | 0xb, 204 (i | 0x60), 0xfe); 205 } 206 } 207 } 208 209 /* Now fill in the handler_id field of the adb_handler entries. */ 210 printk(KERN_DEBUG "adb devices:"); 211 for (i = 1; i < 16; i++) { 212 if (adb_handler[i].original_address == 0) 213 continue; 214 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 215 (i << 4) | 0xf); 216 adb_handler[i].handler_id = req.reply[2]; 217 printk(" [%d]: %d %x", i, adb_handler[i].original_address, 218 adb_handler[i].handler_id); 219 devmask |= 1 << i; 220 } 221 printk("\n"); 222 return devmask; 223 } 224 225 /* 226 * This kernel task handles ADB probing. It dies once probing is 227 * completed. 228 */ 229 static int 230 adb_probe_task(void *x) 231 { 232 printk(KERN_INFO "adb: starting probe task...\n"); 233 do_adb_reset_bus(); 234 printk(KERN_INFO "adb: finished probe task...\n"); 235 236 up(&adb_probe_mutex); 237 238 return 0; 239 } 240 241 static void 242 __adb_probe_task(struct work_struct *bullshit) 243 { 244 kthread_run(adb_probe_task, NULL, "kadbprobe"); 245 } 246 247 static DECLARE_WORK(adb_reset_work, __adb_probe_task); 248 249 int 250 adb_reset_bus(void) 251 { 252 if (__adb_probe_sync) { 253 do_adb_reset_bus(); 254 return 0; 255 } 256 257 down(&adb_probe_mutex); 258 schedule_work(&adb_reset_work); 259 return 0; 260 } 261 262 #ifdef CONFIG_PM 263 /* 264 * notify clients before sleep 265 */ 266 static int adb_suspend(struct platform_device *dev, pm_message_t state) 267 { 268 adb_got_sleep = 1; 269 /* We need to get a lock on the probe thread */ 270 down(&adb_probe_mutex); 271 /* Stop autopoll */ 272 if (adb_controller->autopoll) 273 adb_controller->autopoll(0); 274 blocking_notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL); 275 276 return 0; 277 } 278 279 /* 280 * reset bus after sleep 281 */ 282 static int adb_resume(struct platform_device *dev) 283 { 284 adb_got_sleep = 0; 285 up(&adb_probe_mutex); 286 adb_reset_bus(); 287 288 return 0; 289 } 290 #endif /* CONFIG_PM */ 291 292 static int __init adb_init(void) 293 { 294 struct adb_driver *driver; 295 int i; 296 297 #ifdef CONFIG_PPC32 298 if (!machine_is(chrp) && !machine_is(powermac)) 299 return 0; 300 #endif 301 #ifdef CONFIG_MAC 302 if (!MACH_IS_MAC) 303 return 0; 304 #endif 305 306 /* xmon may do early-init */ 307 if (adb_inited) 308 return 0; 309 adb_inited = 1; 310 311 adb_controller = NULL; 312 313 i = 0; 314 while ((driver = adb_driver_list[i++]) != NULL) { 315 if (!driver->probe()) { 316 adb_controller = driver; 317 break; 318 } 319 } 320 if ((adb_controller == NULL) || adb_controller->init()) { 321 printk(KERN_WARNING "Warning: no ADB interface detected\n"); 322 adb_controller = NULL; 323 } else { 324 #ifdef CONFIG_PPC 325 if (machine_is_compatible("AAPL,PowerBook1998") || 326 machine_is_compatible("PowerBook1,1")) 327 sleepy_trackpad = 1; 328 #endif /* CONFIG_PPC */ 329 330 adbdev_init(); 331 adb_reset_bus(); 332 } 333 return 0; 334 } 335 336 device_initcall(adb_init); 337 338 static int 339 do_adb_reset_bus(void) 340 { 341 int ret; 342 343 if (adb_controller == NULL) 344 return -ENXIO; 345 346 if (adb_controller->autopoll) 347 adb_controller->autopoll(0); 348 349 blocking_notifier_call_chain(&adb_client_list, 350 ADB_MSG_PRE_RESET, NULL); 351 352 if (sleepy_trackpad) { 353 /* Let the trackpad settle down */ 354 msleep(500); 355 } 356 357 mutex_lock(&adb_handler_mutex); 358 write_lock_irq(&adb_handler_lock); 359 memset(adb_handler, 0, sizeof(adb_handler)); 360 write_unlock_irq(&adb_handler_lock); 361 362 /* That one is still a bit synchronous, oh well... */ 363 if (adb_controller->reset_bus) 364 ret = adb_controller->reset_bus(); 365 else 366 ret = 0; 367 368 if (sleepy_trackpad) { 369 /* Let the trackpad settle down */ 370 msleep(1500); 371 } 372 373 if (!ret) { 374 autopoll_devs = adb_scan_bus(); 375 if (adb_controller->autopoll) 376 adb_controller->autopoll(autopoll_devs); 377 } 378 mutex_unlock(&adb_handler_mutex); 379 380 blocking_notifier_call_chain(&adb_client_list, 381 ADB_MSG_POST_RESET, NULL); 382 383 return ret; 384 } 385 386 void 387 adb_poll(void) 388 { 389 if ((adb_controller == NULL)||(adb_controller->poll == NULL)) 390 return; 391 adb_controller->poll(); 392 } 393 394 static void adb_sync_req_done(struct adb_request *req) 395 { 396 struct completion *comp = req->arg; 397 398 complete(comp); 399 } 400 401 int 402 adb_request(struct adb_request *req, void (*done)(struct adb_request *), 403 int flags, int nbytes, ...) 404 { 405 va_list list; 406 int i; 407 int rc; 408 struct completion comp; 409 410 if ((adb_controller == NULL) || (adb_controller->send_request == NULL)) 411 return -ENXIO; 412 if (nbytes < 1) 413 return -EINVAL; 414 415 req->nbytes = nbytes+1; 416 req->done = done; 417 req->reply_expected = flags & ADBREQ_REPLY; 418 req->data[0] = ADB_PACKET; 419 va_start(list, nbytes); 420 for (i = 0; i < nbytes; ++i) 421 req->data[i+1] = va_arg(list, int); 422 va_end(list); 423 424 if (flags & ADBREQ_NOSEND) 425 return 0; 426 427 /* Synchronous requests block using an on-stack completion */ 428 if (flags & ADBREQ_SYNC) { 429 WARN_ON(done); 430 req->done = adb_sync_req_done; 431 req->arg = ∁ 432 init_completion(&comp); 433 } 434 435 rc = adb_controller->send_request(req, 0); 436 437 if ((flags & ADBREQ_SYNC) && !rc && !req->complete) 438 wait_for_completion(&comp); 439 440 return rc; 441 } 442 443 /* Ultimately this should return the number of devices with 444 the given default id. 445 And it does it now ! Note: changed behaviour: This function 446 will now register if default_id _and_ handler_id both match 447 but handler_id can be left to 0 to match with default_id only. 448 When handler_id is set, this function will try to adjust 449 the handler_id id it doesn't match. */ 450 int 451 adb_register(int default_id, int handler_id, struct adb_ids *ids, 452 void (*handler)(unsigned char *, int, int)) 453 { 454 int i; 455 456 mutex_lock(&adb_handler_mutex); 457 ids->nids = 0; 458 for (i = 1; i < 16; i++) { 459 if ((adb_handler[i].original_address == default_id) && 460 (!handler_id || (handler_id == adb_handler[i].handler_id) || 461 try_handler_change(i, handler_id))) { 462 if (adb_handler[i].handler != 0) { 463 printk(KERN_ERR 464 "Two handlers for ADB device %d\n", 465 default_id); 466 continue; 467 } 468 write_lock_irq(&adb_handler_lock); 469 adb_handler[i].handler = handler; 470 write_unlock_irq(&adb_handler_lock); 471 ids->id[ids->nids++] = i; 472 } 473 } 474 mutex_unlock(&adb_handler_mutex); 475 return ids->nids; 476 } 477 478 int 479 adb_unregister(int index) 480 { 481 int ret = -ENODEV; 482 483 mutex_lock(&adb_handler_mutex); 484 write_lock_irq(&adb_handler_lock); 485 if (adb_handler[index].handler) { 486 while(adb_handler[index].busy) { 487 write_unlock_irq(&adb_handler_lock); 488 yield(); 489 write_lock_irq(&adb_handler_lock); 490 } 491 ret = 0; 492 adb_handler[index].handler = NULL; 493 } 494 write_unlock_irq(&adb_handler_lock); 495 mutex_unlock(&adb_handler_mutex); 496 return ret; 497 } 498 499 void 500 adb_input(unsigned char *buf, int nb, int autopoll) 501 { 502 int i, id; 503 static int dump_adb_input = 0; 504 unsigned long flags; 505 506 void (*handler)(unsigned char *, int, int); 507 508 /* We skip keystrokes and mouse moves when the sleep process 509 * has been started. We stop autopoll, but this is another security 510 */ 511 if (adb_got_sleep) 512 return; 513 514 id = buf[0] >> 4; 515 if (dump_adb_input) { 516 printk(KERN_INFO "adb packet: "); 517 for (i = 0; i < nb; ++i) 518 printk(" %x", buf[i]); 519 printk(", id = %d\n", id); 520 } 521 write_lock_irqsave(&adb_handler_lock, flags); 522 handler = adb_handler[id].handler; 523 if (handler != NULL) 524 adb_handler[id].busy = 1; 525 write_unlock_irqrestore(&adb_handler_lock, flags); 526 if (handler != NULL) { 527 (*handler)(buf, nb, autopoll); 528 wmb(); 529 adb_handler[id].busy = 0; 530 } 531 532 } 533 534 /* Try to change handler to new_id. Will return 1 if successful. */ 535 static int try_handler_change(int address, int new_id) 536 { 537 struct adb_request req; 538 539 if (adb_handler[address].handler_id == new_id) 540 return 1; 541 adb_request(&req, NULL, ADBREQ_SYNC, 3, 542 ADB_WRITEREG(address, 3), address | 0x20, new_id); 543 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1, 544 ADB_READREG(address, 3)); 545 if (req.reply_len < 2) 546 return 0; 547 if (req.reply[2] != new_id) 548 return 0; 549 adb_handler[address].handler_id = req.reply[2]; 550 551 return 1; 552 } 553 554 int 555 adb_try_handler_change(int address, int new_id) 556 { 557 int ret; 558 559 mutex_lock(&adb_handler_mutex); 560 ret = try_handler_change(address, new_id); 561 mutex_unlock(&adb_handler_mutex); 562 return ret; 563 } 564 565 int 566 adb_get_infos(int address, int *original_address, int *handler_id) 567 { 568 mutex_lock(&adb_handler_mutex); 569 *original_address = adb_handler[address].original_address; 570 *handler_id = adb_handler[address].handler_id; 571 mutex_unlock(&adb_handler_mutex); 572 573 return (*original_address != 0); 574 } 575 576 577 /* 578 * /dev/adb device driver. 579 */ 580 581 #define ADB_MAJOR 56 /* major number for /dev/adb */ 582 583 struct adbdev_state { 584 spinlock_t lock; 585 atomic_t n_pending; 586 struct adb_request *completed; 587 wait_queue_head_t wait_queue; 588 int inuse; 589 }; 590 591 static void adb_write_done(struct adb_request *req) 592 { 593 struct adbdev_state *state = (struct adbdev_state *) req->arg; 594 unsigned long flags; 595 596 if (!req->complete) { 597 req->reply_len = 0; 598 req->complete = 1; 599 } 600 spin_lock_irqsave(&state->lock, flags); 601 atomic_dec(&state->n_pending); 602 if (!state->inuse) { 603 kfree(req); 604 if (atomic_read(&state->n_pending) == 0) { 605 spin_unlock_irqrestore(&state->lock, flags); 606 kfree(state); 607 return; 608 } 609 } else { 610 struct adb_request **ap = &state->completed; 611 while (*ap != NULL) 612 ap = &(*ap)->next; 613 req->next = NULL; 614 *ap = req; 615 wake_up_interruptible(&state->wait_queue); 616 } 617 spin_unlock_irqrestore(&state->lock, flags); 618 } 619 620 static int 621 do_adb_query(struct adb_request *req) 622 { 623 int ret = -EINVAL; 624 625 switch(req->data[1]) 626 { 627 case ADB_QUERY_GETDEVINFO: 628 if (req->nbytes < 3) 629 break; 630 mutex_lock(&adb_handler_mutex); 631 req->reply[0] = adb_handler[req->data[2]].original_address; 632 req->reply[1] = adb_handler[req->data[2]].handler_id; 633 mutex_unlock(&adb_handler_mutex); 634 req->complete = 1; 635 req->reply_len = 2; 636 adb_write_done(req); 637 ret = 0; 638 break; 639 } 640 return ret; 641 } 642 643 static int adb_open(struct inode *inode, struct file *file) 644 { 645 struct adbdev_state *state; 646 int ret = 0; 647 648 lock_kernel(); 649 if (iminor(inode) > 0 || adb_controller == NULL) { 650 ret = -ENXIO; 651 goto out; 652 } 653 state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL); 654 if (state == 0) { 655 ret = -ENOMEM; 656 goto out; 657 } 658 file->private_data = state; 659 spin_lock_init(&state->lock); 660 atomic_set(&state->n_pending, 0); 661 state->completed = NULL; 662 init_waitqueue_head(&state->wait_queue); 663 state->inuse = 1; 664 665 out: 666 unlock_kernel(); 667 return ret; 668 } 669 670 static int adb_release(struct inode *inode, struct file *file) 671 { 672 struct adbdev_state *state = file->private_data; 673 unsigned long flags; 674 675 lock_kernel(); 676 if (state) { 677 file->private_data = NULL; 678 spin_lock_irqsave(&state->lock, flags); 679 if (atomic_read(&state->n_pending) == 0 680 && state->completed == NULL) { 681 spin_unlock_irqrestore(&state->lock, flags); 682 kfree(state); 683 } else { 684 state->inuse = 0; 685 spin_unlock_irqrestore(&state->lock, flags); 686 } 687 } 688 unlock_kernel(); 689 return 0; 690 } 691 692 static ssize_t adb_read(struct file *file, char __user *buf, 693 size_t count, loff_t *ppos) 694 { 695 int ret = 0; 696 struct adbdev_state *state = file->private_data; 697 struct adb_request *req; 698 wait_queue_t wait = __WAITQUEUE_INITIALIZER(wait,current); 699 unsigned long flags; 700 701 if (count < 2) 702 return -EINVAL; 703 if (count > sizeof(req->reply)) 704 count = sizeof(req->reply); 705 if (!access_ok(VERIFY_WRITE, buf, count)) 706 return -EFAULT; 707 708 req = NULL; 709 spin_lock_irqsave(&state->lock, flags); 710 add_wait_queue(&state->wait_queue, &wait); 711 current->state = TASK_INTERRUPTIBLE; 712 713 for (;;) { 714 req = state->completed; 715 if (req != NULL) 716 state->completed = req->next; 717 else if (atomic_read(&state->n_pending) == 0) 718 ret = -EIO; 719 if (req != NULL || ret != 0) 720 break; 721 722 if (file->f_flags & O_NONBLOCK) { 723 ret = -EAGAIN; 724 break; 725 } 726 if (signal_pending(current)) { 727 ret = -ERESTARTSYS; 728 break; 729 } 730 spin_unlock_irqrestore(&state->lock, flags); 731 schedule(); 732 spin_lock_irqsave(&state->lock, flags); 733 } 734 735 current->state = TASK_RUNNING; 736 remove_wait_queue(&state->wait_queue, &wait); 737 spin_unlock_irqrestore(&state->lock, flags); 738 739 if (ret) 740 return ret; 741 742 ret = req->reply_len; 743 if (ret > count) 744 ret = count; 745 if (ret > 0 && copy_to_user(buf, req->reply, ret)) 746 ret = -EFAULT; 747 748 kfree(req); 749 return ret; 750 } 751 752 static ssize_t adb_write(struct file *file, const char __user *buf, 753 size_t count, loff_t *ppos) 754 { 755 int ret/*, i*/; 756 struct adbdev_state *state = file->private_data; 757 struct adb_request *req; 758 759 if (count < 2 || count > sizeof(req->data)) 760 return -EINVAL; 761 if (adb_controller == NULL) 762 return -ENXIO; 763 if (!access_ok(VERIFY_READ, buf, count)) 764 return -EFAULT; 765 766 req = kmalloc(sizeof(struct adb_request), 767 GFP_KERNEL); 768 if (req == NULL) 769 return -ENOMEM; 770 771 req->nbytes = count; 772 req->done = adb_write_done; 773 req->arg = (void *) state; 774 req->complete = 0; 775 776 ret = -EFAULT; 777 if (copy_from_user(req->data, buf, count)) 778 goto out; 779 780 atomic_inc(&state->n_pending); 781 782 /* If a probe is in progress or we are sleeping, wait for it to complete */ 783 down(&adb_probe_mutex); 784 785 /* Queries are special requests sent to the ADB driver itself */ 786 if (req->data[0] == ADB_QUERY) { 787 if (count > 1) 788 ret = do_adb_query(req); 789 else 790 ret = -EINVAL; 791 up(&adb_probe_mutex); 792 } 793 /* Special case for ADB_BUSRESET request, all others are sent to 794 the controller */ 795 else if ((req->data[0] == ADB_PACKET)&&(count > 1) 796 &&(req->data[1] == ADB_BUSRESET)) { 797 ret = do_adb_reset_bus(); 798 up(&adb_probe_mutex); 799 atomic_dec(&state->n_pending); 800 if (ret == 0) 801 ret = count; 802 goto out; 803 } else { 804 req->reply_expected = ((req->data[1] & 0xc) == 0xc); 805 if (adb_controller && adb_controller->send_request) 806 ret = adb_controller->send_request(req, 0); 807 else 808 ret = -ENXIO; 809 up(&adb_probe_mutex); 810 } 811 812 if (ret != 0) { 813 atomic_dec(&state->n_pending); 814 goto out; 815 } 816 return count; 817 818 out: 819 kfree(req); 820 return ret; 821 } 822 823 static const struct file_operations adb_fops = { 824 .owner = THIS_MODULE, 825 .llseek = no_llseek, 826 .read = adb_read, 827 .write = adb_write, 828 .open = adb_open, 829 .release = adb_release, 830 }; 831 832 static struct platform_driver adb_pfdrv = { 833 .driver = { 834 .name = "adb", 835 }, 836 #ifdef CONFIG_PM 837 .suspend = adb_suspend, 838 .resume = adb_resume, 839 #endif 840 }; 841 842 static struct platform_device adb_pfdev = { 843 .name = "adb", 844 }; 845 846 static int __init 847 adb_dummy_probe(struct platform_device *dev) 848 { 849 if (dev == &adb_pfdev) 850 return 0; 851 return -ENODEV; 852 } 853 854 static void __init 855 adbdev_init(void) 856 { 857 if (register_chrdev(ADB_MAJOR, "adb", &adb_fops)) { 858 printk(KERN_ERR "adb: unable to get major %d\n", ADB_MAJOR); 859 return; 860 } 861 862 adb_dev_class = class_create(THIS_MODULE, "adb"); 863 if (IS_ERR(adb_dev_class)) 864 return; 865 device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), NULL, "adb"); 866 867 platform_device_register(&adb_pfdev); 868 platform_driver_probe(&adb_pfdrv, adb_dummy_probe); 869 } 870