开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
adb.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：18k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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.  * - /proc/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.  */
  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/devfs_fs_kernel.h>
  27. #include <linux/mm.h>
  28. #include <linux/sched.h>
  29. #include <linux/smp_lock.h>
  30. #include <linux/adb.h>
  31. #include <linux/cuda.h>
  32. #include <linux/pmu.h>
  33. #include <linux/notifier.h>
  34. #include <linux/wait.h>
  35. #include <linux/init.h>
  36. #include <linux/delay.h>
  37. #include <linux/completion.h>
  38. #include <asm/uaccess.h>
  39. #ifdef CONFIG_PPC
  40. #include <asm/prom.h>
  41. #include <asm/hydra.h>
  42. #endif
  44. EXPORT_SYMBOL(adb_controller);
  45. EXPORT_SYMBOL(adb_client_list);
  47. extern struct adb_driver via_macii_driver;
  48. extern struct adb_driver via_maciisi_driver;
  49. extern struct adb_driver via_cuda_driver;
  50. extern struct adb_driver adb_iop_driver;
  51. extern struct adb_driver via_pmu_driver;
  52. extern struct adb_driver macio_adb_driver;
  54. static struct adb_driver *adb_driver_list[] = {
  55. #ifdef CONFIG_ADB_MACII
  56. &via_macii_driver,
  57. #endif
  58. #ifdef CONFIG_ADB_MACIISI
  59. &via_maciisi_driver,
  60. #endif
  61. #ifdef CONFIG_ADB_CUDA
  62. &via_cuda_driver,
  63. #endif
  64. #ifdef CONFIG_ADB_IOP
  65. &adb_iop_driver,
  66. #endif
  67. #if defined(CONFIG_ADB_PMU) || defined(CONFIG_ADB_PMU68K)
  68. &via_pmu_driver,
  69. #endif
  70. #ifdef CONFIG_ADB_MACIO
  71. &macio_adb_driver,
  72. #endif
  73. NULL
  74. };
  76. struct adb_driver *adb_controller;
  77. struct notifier_block *adb_client_list = NULL;
  78. static int adb_got_sleep = 0;
  79. static int adb_inited = 0;
  80. static pid_t adb_probe_task_pid;
  81. static DECLARE_MUTEX(adb_probe_mutex);
  82. static struct completion adb_probe_task_comp;
  83. static int sleepy_trackpad;
  84. int __adb_probe_sync;
  86. #ifdef CONFIG_PMAC_PBOOK
  87. static int adb_notify_sleep(struct pmu_sleep_notifier *self, int when);
  88. static struct pmu_sleep_notifier adb_sleep_notifier = {
  89. adb_notify_sleep,
  90. SLEEP_LEVEL_ADB,
  91. };
  92. #endif
  94. static int adb_scan_bus(void);
  95. static int do_adb_reset_bus(void);
  96. static void adbdev_init(void);
  99. static struct adb_handler {
  100. void (*handler)(unsigned char *, int, struct pt_regs *, int);
  101. int original_address;
  102. int handler_id;
  103. } adb_handler[16];
  105. #if 0
  106. static void printADBreply(struct adb_request *req)
  107. {
  108.         int i;
  110.         printk("adb reply (%d)", req->reply_len);
  111.         for(i = 0; i < req->reply_len; i++)
  112.                 printk(" %x", req->reply[i]);
  113.         printk("n");
  115. }
  116. #endif
  119. static __inline__ void adb_wait_ms(unsigned int ms)
  120. {
  121. if (current->pid && adb_probe_task_pid &&
  122.   adb_probe_task_pid == current->pid) {
  123. current->state = TASK_UNINTERRUPTIBLE;
  124. schedule_timeout(1 + ms * HZ / 1000);
  125. } else
  126. mdelay(ms);
  127. }
  129. static int adb_scan_bus(void)
  130. {
  131. int i, highFree=0, noMovement;
  132. int devmask = 0;
  133. struct adb_request req;
  135. /* assumes adb_handler[] is all zeroes at this point */
  136. for (i = 1; i < 16; i++) {
  137. /* see if there is anything at address i */
  138. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  139.                             (i << 4) | 0xf);
  140. if (req.reply_len > 1)
  141. /* one or more devices at this address */
  142. adb_handler[i].original_address = i;
  143. else if (i > highFree)
  144. highFree = i;
  145. }
  147. /* Note we reset noMovement to 0 each time we move a device */
  148. for (noMovement = 1; noMovement < 2 && highFree > 0; noMovement++) {
  149. for (i = 1; i < 16; i++) {
  150. if (adb_handler[i].original_address == 0)
  151. continue;
  152. /*
  153.  * Send a "talk register 3" command to address i
  154.  * to provoke a collision if there is more than
  155.  * one device at this address.
  156.  */
  157. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  158.     (i << 4) | 0xf);
  159. /*
  160.  * Move the device(s) which didn't detect a
  161.  * collision to address `highFree'.  Hopefully
  162.  * this only moves one device.
  163.  */
  164. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  165.     (i<< 4) | 0xb, (highFree | 0x60), 0xfe);
  166. /*
  167.  * See if anybody actually moved. This is suggested
  168.  * by HW TechNote 01:
  169.  *
  170.  * http://developer.apple.com/technotes/hw/hw_01.html
  171.  */
  172. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  173.     (highFree << 4) | 0xf);
  174. if (req.reply_len <= 1) continue;
  175. /*
  176.  * Test whether there are any device(s) left
  177.  * at address i.
  178.  */
  179. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  180.     (i << 4) | 0xf);
  181. if (req.reply_len > 1) {
  182. /*
  183.  * There are still one or more devices
  184.  * left at address i.  Register the one(s)
  185.  * we moved to `highFree', and find a new
  186.  * value for highFree.
  187.  */
  188. adb_handler[highFree].original_address =
  189. adb_handler[i].original_address;
  190. while (highFree > 0 &&
  191.        adb_handler[highFree].original_address)
  192. highFree--;
  193. if (highFree <= 0)
  194. break;
  196. noMovement = 0;
  197. }
  198. else {
  199. /*
  200.  * No devices left at address i; move the
  201.  * one(s) we moved to `highFree' back to i.
  202.  */
  203. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  204.     (highFree << 4) | 0xb,
  205.     (i | 0x60), 0xfe);
  206. }
  207. }
  208. }
  210. /* Now fill in the handler_id field of the adb_handler entries. */
  211. printk(KERN_DEBUG "adb devices:");
  212. for (i = 1; i < 16; i++) {
  213. if (adb_handler[i].original_address == 0)
  214. continue;
  215. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  216.     (i << 4) | 0xf);
  217. adb_handler[i].handler_id = req.reply[2];
  218. printk(" [%d]: %d %x", i, adb_handler[i].original_address,
  219.        adb_handler[i].handler_id);
  220. devmask |= 1 << i;
  221. }
  222. printk("n");
  223. return devmask;
  224. }
  226. /*
  227.  * This kernel task handles ADB probing. It dies once probing is
  228.  * completed.
  229.  */
  230. static int
  231. adb_probe_task(void *x)
  232. {
  233. strcpy(current->comm, "kadbprobe");
  235. spin_lock_irq(&current->sigmask_lock);
  236. sigfillset(&current->blocked);
  237. flush_signals(current);
  238. spin_unlock_irq(&current->sigmask_lock);
  240. printk(KERN_INFO "adb: starting probe task...n");
  241. do_adb_reset_bus();
  242. printk(KERN_INFO "adb: finished probe task...n");
  244. adb_probe_task_pid = 0;
  245. up(&adb_probe_mutex);
  247. return 0;
  248. }
  250. static void
  251. __adb_probe_task(void *data)
  252. {
  253. adb_probe_task_pid = kernel_thread(adb_probe_task, NULL,
  254. SIGCHLD | CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
  255. }
  257. int
  258. adb_reset_bus(void)
  259. {
  260. static struct tq_struct tqs = {
  261. routine: __adb_probe_task,
  262. };
  264. if (__adb_probe_sync) {
  265. do_adb_reset_bus();
  266. return 0;
  267. }
  269. down(&adb_probe_mutex);
  271. /* Create probe thread as a child of keventd */
  272. if (current_is_keventd())
  273. __adb_probe_task(NULL);
  274. else
  275. schedule_task(&tqs);
  276. return 0;
  277. }
  279. int __init adb_init(void)
  280. {
  281. struct adb_driver *driver;
  282. int i;
  284. #ifdef CONFIG_PPC
  285. if ( (_machine != _MACH_chrp) && (_machine != _MACH_Pmac) )
  286. return 0;
  287. #endif
  288. #ifdef CONFIG_MAC
  289. if (!MACH_IS_MAC)
  290. return 0;
  291. #endif
  293. /* xmon may do early-init */
  294. if (adb_inited)
  295. return 0;
  296. adb_inited = 1;
  298. adb_controller = NULL;
  300. i = 0;
  301. while ((driver = adb_driver_list[i++]) != NULL) {
  302. if (!driver->probe()) {
  303. adb_controller = driver;
  304. break;
  305. }
  306. }
  307. if ((adb_controller == NULL) || adb_controller->init()) {
  308. printk(KERN_WARNING "Warning: no ADB interface detectedn");
  309. adb_controller = NULL;
  310. } else {
  311. #ifdef CONFIG_PMAC_PBOOK
  312. pmu_register_sleep_notifier(&adb_sleep_notifier);
  313. #endif /* CONFIG_PMAC_PBOOK */
  314. #ifdef CONFIG_PPC
  315. if (machine_is_compatible("AAPL,PowerBook1998") ||
  316. machine_is_compatible("PowerBook1,1"))
  317. sleepy_trackpad = 1;
  318. #endif /* CONFIG_PPC */
  319. init_completion(&adb_probe_task_comp);
  320. adbdev_init();
  321. adb_reset_bus();
  322. }
  323. return 0;
  324. }
  326. __initcall(adb_init);
  328. #ifdef CONFIG_PMAC_PBOOK
  329. /*
  330.  * notify clients before sleep and reset bus afterwards
  331.  */
  332. int
  333. adb_notify_sleep(struct pmu_sleep_notifier *self, int when)
  334. {
  335. int ret;
  337. switch (when) {
  338. case PBOOK_SLEEP_REQUEST:
  339. adb_got_sleep = 1;
  340. /* We need to get a lock on the probe thread */
  341. down(&adb_probe_mutex);
  342. /* Stop autopoll */
  343. if (adb_controller->autopoll)
  344. adb_controller->autopoll(0);
  345. ret = notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
  346. if (ret & NOTIFY_STOP_MASK) {
  347. up(&adb_probe_mutex);
  348. return PBOOK_SLEEP_REFUSE;
  349. }
  350. break;
  351. case PBOOK_SLEEP_REJECT:
  352. if (adb_got_sleep) {
  353. adb_got_sleep = 0;
  354. up(&adb_probe_mutex);
  355. adb_reset_bus();
  356. }
  357. break;
  359. case PBOOK_SLEEP_NOW:
  360. break;
  361. case PBOOK_WAKE:
  362. adb_got_sleep = 0;
  363. up(&adb_probe_mutex);
  364. adb_reset_bus();
  365. break;
  366. }
  367. return PBOOK_SLEEP_OK;
  368. }
  369. #endif /* CONFIG_PMAC_PBOOK */
  371. static int
  372. do_adb_reset_bus(void)
  373. {
  374. int ret, nret, devs;
  375. unsigned long flags;
  377. if (adb_controller == NULL)
  378. return -ENXIO;
  380. if (adb_controller->autopoll)
  381. adb_controller->autopoll(0);
  383. nret = notifier_call_chain(&adb_client_list, ADB_MSG_PRE_RESET, NULL);
  384. if (nret & NOTIFY_STOP_MASK) {
  385. if (adb_controller->autopoll)
  386. adb_controller->autopoll(devs);
  387. return -EBUSY;
  388. }
  390. if (sleepy_trackpad) {
  391. /* Let the trackpad settle down */
  392. adb_wait_ms(500);
  393. }
  395. save_flags(flags);
  396. cli();
  397. memset(adb_handler, 0, sizeof(adb_handler));
  398. restore_flags(flags);
  400. /* That one is still a bit synchronous, oh well... */
  401. if (adb_controller->reset_bus)
  402. ret = adb_controller->reset_bus();
  403. else
  404. ret = 0;
  406. if (sleepy_trackpad) {
  407. /* Let the trackpad settle down */
  408. adb_wait_ms(1500);
  409. }
  411. if (!ret) {
  412. devs = adb_scan_bus();
  413. if (adb_controller->autopoll)
  414. adb_controller->autopoll(devs);
  415. }
  417. nret = notifier_call_chain(&adb_client_list, ADB_MSG_POST_RESET, NULL);
  418. if (nret & NOTIFY_STOP_MASK)
  419. return -EBUSY;
  421. return ret;
  422. }
  424. void
  425. adb_poll(void)
  426. {
  427. if ((adb_controller == NULL)||(adb_controller->poll == NULL))
  428. return;
  429. adb_controller->poll();
  430. }
  432. static void
  433. adb_probe_wakeup(struct adb_request *req)
  434. {
  435. complete(&adb_probe_task_comp);
  436. }
  438. static struct adb_request adb_sreq;
  439. static int adb_sreq_lock; // Use semaphore ! */ 
  441. int
  442. adb_request(struct adb_request *req, void (*done)(struct adb_request *),
  443.     int flags, int nbytes, ...)
  444. {
  445. va_list list;
  446. int i, use_sreq;
  447. int rc;
  449. if ((adb_controller == NULL) || (adb_controller->send_request == NULL))
  450. return -ENXIO;
  451. if (nbytes < 1)
  452. return -EINVAL;
  453. if (req == NULL && (flags & ADBREQ_NOSEND))
  454. return -EINVAL;
  456. if (req == NULL) {
  457. if (test_and_set_bit(0,&adb_sreq_lock)) {
  458. printk("adb.c: Warning: contention on static request !n");
  459. return -EPERM;
  460. }
  461. req = &adb_sreq;
  462. flags |= ADBREQ_SYNC;
  463. use_sreq = 1;
  464. } else
  465. use_sreq = 0;
  466. req->nbytes = nbytes+1;
  467. req->done = done;
  468. req->reply_expected = flags & ADBREQ_REPLY;
  469. req->data[0] = ADB_PACKET;
  470. va_start(list, nbytes);
  471. for (i = 0; i < nbytes; ++i)
  472. req->data[i+1] = va_arg(list, int);
  473. va_end(list);
  475. if (flags & ADBREQ_NOSEND)
  476. return 0;
  478. /* Synchronous requests send from the probe thread cause it to
  479.  * block. Beware that the "done" callback will be overriden !
  480.  */
  481. if ((flags & ADBREQ_SYNC) &&
  482.     (current->pid && adb_probe_task_pid &&
  483.     adb_probe_task_pid == current->pid)) {
  484. req->done = adb_probe_wakeup;
  485. rc = adb_controller->send_request(req, 0);
  486. if (rc || req->complete)
  487. goto bail;
  488. wait_for_completion(&adb_probe_task_comp);
  489. rc = 0;
  490. goto bail;
  491. }
  493. rc = adb_controller->send_request(req, flags & ADBREQ_SYNC);
  494. bail:
  495. if (use_sreq)
  496. clear_bit(0, &adb_sreq_lock);
  498. return rc;
  499. }
  501.  /* Ultimately this should return the number of devices with
  502.     the given default id.
  503.     And it does it now ! Note: changed behaviour: This function
  504.     will now register if default_id _and_ handler_id both match
  505.     but handler_id can be left to 0 to match with default_id only.
  506.     When handler_id is set, this function will try to adjust
  507.     the handler_id id it doesn't match. */
  508. int
  509. adb_register(int default_id, int handler_id, struct adb_ids *ids,
  510.      void (*handler)(unsigned char *, int, struct pt_regs *, int))
  511. {
  512. int i;
  514. ids->nids = 0;
  515. for (i = 1; i < 16; i++) {
  516. if ((adb_handler[i].original_address == default_id) &&
  517.     (!handler_id || (handler_id == adb_handler[i].handler_id) || 
  518.     adb_try_handler_change(i, handler_id))) {
  519. if (adb_handler[i].handler != 0) {
  520. printk(KERN_ERR
  521.        "Two handlers for ADB device %dn",
  522.        default_id);
  523. continue;
  524. }
  525. adb_handler[i].handler = handler;
  526. ids->id[ids->nids++] = i;
  527. }
  528. }
  529. return ids->nids;
  530. }
  532. int
  533. adb_unregister(int index)
  534. {
  535. if (!adb_handler[index].handler)
  536. return -ENODEV;
  537. adb_handler[index].handler = 0;
  538. return 0;
  539. }
  541. void
  542. adb_input(unsigned char *buf, int nb, struct pt_regs *regs, int autopoll)
  543. {
  544. int i, id;
  545. static int dump_adb_input = 0;
  547. /* We skip keystrokes and mouse moves when the sleep process
  548.  * has been started. We stop autopoll, but this is another security
  549.  */
  550. if (adb_got_sleep)
  551. return;
  553. id = buf[0] >> 4;
  554. if (dump_adb_input) {
  555. printk(KERN_INFO "adb packet: ");
  556. for (i = 0; i < nb; ++i)
  557. printk(" %x", buf[i]);
  558. printk(", id = %dn", id);
  559. }
  560. if (adb_handler[id].handler != 0) {
  561. (*adb_handler[id].handler)(buf, nb, regs, autopoll);
  562. }
  563. }
  565. /* Try to change handler to new_id. Will return 1 if successful */
  566. int
  567. adb_try_handler_change(int address, int new_id)
  568. {
  569. struct adb_request req;
  571. if (adb_handler[address].handler_id == new_id)
  572.     return 1;
  573. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  574.     ADB_WRITEREG(address, 3), address | 0x20, new_id);
  575. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  576.     ADB_READREG(address, 3));
  577. if (req.reply_len < 2)
  578.     return 0;
  579. if (req.reply[2] != new_id)
  580.     return 0;
  581. adb_handler[address].handler_id = req.reply[2];
  583. return 1;
  584. }
  586. int
  587. adb_get_infos(int address, int *original_address, int *handler_id)
  588. {
  589. *original_address = adb_handler[address].original_address;
  590. *handler_id = adb_handler[address].handler_id;
  592. return (*original_address != 0);
  593. }
  596. /*
  597.  * /dev/adb device driver.
  598.  */
  600. #define ADB_MAJOR 56 /* major number for /dev/adb */
  602. struct adbdev_state {
  603. spinlock_t lock;
  604. atomic_t n_pending;
  605. struct adb_request *completed;
  606.    wait_queue_head_t wait_queue;
  607. int inuse;
  608. };
  610. static void adb_write_done(struct adb_request *req)
  611. {
  612. struct adbdev_state *state = (struct adbdev_state *) req->arg;
  613. unsigned long flags;
  615. if (!req->complete) {
  616. req->reply_len = 0;
  617. req->complete = 1;
  618. }
  619. spin_lock_irqsave(&state->lock, flags);
  620. atomic_dec(&state->n_pending);
  621. if (!state->inuse) {
  622. kfree(req);
  623. if (atomic_read(&state->n_pending) == 0) {
  624. spin_unlock_irqrestore(&state->lock, flags);
  625. kfree(state);
  626. return;
  627. }
  628. } else {
  629. struct adb_request **ap = &state->completed;
  630. while (*ap != NULL)
  631. ap = &(*ap)->next;
  632. req->next = NULL;
  633. *ap = req;
  634. wake_up_interruptible(&state->wait_queue);
  635. }
  636. spin_unlock_irqrestore(&state->lock, flags);
  637. }
  639. static int adb_open(struct inode *inode, struct file *file)
  640. {
  641. struct adbdev_state *state;
  643. if (MINOR(inode->i_rdev) > 0 || adb_controller == NULL)
  644. return -ENXIO;
  645. state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL);
  646. if (state == 0)
  647. return -ENOMEM;
  648. file->private_data = state;
  649. spin_lock_init(&state->lock);
  650. atomic_set(&state->n_pending, 0);
  651. state->completed = NULL;
  652. init_waitqueue_head(&state->wait_queue);
  653. state->inuse = 1;
  655. return 0;
  656. }
  658. static int adb_release(struct inode *inode, struct file *file)
  659. {
  660. struct adbdev_state *state = file->private_data;
  661. unsigned long flags;
  663. lock_kernel();
  664. if (state) {
  665. file->private_data = NULL;
  666. spin_lock_irqsave(&state->lock, flags);
  667. if (atomic_read(&state->n_pending) == 0
  668.     && state->completed == NULL) {
  669. spin_unlock_irqrestore(&state->lock, flags);
  670. kfree(state);
  671. } else {
  672. state->inuse = 0;
  673. spin_unlock_irqrestore(&state->lock, flags);
  674. }
  675. }
  676. unlock_kernel();
  677. return 0;
  678. }
  680. static ssize_t adb_read(struct file *file, char *buf,
  681. size_t count, loff_t *ppos)
  682. {
  683. int ret;
  684. struct adbdev_state *state = file->private_data;
  685. struct adb_request *req;
  686. wait_queue_t wait = __WAITQUEUE_INITIALIZER(wait,current);
  687. unsigned long flags;
  689. if (count < 2)
  690. return -EINVAL;
  691. if (count > sizeof(req->reply))
  692. count = sizeof(req->reply);
  693. ret = verify_area(VERIFY_WRITE, buf, count);
  694. if (ret)
  695. return ret;
  697. req = NULL;
  698. spin_lock_irqsave(&state->lock, flags);
  699. add_wait_queue(&state->wait_queue, &wait);
  700. current->state = TASK_INTERRUPTIBLE;
  702. for (;;) {
  703. req = state->completed;
  704. if (req != NULL)
  705. state->completed = req->next;
  706. else if (atomic_read(&state->n_pending) == 0)
  707. ret = -EIO;
  708. if (req != NULL || ret != 0)
  709. break;
  711. if (file->f_flags & O_NONBLOCK) {
  712. ret = -EAGAIN;
  713. break;
  714. }
  715. if (signal_pending(current)) {
  716. ret = -ERESTARTSYS;
  717. break;
  718. }
  719. spin_unlock_irqrestore(&state->lock, flags);
  720. schedule();
  721. spin_lock_irqsave(&state->lock, flags);
  722. }
  724. current->state = TASK_RUNNING;
  725. remove_wait_queue(&state->wait_queue, &wait);
  726. spin_unlock_irqrestore(&state->lock, flags);
  728. if (ret)
  729. return ret;
  731. ret = req->reply_len;
  732. if (ret > count)
  733. ret = count;
  734. if (ret > 0 && copy_to_user(buf, req->reply, ret))
  735. ret = -EFAULT;
  737. kfree(req);
  738. return ret;
  739. }
  741. static ssize_t adb_write(struct file *file, const char *buf,
  742.  size_t count, loff_t *ppos)
  743. {
  744. int ret/*, i*/;
  745. struct adbdev_state *state = file->private_data;
  746. struct adb_request *req;
  748. if (count < 2 || count > sizeof(req->data))
  749. return -EINVAL;
  750. if (adb_controller == NULL)
  751. return -ENXIO;
  752. ret = verify_area(VERIFY_READ, buf, count);
  753. if (ret)
  754. return ret;
  756. req = (struct adb_request *) kmalloc(sizeof(struct adb_request),
  757.      GFP_KERNEL);
  758. if (req == NULL)
  759. return -ENOMEM;
  761. req->nbytes = count;
  762. req->done = adb_write_done;
  763. req->arg = (void *) state;
  764. req->complete = 0;
  766. ret = -EFAULT;
  767. if (copy_from_user(req->data, buf, count))
  768. goto out;
  770. atomic_inc(&state->n_pending);
  772. /* If a probe is in progress or we are sleeping, wait for it to complete */
  773. down(&adb_probe_mutex);
  775. /* Special case for ADB_BUSRESET request, all others are sent to
  776.    the controller */
  777. if ((req->data[0] == ADB_PACKET)&&(count > 1)
  778. &&(req->data[1] == ADB_BUSRESET)) {
  779. ret = do_adb_reset_bus();
  780. up(&adb_probe_mutex);
  781. atomic_dec(&state->n_pending);
  782. if (ret == 0)
  783. ret = count;
  784. goto out;
  785. } else {
  786. req->reply_expected = ((req->data[1] & 0xc) == 0xc);
  787. if (adb_controller && adb_controller->send_request)
  788. ret = adb_controller->send_request(req, 0);
  789. else
  790. ret = -ENXIO;
  791. up(&adb_probe_mutex);
  792. }
  794. if (ret != 0) {
  795. atomic_dec(&state->n_pending);
  796. goto out;
  797. }
  798. return count;
  800. out:
  801. kfree(req);
  802. return ret;
  803. }
  805. static struct file_operations adb_fops = {
  806. llseek: no_llseek,
  807. read: adb_read,
  808. write: adb_write,
  809. open: adb_open,
  810. release: adb_release,
  811. };
  813. static void
  814. adbdev_init(void)
  815. {
  816. if (devfs_register_chrdev(ADB_MAJOR, "adb", &adb_fops))
  817. printk(KERN_ERR "adb: unable to get major %dn", ADB_MAJOR);
  818. else
  819. devfs_register (NULL, "adb", DEVFS_FL_DEFAULT,
  820. ADB_MAJOR, 0,
  821. S_IFCHR | S_IRUSR | S_IWUSR,
  822. &adb_fops, NULL);
  823. }