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

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

Linux/Unix编程

开发平台：

Unix_Linux

via-cuda.c：源码内容
  1. /*
  2.  * Device driver for the via-cuda on Apple Powermacs.
  3.  *
  4.  * The VIA (versatile interface adapter) interfaces to the CUDA,
  5.  * a 6805 microprocessor core which controls the ADB (Apple Desktop
  6.  * Bus) which connects to the keyboard and mouse.  The CUDA also
  7.  * controls system power and the RTC (real time clock) chip.
  8.  *
  9.  * Copyright (C) 1996 Paul Mackerras.
  10.  */
  11. #include <stdarg.h>
  12. #include <linux/config.h>
  13. #include <linux/types.h>
  14. #include <linux/errno.h>
  15. #include <linux/kernel.h>
  16. #include <linux/delay.h>
  17. #include <linux/sched.h>
  18. #include <linux/adb.h>
  19. #include <linux/cuda.h>
  20. #include <linux/spinlock.h>
  21. #ifdef CONFIG_PPC
  22. #include <asm/prom.h>
  23. #include <asm/machdep.h>
  24. #else
  25. #include <asm/macintosh.h>
  26. #include <asm/macints.h>
  27. #include <asm/machw.h>
  28. #include <asm/mac_via.h>
  29. #endif
  30. #include <asm/io.h>
  31. #include <asm/system.h>
  32. #include <linux/init.h>
  34. static volatile unsigned char *via;
  35. static spinlock_t cuda_lock = SPIN_LOCK_UNLOCKED;
  37. #ifdef CONFIG_MAC
  38. #define CUDA_IRQ IRQ_MAC_ADB
  39. #define __openfirmware
  40. #define eieio()
  41. #else
  42. #define CUDA_IRQ vias->intrs[0].line
  43. #endif
  45. /* VIA registers - spaced 0x200 bytes apart */
  46. #define RS 0x200 /* skip between registers */
  47. #define B 0 /* B-side data */
  48. #define A RS /* A-side data */
  49. #define DIRB (2*RS) /* B-side direction (1=output) */
  50. #define DIRA (3*RS) /* A-side direction (1=output) */
  51. #define T1CL (4*RS) /* Timer 1 ctr/latch (low 8 bits) */
  52. #define T1CH (5*RS) /* Timer 1 counter (high 8 bits) */
  53. #define T1LL (6*RS) /* Timer 1 latch (low 8 bits) */
  54. #define T1LH (7*RS) /* Timer 1 latch (high 8 bits) */
  55. #define T2CL (8*RS) /* Timer 2 ctr/latch (low 8 bits) */
  56. #define T2CH (9*RS) /* Timer 2 counter (high 8 bits) */
  57. #define SR (10*RS) /* Shift register */
  58. #define ACR (11*RS) /* Auxiliary control register */
  59. #define PCR (12*RS) /* Peripheral control register */
  60. #define IFR (13*RS) /* Interrupt flag register */
  61. #define IER (14*RS) /* Interrupt enable register */
  62. #define ANH (15*RS) /* A-side data, no handshake */
  64. /* Bits in B data register: all active low */
  65. #define TREQ 0x08 /* Transfer request (input) */
  66. #define TACK 0x10 /* Transfer acknowledge (output) */
  67. #define TIP 0x20 /* Transfer in progress (output) */
  69. /* Bits in ACR */
  70. #define SR_CTRL 0x1c /* Shift register control bits */
  71. #define SR_EXT 0x0c /* Shift on external clock */
  72. #define SR_OUT 0x10 /* Shift out if 1 */
  74. /* Bits in IFR and IER */
  75. #define IER_SET 0x80 /* set bits in IER */
  76. #define IER_CLR 0 /* clear bits in IER */
  77. #define SR_INT 0x04 /* Shift register full/empty */
  79. static enum cuda_state {
  80.     idle,
  81.     sent_first_byte,
  82.     sending,
  83.     reading,
  84.     read_done,
  85.     awaiting_reply
  86. } cuda_state;
  88. static struct adb_request *current_req;
  89. static struct adb_request *last_req;
  90. static unsigned char cuda_rbuf[16];
  91. static unsigned char *reply_ptr;
  92. static int reading_reply;
  93. static int data_index;
  94. #ifdef CONFIG_PPC
  95. static struct device_node *vias;
  96. #endif
  97. static int cuda_fully_inited = 0;
  99. #ifdef CONFIG_ADB
  100. static int cuda_probe(void);
  101. static int cuda_init(void);
  102. static int cuda_send_request(struct adb_request *req, int sync);
  103. static int cuda_adb_autopoll(int devs);
  104. static int cuda_reset_adb_bus(void);
  105. #endif /* CONFIG_ADB */
  107. static int cuda_init_via(void);
  108. static void cuda_start(void);
  109. static void cuda_interrupt(int irq, void *arg, struct pt_regs *regs);
  110. static void cuda_input(unsigned char *buf, int nb, struct pt_regs *regs);
  111. void cuda_poll(void);
  112. static int cuda_write(struct adb_request *req);
  114. int cuda_request(struct adb_request *req,
  115.  void (*done)(struct adb_request *), int nbytes, ...);
  117. #ifdef CONFIG_ADB
  118. struct adb_driver via_cuda_driver = {
  119. "CUDA",
  120. cuda_probe,
  121. cuda_init,
  122. cuda_send_request,
  123. cuda_adb_autopoll,
  124. cuda_poll,
  125. cuda_reset_adb_bus
  126. };
  127. #endif /* CONFIG_ADB */
  129. #ifdef CONFIG_PPC
  130. int __init
  131. find_via_cuda(void)
  132. {
  133.     int err;
  134.     struct adb_request req;
  136.     if (vias != 0)
  137. return 1;
  138.     vias = find_devices("via-cuda");
  139.     if (vias == 0)
  140. return 0;
  141.     if (vias->next != 0)
  142. printk(KERN_WARNING "Warning: only using 1st via-cudan");
  144. #if 0
  145.     { int i;
  147.     printk("find_via_cuda: node = %p, addrs =", vias->node);
  148.     for (i = 0; i < vias->n_addrs; ++i)
  149. printk(" %x(%x)", vias->addrs[i].address, vias->addrs[i].size);
  150.     printk(", intrs =");
  151.     for (i = 0; i < vias->n_intrs; ++i)
  152. printk(" %x", vias->intrs[i].line);
  153.     printk("n"); }
  154. #endif
  156.     if (vias->n_addrs != 1 || vias->n_intrs != 1) {
  157. printk(KERN_ERR "via-cuda: expecting 1 address (%d) and 1 interrupt (%d)n",
  158.        vias->n_addrs, vias->n_intrs);
  159. if (vias->n_addrs < 1 || vias->n_intrs < 1)
  160.     return 0;
  161.     }
  162.     via = (volatile unsigned char *) ioremap(vias->addrs->address, 0x2000);
  164.     cuda_state = idle;
  165.     sys_ctrler = SYS_CTRLER_CUDA;
  167.     err = cuda_init_via();
  168.     if (err) {
  169. printk(KERN_ERR "cuda_init_via() failedn");
  170. via = NULL;
  171. return 0;
  172.     }
  174.     /* Clear and enable interrupts, but only on PPC. On 68K it's done  */
  175.     /* for us by the main VIA driver in arch/m68k/mac/via.c        */
  177. #ifndef CONFIG_MAC
  178.     via[IFR] = 0x7f; eieio(); /* clear interrupts by writing 1s */
  179.     via[IER] = IER_SET|SR_INT; eieio(); /* enable interrupt from SR */
  180. #endif
  182.     /* enable autopoll */
  183.     cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, 1);
  184.     while (!req.complete)
  185. cuda_poll();
  187.     return 1;
  188. }
  189. #endif /* CONFIG_PPC */
  191. int __init
  192. via_cuda_start(void)
  193. {
  194.     if (via == NULL)
  195. return -ENODEV;
  197. #ifdef CONFIG_PPC
  198.     request_OF_resource(vias, 0, NULL);
  199. #endif
  201.     if (request_irq(CUDA_IRQ, cuda_interrupt, 0, "ADB", cuda_interrupt)) {
  202. printk(KERN_ERR "cuda_init: can't get irq %dn", CUDA_IRQ);
  203. return -EAGAIN;
  204.     }
  206.     printk("Macintosh CUDA driver v0.5 for Unified ADB.n");
  208.     cuda_fully_inited = 1;
  209.     return 0;
  210. }
  212. #ifdef CONFIG_ADB
  213. static int
  214. cuda_probe()
  215. {
  216. #ifdef CONFIG_PPC
  217.     if (sys_ctrler != SYS_CTRLER_CUDA)
  218. return -ENODEV;
  219. #else
  220.     if (macintosh_config->adb_type != MAC_ADB_CUDA)
  221. return -ENODEV;
  222.     via = via1;
  223. #endif
  224.     return 0;
  225. }
  227. static int __init
  228. cuda_init(void)
  229. {
  230. #ifdef CONFIG_PPC
  231.     if (via == NULL)
  232. return -ENODEV;
  233.     return 0;
  234. #else 
  235.     int err = cuda_init_via();
  236.     if (err) {
  237. printk(KERN_ERR "cuda_init_via() failedn");
  238. return -ENODEV;
  239.     }
  241.     return via_cuda_start();
  242. #endif
  243. }
  244. #endif /* CONFIG_ADB */
  246. #define WAIT_FOR(cond, what)
  247.     do {
  248. for (x = 1000; !(cond); --x) {
  249.     if (x == 0) {
  250. printk("Timeout waiting for " what "n");
  251. return -ENXIO;
  252.     }
  253.     udelay(100);
  254. }
  255.     } while (0)
  257. static int
  258. cuda_init_via()
  259. {
  260.     int x;
  262.     via[DIRB] = (via[DIRB] | TACK | TIP) & ~TREQ; /* TACK & TIP out */
  263.     via[B] |= TACK | TIP; /* negate them */
  264.     via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT; /* SR data in */
  265.     eieio();
  266.     x = via[SR]; eieio(); /* clear any left-over data */
  267. #ifndef CONFIG_MAC
  268.     via[IER] = 0x7f; eieio(); /* disable interrupts from VIA */
  269. #endif
  270.     eieio();
  272.     /* delay 4ms and then clear any pending interrupt */
  273.     mdelay(4);
  274.     x = via[SR]; eieio();
  276.     /* sync with the CUDA - assert TACK without TIP */
  277.     via[B] &= ~TACK; eieio();
  279.     /* wait for the CUDA to assert TREQ in response */
  280.     WAIT_FOR((via[B] & TREQ) == 0, "CUDA response to sync");
  282.     /* wait for the interrupt and then clear it */
  283.     WAIT_FOR(via[IFR] & SR_INT, "CUDA response to sync (2)");
  284.     x = via[SR]; eieio();
  286.     /* finish the sync by negating TACK */
  287.     via[B] |= TACK; eieio();
  289.     /* wait for the CUDA to negate TREQ and the corresponding interrupt */
  290.     WAIT_FOR(via[B] & TREQ, "CUDA response to sync (3)");
  291.     WAIT_FOR(via[IFR] & SR_INT, "CUDA response to sync (4)");
  292.     x = via[SR]; eieio();
  293.     via[B] |= TIP; eieio(); /* should be unnecessary */
  295.     return 0;
  296. }
  298. #ifdef CONFIG_ADB
  299. /* Send an ADB command */
  300. static int
  301. cuda_send_request(struct adb_request *req, int sync)
  302. {
  303.     int i;
  305.     if ((via == NULL) || !cuda_fully_inited) {
  306. req->complete = 1;
  307. return -ENXIO;
  308.     }
  309.   
  310.     req->reply_expected = 1;
  312.     i = cuda_write(req);
  313.     if (i)
  314. return i;
  316.     if (sync) {
  317. while (!req->complete)
  318.     cuda_poll();
  319.     }
  320.     return 0;
  321. }
  324. /* Enable/disable autopolling */
  325. static int
  326. cuda_adb_autopoll(int devs)
  327. {
  328.     struct adb_request req;
  330.     if ((via == NULL) || !cuda_fully_inited)
  331. return -ENXIO;
  333.     cuda_request(&req, NULL, 3, CUDA_PACKET, CUDA_AUTOPOLL, (devs? 1: 0));
  334.     while (!req.complete)
  335. cuda_poll();
  336.     return 0;
  337. }
  339. /* Reset adb bus - how do we do this?? */
  340. static int
  341. cuda_reset_adb_bus(void)
  342. {
  343.     struct adb_request req;
  345.     if ((via == NULL) || !cuda_fully_inited)
  346. return -ENXIO;
  348.     cuda_request(&req, NULL, 2, ADB_PACKET, 0); /* maybe? */
  349.     while (!req.complete)
  350. cuda_poll();
  351.     return 0;
  352. }
  353. #endif /* CONFIG_ADB */
  354. /* Construct and send a cuda request */
  355. int
  356. cuda_request(struct adb_request *req, void (*done)(struct adb_request *),
  357.      int nbytes, ...)
  358. {
  359.     va_list list;
  360.     int i;
  362.     if (via == NULL) {
  363. req->complete = 1;
  364. return -ENXIO;
  365.     }
  367.     req->nbytes = nbytes;
  368.     req->done = done;
  369.     va_start(list, nbytes);
  370.     for (i = 0; i < nbytes; ++i)
  371. req->data[i] = va_arg(list, int);
  372.     va_end(list);
  373.     req->reply_expected = 1;
  374.     return cuda_write(req);
  375. }
  377. static int
  378. cuda_write(struct adb_request *req)
  379. {
  380.     unsigned long flags;
  382.     if (req->nbytes < 2 || req->data[0] > CUDA_PACKET) {
  383. req->complete = 1;
  384. return -EINVAL;
  385.     }
  386.     req->next = 0;
  387.     req->sent = 0;
  388.     req->complete = 0;
  389.     req->reply_len = 0;
  391.     spin_lock_irqsave(&cuda_lock, flags);
  392.     if (current_req != 0) {
  393. last_req->next = req;
  394. last_req = req;
  395.     } else {
  396. current_req = req;
  397. last_req = req;
  398. if (cuda_state == idle)
  399.     cuda_start();
  400.     }
  401.     spin_unlock_irqrestore(&cuda_lock, flags);
  403.     return 0;
  404. }
  406. static void
  407. cuda_start()
  408. {
  409.     struct adb_request *req;
  411.     /* assert cuda_state == idle */
  412.     /* get the packet to send */
  413.     req = current_req;
  414.     if (req == 0)
  415. return;
  416.     if ((via[B] & TREQ) == 0)
  417. return; /* a byte is coming in from the CUDA */
  419.     /* set the shift register to shift out and send a byte */
  420.     via[ACR] |= SR_OUT; eieio();
  421.     via[SR] = req->data[0]; eieio();
  422.     via[B] &= ~TIP;
  423.     cuda_state = sent_first_byte;
  424. }
  426. void
  427. cuda_poll()
  428. {
  429.     if (via[IFR] & SR_INT) {
  430. unsigned long flags;
  432. /* cuda_interrupt only takes a normal lock, we disable
  433.  * interrupts here to avoid re-entering and thus deadlocking.
  434.  * An option would be to disable only the IRQ source with
  435.  * disable_irq(), would that work on m68k ? --BenH
  436.  */
  437. local_irq_save(flags);
  438. cuda_interrupt(0, 0, 0);
  439. local_irq_restore(flags);
  440.     }
  441. }
  443. static void
  444. cuda_interrupt(int irq, void *arg, struct pt_regs *regs)
  445. {
  446.     int x, status;
  447.     struct adb_request *req = NULL;
  448.     unsigned char ibuf[16];
  449.     int ibuf_len = 0;
  450.     int complete = 0;
  451.     
  452.     if ((via[IFR] & SR_INT) == 0)
  453. return;
  455.     spin_lock(&cuda_lock);
  456.     status = (~via[B] & (TIP|TREQ)) | (via[ACR] & SR_OUT); eieio();
  457.     /* printk("cuda_interrupt: state=%d status=%xn", cuda_state, status); */
  458.     switch (cuda_state) {
  459.     case idle:
  460. /* CUDA has sent us the first byte of data - unsolicited */
  461. if (status != TREQ)
  462.     printk("cuda: state=idle, status=%xn", status);
  463. x = via[SR]; eieio();
  464. via[B] &= ~TIP; eieio();
  465. cuda_state = reading;
  466. reply_ptr = cuda_rbuf;
  467. reading_reply = 0;
  468. break;
  470.     case awaiting_reply:
  471. /* CUDA has sent us the first byte of data of a reply */
  472. if (status != TREQ)
  473.     printk("cuda: state=awaiting_reply, status=%xn", status);
  474. x = via[SR]; eieio();
  475. via[B] &= ~TIP; eieio();
  476. cuda_state = reading;
  477. reply_ptr = current_req->reply;
  478. reading_reply = 1;
  479. break;
  481.     case sent_first_byte:
  482. if (status == TREQ + TIP + SR_OUT) {
  483.     /* collision */
  484.     via[ACR] &= ~SR_OUT; eieio();
  485.     x = via[SR]; eieio();
  486.     via[B] |= TIP | TACK; eieio();
  487.     cuda_state = idle;
  488. } else {
  489.     /* assert status == TIP + SR_OUT */
  490.     if (status != TIP + SR_OUT)
  491. printk("cuda: state=sent_first_byte status=%xn", status);
  492.     via[SR] = current_req->data[1]; eieio();
  493.     via[B] ^= TACK; eieio();
  494.     data_index = 2;
  495.     cuda_state = sending;
  496. }
  497. break;
  499.     case sending:
  500. req = current_req;
  501. if (data_index >= req->nbytes) {
  502.     via[ACR] &= ~SR_OUT; eieio();
  503.     x = via[SR]; eieio();
  504.     via[B] |= TACK | TIP; eieio();
  505.     req->sent = 1;
  506.     if (req->reply_expected) {
  507. cuda_state = awaiting_reply;
  508.     } else {
  509. current_req = req->next;
  510. complete = 1;
  511. /* not sure about this */
  512. cuda_state = idle;
  513. cuda_start();
  514.     }
  515. } else {
  516.     via[SR] = req->data[data_index++]; eieio();
  517.     via[B] ^= TACK; eieio();
  518. }
  519. break;
  521.     case reading:
  522. *reply_ptr++ = via[SR]; eieio();
  523. if (status == TIP) {
  524.     /* that's all folks */
  525.     via[B] |= TACK | TIP; eieio();
  526.     cuda_state = read_done;
  527. } else {
  528.     /* assert status == TIP | TREQ */
  529.     if (status != TIP + TREQ)
  530. printk("cuda: state=reading status=%xn", status);
  531.     via[B] ^= TACK; eieio();
  532. }
  533. break;
  535.     case read_done:
  536. x = via[SR]; eieio();
  537. if (reading_reply) {
  538.     req = current_req;
  539.     req->reply_len = reply_ptr - req->reply;
  540.     if (req->data[0] == ADB_PACKET) {
  541. /* Have to adjust the reply from ADB commands */
  542. if (req->reply_len <= 2 || (req->reply[1] & 2) != 0) {
  543.     /* the 0x2 bit indicates no response */
  544.     req->reply_len = 0;
  545. } else {
  546.     /* leave just the command and result bytes in the reply */
  547.     req->reply_len -= 2;
  548.     memmove(req->reply, req->reply + 2, req->reply_len);
  549. }
  550.     }
  551.     req->complete = 1;
  552.     current_req = req->next;
  553.     complete = 1;
  554. } else {
  555.     /* This is tricky. We must break the spinlock to call
  556.      * cuda_input. However, doing so means we might get
  557.      * re-entered from another CPU getting an interrupt
  558.      * or calling cuda_poll(). I ended up using the stack
  559.      * (it's only for 16 bytes) and moving the actual
  560.      * call to cuda_input to outside of the lock.
  561.      */
  562.     ibuf_len = reply_ptr - cuda_rbuf;
  563.     memcpy(ibuf, cuda_rbuf, ibuf_len);
  564. }
  565. if (status == TREQ) {
  566.     via[B] &= ~TIP; eieio();
  567.     cuda_state = reading;
  568.     reply_ptr = cuda_rbuf;
  569.     reading_reply = 0;
  570. } else {
  571.     cuda_state = idle;
  572.     cuda_start();
  573. }
  574. break;
  576.     default:
  577. printk("cuda_interrupt: unknown cuda_state %d?n", cuda_state);
  578.     }
  579.     spin_unlock(&cuda_lock);
  580.     if (complete && req && req->done)
  581. (*req->done)(req);
  582.     if (ibuf_len)
  583. cuda_input(ibuf, ibuf_len, regs);
  584. }
  586. static void
  587. cuda_input(unsigned char *buf, int nb, struct pt_regs *regs)
  588. {
  589.     int i;
  591.     switch (buf[0]) {
  592.     case ADB_PACKET:
  593. #ifdef CONFIG_XMON
  594. if (nb == 5 && buf[2] == 0x2c) {
  595.     extern int xmon_wants_key, xmon_adb_keycode;
  596.     if (xmon_wants_key) {
  597. xmon_adb_keycode = buf[3];
  598. return;
  599.     }
  600. }
  601. #endif /* CONFIG_XMON */
  602. #ifdef CONFIG_ADB
  603. adb_input(buf+2, nb-2, regs, buf[1] & 0x40);
  604. #endif /* CONFIG_ADB */
  605. break;
  607.     default:
  608. printk("data from cuda (%d bytes):", nb);
  609. for (i = 0; i < nb; ++i)
  610.     printk(" %.2x", buf[i]);
  611. printk("n");
  612.     }
  613. }