drivers/macintosh/adb.c

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