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