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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
adb.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

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. #ifdef CONFIG_ADB_PMU
  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 int adb_probe_task_flag;
  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. clear_bit(0, &adb_probe_task_flag);
  246. return 0;
  247. }
  249. static void
  250. __adb_probe_task(void *data)
  251. {
  252. adb_probe_task_pid = kernel_thread(adb_probe_task, NULL,
  253. SIGCHLD | CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
  254. }
  256. int
  257. adb_reset_bus(void)
  258. {
  259. static struct tq_struct tqs = {
  260. routine: __adb_probe_task,
  261. };
  263. if (__adb_probe_sync) {
  264. do_adb_reset_bus();
  265. return 0;
  266. }
  268. /* We need to get a lock on the probe thread */
  269. while (test_and_set_bit(0, &adb_probe_task_flag))
  270. schedule();
  272. /* Just wait for PID to be 0 just in case (possible race) */
  273. while (adb_probe_task_pid != 0)
  274. schedule();
  276. /* Create probe thread as a child of keventd */
  277. if (current_is_keventd())
  278. __adb_probe_task(NULL);
  279. else
  280. schedule_task(&tqs);
  281. return 0;
  282. }
  284. int __init adb_init(void)
  285. {
  286. struct adb_driver *driver;
  287. int i;
  289. #ifdef CONFIG_PPC
  290. if ( (_machine != _MACH_chrp) && (_machine != _MACH_Pmac) )
  291. return 0;
  292. #endif
  293. #ifdef CONFIG_MAC
  294. if (!MACH_IS_MAC)
  295. return 0;
  296. #endif
  298. /* xmon may do early-init */
  299. if (adb_inited)
  300. return 0;
  301. adb_inited = 1;
  303. adb_controller = NULL;
  305. i = 0;
  306. while ((driver = adb_driver_list[i++]) != NULL) {
  307. if (!driver->probe()) {
  308. adb_controller = driver;
  309. break;
  310. }
  311. }
  312. if ((adb_controller == NULL) || adb_controller->init()) {
  313. printk(KERN_WARNING "Warning: no ADB interface detectedn");
  314. adb_controller = NULL;
  315. } else {
  316. #ifdef CONFIG_PMAC_PBOOK
  317. pmu_register_sleep_notifier(&adb_sleep_notifier);
  318. #endif /* CONFIG_PMAC_PBOOK */
  319. if (machine_is_compatible("AAPL,PowerBook1998") ||
  320. machine_is_compatible("PowerBook1,1"))
  321. sleepy_trackpad = 1;
  322. init_completion(&adb_probe_task_comp);
  323. adbdev_init();
  324. adb_reset_bus();
  325. }
  326. return 0;
  327. }
  329. __initcall(adb_init);
  331. #ifdef CONFIG_PMAC_PBOOK
  332. /*
  333.  * notify clients before sleep and reset bus afterwards
  334.  */
  335. int
  336. adb_notify_sleep(struct pmu_sleep_notifier *self, int when)
  337. {
  338. int ret;
  340. switch (when) {
  341. case PBOOK_SLEEP_REQUEST:
  342. adb_got_sleep = 1;
  343. /* We need to get a lock on the probe thread */
  344. while (test_and_set_bit(0, &adb_probe_task_flag))
  345. schedule();
  346. /* Just wait for PID to be 0 just in case (possible race) */
  347. while (adb_probe_task_pid != 0)
  348. schedule();
  349. if (adb_controller->autopoll)
  350. adb_controller->autopoll(0);
  351. ret = notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
  352. if (ret & NOTIFY_STOP_MASK)
  353. return PBOOK_SLEEP_REFUSE;
  354. break;
  355. case PBOOK_SLEEP_REJECT:
  356. if (adb_got_sleep) {
  357. adb_got_sleep = 0;
  358. clear_bit(0, &adb_probe_task_flag);
  359. adb_reset_bus();
  360. }
  361. break;
  363. case PBOOK_SLEEP_NOW:
  364. break;
  365. case PBOOK_WAKE:
  366. adb_got_sleep = 0;
  367. clear_bit(0, &adb_probe_task_flag);
  368. adb_reset_bus();
  369. break;
  370. }
  371. return PBOOK_SLEEP_OK;
  372. }
  373. #endif /* CONFIG_PMAC_PBOOK */
  375. static int
  376. do_adb_reset_bus(void)
  377. {
  378. int ret, nret, devs;
  379. unsigned long flags;
  381. if (adb_controller == NULL)
  382. return -ENXIO;
  384. if (adb_controller->autopoll)
  385. adb_controller->autopoll(0);
  387. nret = notifier_call_chain(&adb_client_list, ADB_MSG_PRE_RESET, NULL);
  388. if (nret & NOTIFY_STOP_MASK) {
  389. if (adb_controller->autopoll)
  390. adb_controller->autopoll(devs);
  391. return -EBUSY;
  392. }
  394. if (sleepy_trackpad) {
  395. /* Let the trackpad settle down */
  396. adb_wait_ms(500);
  397. }
  399. save_flags(flags);
  400. cli();
  401. memset(adb_handler, 0, sizeof(adb_handler));
  402. restore_flags(flags);
  404. /* That one is still a bit synchronous, oh well... */
  405. if (adb_controller->reset_bus)
  406. ret = adb_controller->reset_bus();
  407. else
  408. ret = 0;
  410. if (sleepy_trackpad) {
  411. /* Let the trackpad settle down */
  412. adb_wait_ms(1500);
  413. }
  415. if (!ret) {
  416. devs = adb_scan_bus();
  417. if (adb_controller->autopoll)
  418. adb_controller->autopoll(devs);
  419. }
  421. nret = notifier_call_chain(&adb_client_list, ADB_MSG_POST_RESET, NULL);
  422. if (nret & NOTIFY_STOP_MASK)
  423. return -EBUSY;
  425. return ret;
  426. }
  428. void
  429. adb_poll(void)
  430. {
  431. if ((adb_controller == NULL)||(adb_controller->poll == NULL))
  432. return;
  433. adb_controller->poll();
  434. }
  436. static void
  437. adb_probe_wakeup(struct adb_request *req)
  438. {
  439. complete(&adb_probe_task_comp);
  440. }
  442. static struct adb_request adb_sreq;
  443. static int adb_sreq_lock; // Use semaphore ! */ 
  445. int
  446. adb_request(struct adb_request *req, void (*done)(struct adb_request *),
  447.     int flags, int nbytes, ...)
  448. {
  449. va_list list;
  450. int i, use_sreq;
  451. int rc;
  453. if ((adb_controller == NULL) || (adb_controller->send_request == NULL))
  454. return -ENXIO;
  455. if (nbytes < 1)
  456. return -EINVAL;
  457. if (req == NULL && (flags & ADBREQ_NOSEND))
  458. return -EINVAL;
  460. if (req == NULL) {
  461. if (test_and_set_bit(0,&adb_sreq_lock)) {
  462. printk("adb.c: Warning: contention on static request !n");
  463. return -EPERM;
  464. }
  465. req = &adb_sreq;
  466. flags |= ADBREQ_SYNC;
  467. use_sreq = 1;
  468. } else
  469. use_sreq = 0;
  470. req->nbytes = nbytes+1;
  471. req->done = done;
  472. req->reply_expected = flags & ADBREQ_REPLY;
  473. req->data[0] = ADB_PACKET;
  474. va_start(list, nbytes);
  475. for (i = 0; i < nbytes; ++i)
  476. req->data[i+1] = va_arg(list, int);
  477. va_end(list);
  479. if (flags & ADBREQ_NOSEND)
  480. return 0;
  482. /* Synchronous requests send from the probe thread cause it to
  483.  * block. Beware that the "done" callback will be overriden !
  484.  */
  485. if ((flags & ADBREQ_SYNC) &&
  486.     (current->pid && adb_probe_task_pid &&
  487.     adb_probe_task_pid == current->pid)) {
  488. req->done = adb_probe_wakeup;
  489. rc = adb_controller->send_request(req, 0);
  490. if (rc || req->complete)
  491. goto bail;
  492. wait_for_completion(&adb_probe_task_comp);
  493. rc = 0;
  494. goto bail;
  495. }
  497. rc = adb_controller->send_request(req, flags & ADBREQ_SYNC);
  498. bail:
  499. if (use_sreq)
  500. clear_bit(0, &adb_sreq_lock);
  502. return rc;
  503. }
  505.  /* Ultimately this should return the number of devices with
  506.     the given default id.
  507.     And it does it now ! Note: changed behaviour: This function
  508.     will now register if default_id _and_ handler_id both match
  509.     but handler_id can be left to 0 to match with default_id only.
  510.     When handler_id is set, this function will try to adjust
  511.     the handler_id id it doesn't match. */
  512. int
  513. adb_register(int default_id, int handler_id, struct adb_ids *ids,
  514.      void (*handler)(unsigned char *, int, struct pt_regs *, int))
  515. {
  516. int i;
  518. ids->nids = 0;
  519. for (i = 1; i < 16; i++) {
  520. if ((adb_handler[i].original_address == default_id) &&
  521.     (!handler_id || (handler_id == adb_handler[i].handler_id) || 
  522.     adb_try_handler_change(i, handler_id))) {
  523. if (adb_handler[i].handler != 0) {
  524. printk(KERN_ERR
  525.        "Two handlers for ADB device %dn",
  526.        default_id);
  527. continue;
  528. }
  529. adb_handler[i].handler = handler;
  530. ids->id[ids->nids++] = i;
  531. }
  532. }
  533. return ids->nids;
  534. }
  536. int
  537. adb_unregister(int index)
  538. {
  539. if (!adb_handler[index].handler)
  540. return -ENODEV;
  541. adb_handler[index].handler = 0;
  542. return 0;
  543. }
  545. void
  546. adb_input(unsigned char *buf, int nb, struct pt_regs *regs, int autopoll)
  547. {
  548. int i, id;
  549. static int dump_adb_input = 0;
  551. /* We skip keystrokes and mouse moves when the sleep process
  552.  * has been started. We stop autopoll, but this is another security
  553.  */
  554. if (adb_got_sleep)
  555. return;
  557. id = buf[0] >> 4;
  558. if (dump_adb_input) {
  559. printk(KERN_INFO "adb packet: ");
  560. for (i = 0; i < nb; ++i)
  561. printk(" %x", buf[i]);
  562. printk(", id = %dn", id);
  563. }
  564. if (adb_handler[id].handler != 0) {
  565. (*adb_handler[id].handler)(buf, nb, regs, autopoll);
  566. }
  567. }
  569. /* Try to change handler to new_id. Will return 1 if successful */
  570. int
  571. adb_try_handler_change(int address, int new_id)
  572. {
  573. struct adb_request req;
  575. if (adb_handler[address].handler_id == new_id)
  576.     return 1;
  577. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  578.     ADB_WRITEREG(address, 3), address | 0x20, new_id);
  579. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  580.     ADB_READREG(address, 3));
  581. if (req.reply_len < 2)
  582.     return 0;
  583. if (req.reply[2] != new_id)
  584.     return 0;
  585. adb_handler[address].handler_id = req.reply[2];
  587. return 1;
  588. }
  590. int
  591. adb_get_infos(int address, int *original_address, int *handler_id)
  592. {
  593. *original_address = adb_handler[address].original_address;
  594. *handler_id = adb_handler[address].handler_id;
  596. return (*original_address != 0);
  597. }
  600. /*
  601.  * /dev/adb device driver.
  602.  */
  604. #define ADB_MAJOR 56 /* major number for /dev/adb */
  606. struct adbdev_state {
  607. spinlock_t lock;
  608. atomic_t n_pending;
  609. struct adb_request *completed;
  610.    wait_queue_head_t wait_queue;
  611. int inuse;
  612. };
  614. static void adb_write_done(struct adb_request *req)
  615. {
  616. struct adbdev_state *state = (struct adbdev_state *) req->arg;
  617. unsigned long flags;
  619. if (!req->complete) {
  620. req->reply_len = 0;
  621. req->complete = 1;
  622. }
  623. spin_lock_irqsave(&state->lock, flags);
  624. atomic_dec(&state->n_pending);
  625. if (!state->inuse) {
  626. kfree(req);
  627. if (atomic_read(&state->n_pending) == 0) {
  628. spin_unlock_irqrestore(&state->lock, flags);
  629. kfree(state);
  630. return;
  631. }
  632. } else {
  633. struct adb_request **ap = &state->completed;
  634. while (*ap != NULL)
  635. ap = &(*ap)->next;
  636. req->next = NULL;
  637. *ap = req;
  638. wake_up_interruptible(&state->wait_queue);
  639. }
  640. spin_unlock_irqrestore(&state->lock, flags);
  641. }
  643. static int adb_open(struct inode *inode, struct file *file)
  644. {
  645. struct adbdev_state *state;
  647. if (MINOR(inode->i_rdev) > 0 || adb_controller == NULL)
  648. return -ENXIO;
  649. state = kmalloc(sizeof(struct adbdev_state), GFP_KERNEL);
  650. if (state == 0)
  651. return -ENOMEM;
  652. file->private_data = state;
  653. spin_lock_init(&state->lock);
  654. atomic_set(&state->n_pending, 0);
  655. state->completed = NULL;
  656. init_waitqueue_head(&state->wait_queue);
  657. state->inuse = 1;
  659. return 0;
  660. }
  662. static int adb_release(struct inode *inode, struct file *file)
  663. {
  664. struct adbdev_state *state = file->private_data;
  665. unsigned long flags;
  667. lock_kernel();
  668. if (state) {
  669. file->private_data = NULL;
  670. spin_lock_irqsave(&state->lock, flags);
  671. if (atomic_read(&state->n_pending) == 0
  672.     && state->completed == NULL) {
  673. spin_unlock_irqrestore(&state->lock, flags);
  674. kfree(state);
  675. } else {
  676. state->inuse = 0;
  677. spin_unlock_irqrestore(&state->lock, flags);
  678. }
  679. }
  680. unlock_kernel();
  681. return 0;
  682. }
  684. static ssize_t adb_read(struct file *file, char *buf,
  685. size_t count, loff_t *ppos)
  686. {
  687. int ret;
  688. struct adbdev_state *state = file->private_data;
  689. struct adb_request *req;
  690. wait_queue_t wait = __WAITQUEUE_INITIALIZER(wait,current);
  691. unsigned long flags;
  693. if (count < 2)
  694. return -EINVAL;
  695. if (count > sizeof(req->reply))
  696. count = sizeof(req->reply);
  697. ret = verify_area(VERIFY_WRITE, buf, count);
  698. if (ret)
  699. return ret;
  701. req = NULL;
  702. spin_lock_irqsave(&state->lock, flags);
  703. add_wait_queue(&state->wait_queue, &wait);
  704. current->state = TASK_INTERRUPTIBLE;
  706. for (;;) {
  707. req = state->completed;
  708. if (req != NULL)
  709. state->completed = req->next;
  710. else if (atomic_read(&state->n_pending) == 0)
  711. ret = -EIO;
  712. if (req != NULL || ret != 0)
  713. break;
  715. if (file->f_flags & O_NONBLOCK) {
  716. ret = -EAGAIN;
  717. break;
  718. }
  719. if (signal_pending(current)) {
  720. ret = -ERESTARTSYS;
  721. break;
  722. }
  723. spin_unlock_irqrestore(&state->lock, flags);
  724. schedule();
  725. spin_lock_irqsave(&state->lock, flags);
  726. }
  728. current->state = TASK_RUNNING;
  729. remove_wait_queue(&state->wait_queue, &wait);
  730. spin_unlock_irqrestore(&state->lock, flags);
  732. if (ret)
  733. return ret;
  735. ret = req->reply_len;
  736. if (ret > count)
  737. ret = count;
  738. if (ret > 0 && copy_to_user(buf, req->reply, ret))
  739. ret = -EFAULT;
  741. kfree(req);
  742. return ret;
  743. }
  745. static ssize_t adb_write(struct file *file, const char *buf,
  746.  size_t count, loff_t *ppos)
  747. {
  748. int ret/*, i*/;
  749. struct adbdev_state *state = file->private_data;
  750. struct adb_request *req;
  752. if (count < 2 || count > sizeof(req->data))
  753. return -EINVAL;
  754. if (adb_controller == NULL)
  755. return -ENXIO;
  756. ret = verify_area(VERIFY_READ, buf, count);
  757. if (ret)
  758. return ret;
  760. req = (struct adb_request *) kmalloc(sizeof(struct adb_request),
  761.      GFP_KERNEL);
  762. if (req == NULL)
  763. return -ENOMEM;
  765. req->nbytes = count;
  766. req->done = adb_write_done;
  767. req->arg = (void *) state;
  768. req->complete = 0;
  770. ret = -EFAULT;
  771. if (copy_from_user(req->data, buf, count))
  772. goto out;
  774. atomic_inc(&state->n_pending);
  776. /* If a probe is in progress, wait for it to complete */
  777. while (adb_probe_task_pid != 0 || test_bit(0, &adb_probe_task_flag))
  778. schedule();
  780. /* Special case for ADB_BUSRESET request, all others are sent to
  781.    the controller */
  782. if ((req->data[0] == ADB_PACKET)&&(count > 1)
  783. &&(req->data[1] == ADB_BUSRESET)) {
  784. ret = do_adb_reset_bus();
  785. atomic_dec(&state->n_pending);
  786. if (ret == 0)
  787. ret = count;
  788. goto out;
  789. } else {
  790. req->reply_expected = ((req->data[1] & 0xc) == 0xc);
  792. if (adb_controller && adb_controller->send_request)
  793. ret = adb_controller->send_request(req, 0);
  794. else
  795. ret = -ENXIO;
  796. }
  798. if (ret != 0) {
  799. atomic_dec(&state->n_pending);
  800. goto out;
  801. }
  802. return count;
  804. out:
  805. kfree(req);
  806. return ret;
  807. }
  809. static struct file_operations adb_fops = {
  810. llseek: no_llseek,
  811. read: adb_read,
  812. write: adb_write,
  813. open: adb_open,
  814. release: adb_release,
  815. };
  817. static void
  818. adbdev_init(void)
  819. {
  820. if (devfs_register_chrdev(ADB_MAJOR, "adb", &adb_fops))
  821. printk(KERN_ERR "adb: unable to get major %dn", ADB_MAJOR);
  822. else
  823. devfs_register (NULL, "adb", DEVFS_FL_DEFAULT,
  824. ADB_MAJOR, 0,
  825. S_IFCHR | S_IRUSR | S_IWUSR,
  826. &adb_fops, NULL);
  827. }