SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 #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 }