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