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