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

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

Linux/Unix编程

开发平台：

Unix_Linux

applicom.c：源码内容
  1. /* Derived from Applicom driver ac.c for SCO Unix                            */
  2. /* Ported by David Woodhouse, Axiom (Cambridge) Ltd.                         */
  3. /* dwmw2@redhat.com  30/8/98                                                 */
  4. /* $Id: ac.c,v 1.30 2000/03/22 16:03:57 dwmw2 Exp $      */
  5. /* This module is for Linux 2.1 and 2.2 series kernels.                      */
  6. /*****************************************************************************/
  7. /* J PAGET 18/02/94 passage V2.4.2 ioctl avec code 2 reset to les interrupt  */
  8. /* ceci pour reseter correctement apres une sortie sauvage                   */
  9. /* J PAGET 02/05/94 passage V2.4.3 dans le traitement de d'interruption,     */
  10. /* LoopCount n'etait pas initialise a 0.                                     */
  11. /* F LAFORSE 04/07/95 version V2.6.0 lecture bidon apres acces a une carte   */
  12. /*           pour liberer le bus                                             */
  13. /* J.PAGET 19/11/95 version V2.6.1 Nombre, addresse,irq n'est plus configure */
  14. /* et passe en argument a acinit, mais est scrute sur le bus pour s'adapter  */
  15. /* au nombre de cartes presentes sur le bus. IOCL code 6 affichait V2.4.3    */
  16. /* F.LAFORSE 28/11/95 creation de fichiers acXX.o avec les differentes       */
  17. /* adresses de base des cartes, IOCTL 6 plus complet                         */
  18. /* J.PAGET le 19/08/96 copie de la version V2.6 en V2.8.0 sans modification  */
  19. /* de code autre que le texte V2.6.1 en V2.8.0                               */
  20. /*****************************************************************************/
  23. #include <linux/kernel.h>
  24. #include <linux/module.h>
  25. #include <linux/slab.h>
  26. #include <asm/errno.h>
  27. #include <asm/io.h>
  28. #include <asm/uaccess.h>
  29. #include <linux/miscdevice.h>
  30. #include <linux/pci.h>
  31. #include <linux/wait.h>
  32. #include <linux/init.h>
  33. #include <linux/compatmac.h>
  35. #include "applicom.h"
  37. #if LINUX_VERSION_CODE < 0x20300 
  38. /* These probably want adding to <linux/compatmac.h> */
  39. #define init_waitqueue_head(x) do { *(x) = NULL; } while (0)
  40. #define PCI_BASE_ADDRESS(dev) (dev->base_address[0])
  41. #define DECLARE_WAIT_QUEUE_HEAD(x) struct wait_queue *x
  42. #define __setup(x,y) /* */
  43. #else
  44. #define PCI_BASE_ADDRESS(dev) (dev->resource[0].start)
  45. #endif
  47. /* NOTE: We use for loops with {write,read}b() instead of 
  48.    memcpy_{from,to}io throughout this driver. This is because
  49.    the board doesn't correctly handle word accesses - only
  50.    bytes. 
  51. */
  54. #undef DEBUG
  56. #define MAX_BOARD 8 /* maximum of pc board possible */
  57. #define MAX_ISA_BOARD 4
  58. #define LEN_RAM_IO 0x800
  59. #define AC_MINOR 157
  61. #ifndef PCI_VENDOR_ID_APPLICOM
  62. #define PCI_VENDOR_ID_APPLICOM                0x1389
  63. #define PCI_DEVICE_ID_APPLICOM_PCIGENERIC     0x0001
  64. #define PCI_DEVICE_ID_APPLICOM_PCI2000IBS_CAN 0x0002
  65. #define PCI_DEVICE_ID_APPLICOM_PCI2000PFB     0x0003
  66. #endif
  67. #define MAX_PCI_DEVICE_NUM 3
  69. static char *applicom_pci_devnames[] = {
  70. "PCI board",
  71. "PCI2000IBS / PCI2000CAN",
  72. "PCI2000PFB"
  73. };
  75. static struct pci_device_id applicom_pci_tbl[] = {
  76. { PCI_VENDOR_ID_APPLICOM, PCI_DEVICE_ID_APPLICOM_PCIGENERIC,
  77.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  78. { PCI_VENDOR_ID_APPLICOM, PCI_DEVICE_ID_APPLICOM_PCI2000IBS_CAN,
  79.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  80. { PCI_VENDOR_ID_APPLICOM, PCI_DEVICE_ID_APPLICOM_PCI2000PFB,
  81.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  82. { 0 }
  83. };
  84. MODULE_DEVICE_TABLE(pci, applicom_pci_tbl);
  86. MODULE_AUTHOR("David Woodhouse & Applicom International");
  87. MODULE_DESCRIPTION("Driver for Applicom Profibus card");
  88. MODULE_LICENSE("GPL");
  89. MODULE_PARM(irq, "i");
  90. MODULE_PARM_DESC(irq, "IRQ of the Applicom board");
  91. MODULE_PARM(mem, "i");
  92. MODULE_PARM_DESC(mem, "Shared Memory Address of Applicom board");
  94. MODULE_SUPPORTED_DEVICE("ac");
  97. static struct applicom_board {
  98. unsigned long PhysIO;
  99. unsigned long RamIO;
  100. wait_queue_head_t FlagSleepSend;
  101. long irq;
  102. spinlock_t mutex;
  103. } apbs[MAX_BOARD];
  105. static unsigned int irq = 0; /* interrupt number IRQ       */
  106. static unsigned long mem = 0; /* physical segment of board  */
  108. static unsigned int numboards; /* number of installed boards */
  109. static volatile unsigned char Dummy;
  110. static DECLARE_WAIT_QUEUE_HEAD(FlagSleepRec);
  111. static unsigned int WriteErrorCount; /* number of write error      */
  112. static unsigned int ReadErrorCount; /* number of read error       */
  113. static unsigned int DeviceErrorCount; /* number of device error     */
  115. static ssize_t ac_read (struct file *, char *, size_t, loff_t *);
  116. static ssize_t ac_write (struct file *, const char *, size_t, loff_t *);
  117. static int ac_ioctl(struct inode *, struct file *, unsigned int,
  118.     unsigned long);
  119. static void ac_interrupt(int, void *, struct pt_regs *);
  121. static struct file_operations ac_fops = {
  122. owner:THIS_MODULE,
  123. llseek:no_llseek,
  124. read:ac_read,
  125. write:ac_write,
  126. ioctl:ac_ioctl,
  127. };
  129. static struct miscdevice ac_miscdev = {
  130. AC_MINOR,
  131. "ac",
  132. &ac_fops
  133. };
  135. static int dummy; /* dev_id for request_irq() */
  137. static int ac_register_board(unsigned long physloc, unsigned long loc, 
  138.       unsigned char boardno)
  139. {
  140. volatile unsigned char byte_reset_it;
  142. if((readb(loc + CONF_END_TEST)     != 0x00) ||
  143.    (readb(loc + CONF_END_TEST + 1) != 0x55) ||
  144.    (readb(loc + CONF_END_TEST + 2) != 0xAA) ||
  145.    (readb(loc + CONF_END_TEST + 3) != 0xFF))
  146. return 0;
  148. if (!boardno)
  149. boardno = readb(loc + NUMCARD_OWNER_TO_PC);
  151. if (!boardno && boardno > MAX_BOARD) {
  152. printk(KERN_WARNING "Board #%d (at 0x%lx) is out of range (1 <= x <= %d).n",
  153.        boardno, physloc, MAX_BOARD);
  154. return 0;
  155. }
  157. if (apbs[boardno - 1].RamIO) {
  158. printk(KERN_WARNING "Board #%d (at 0x%lx) conflicts with previous board #%d (at 0x%lx)n", 
  159.        boardno, physloc, boardno, apbs[boardno-1].PhysIO);
  160. return 0;
  161. }
  163. boardno--;
  165. apbs[boardno].PhysIO = physloc;
  166. apbs[boardno].RamIO = loc;
  167. init_waitqueue_head(&apbs[boardno].FlagSleepSend);
  168. spin_lock_init(&apbs[boardno].mutex);
  169. byte_reset_it = readb(loc + RAM_IT_TO_PC);
  171. numboards++;
  172. return boardno + 1;
  173. }
  175. #ifdef MODULE
  177. #define applicom_init init_module
  179. void cleanup_module(void)
  180. {
  181. int i;
  183. misc_deregister(&ac_miscdev);
  185. for (i = 0; i < MAX_BOARD; i++) {
  187. if (!apbs[i].RamIO)
  188. continue;
  190. iounmap((void *) apbs[i].RamIO);
  192. if (apbs[i].irq)
  193. free_irq(apbs[i].irq, &dummy);
  194. }
  195. }
  197. #endif /* MODULE */
  199. int __init applicom_init(void)
  200. {
  201. int i, numisa = 0;
  202. struct pci_dev *dev = NULL;
  203. void *RamIO;
  204. int boardno;
  206. printk(KERN_INFO "Applicom driver: $Id: ac.c,v 1.30 2000/03/22 16:03:57 dwmw2 Exp $n");
  208. /* No mem and irq given - check for a PCI card */
  210. while ( (dev = pci_find_class(PCI_CLASS_OTHERS << 16, dev))) {
  212. if (dev->vendor != PCI_VENDOR_ID_APPLICOM)
  213. continue;
  215. if (dev->device  > MAX_PCI_DEVICE_NUM || dev->device == 0)
  216. continue;
  218. if (pci_enable_device(dev))
  219. return -EIO;
  221. RamIO = ioremap(PCI_BASE_ADDRESS(dev), LEN_RAM_IO);
  223. if (!RamIO) {
  224. printk(KERN_INFO "ac.o: Failed to ioremap PCI memory space at 0x%lxn", PCI_BASE_ADDRESS(dev));
  225. return -EIO;
  226. }
  228. printk(KERN_INFO "Applicom %s found at mem 0x%lx, irq %dn",
  229.        applicom_pci_devnames[dev->device-1], PCI_BASE_ADDRESS(dev), 
  230.        dev->irq);
  232. if (!(boardno = ac_register_board(PCI_BASE_ADDRESS(dev),
  233.   (unsigned long)RamIO,0))) {
  234. printk(KERN_INFO "ac.o: PCI Applicom device doesn't have correct signature.n");
  235. iounmap(RamIO);
  236. continue;
  237. }
  239. if (request_irq(dev->irq, &ac_interrupt, SA_SHIRQ, "Applicom PCI", &dummy)) {
  240. printk(KERN_INFO "Could not allocate IRQ %d for PCI Applicom device.n", dev->irq);
  241. iounmap(RamIO);
  242. apbs[boardno - 1].RamIO = 0;
  243. continue;
  244. }
  246. /* Enable interrupts. */
  248. writeb(0x40, apbs[boardno - 1].RamIO + RAM_IT_FROM_PC);
  250. apbs[boardno - 1].irq = dev->irq;
  251. }
  253. /* Finished with PCI cards. If none registered, 
  254.  * and there was no mem/irq specified, exit */
  256. if (!mem || !irq) {
  257. if (numboards)
  258. goto fin;
  259. else {
  260. printk(KERN_INFO "ac.o: No PCI boards found.n");
  261. printk(KERN_INFO "ac.o: For an ISA board you must supply memory and irq parameters.n");
  262. return -ENXIO;
  263. }
  264. }
  266. /* Now try the specified ISA cards */
  268. #warning "LEAK"
  269. RamIO = ioremap(mem, LEN_RAM_IO * MAX_ISA_BOARD);
  271. if (!RamIO) 
  272. printk(KERN_INFO "ac.o: Failed to ioremap ISA memory space at 0x%lxn", mem);
  274. for (i = 0; i < MAX_ISA_BOARD; i++) {
  275. RamIO = ioremap(mem + (LEN_RAM_IO * i), LEN_RAM_IO);
  277. if (!RamIO) {
  278. printk(KERN_INFO "ac.o: Failed to ioremap the ISA card's memory space (slot #%d)n", i + 1);
  279. continue;
  280. }
  282. if (!(boardno = ac_register_board((unsigned long)mem+ (LEN_RAM_IO*i),
  283.   (unsigned long)RamIO,i+1))) {
  284. iounmap(RamIO);
  285. continue;
  286. }
  288. printk(KERN_NOTICE "Applicom ISA card found at mem 0x%lx, irq %dn", mem + (LEN_RAM_IO*i), irq);
  290. if (!numisa) {
  291. if (request_irq(irq, &ac_interrupt, SA_SHIRQ, "Applicom ISA", &dummy)) {
  292. printk(KERN_WARNING "Could not allocate IRQ %d for ISA Applicom device.n", irq);
  293. iounmap((void *) RamIO);
  294. apbs[boardno - 1].RamIO = 0;
  295. }
  296. apbs[boardno - 1].irq = irq;
  297. }
  298. else
  299. apbs[boardno - 1].irq = 0;
  301. numisa++;
  302. }
  304. if (!numisa)
  305. printk(KERN_WARNING"ac.o: No valid ISA Applicom boards found at mem 0x%lxn",mem);
  307.  fin:
  308. init_waitqueue_head(&FlagSleepRec);
  310. WriteErrorCount = 0;
  311. ReadErrorCount = 0;
  312. DeviceErrorCount = 0;
  314. if (numboards) {
  315. misc_register(&ac_miscdev);
  316. for (i = 0; i < MAX_BOARD; i++) {
  317. int serial;
  318. char boardname[(SERIAL_NUMBER - TYPE_CARD) + 1];
  320. if (!apbs[i].RamIO)
  321. continue;
  323. for (serial = 0; serial < SERIAL_NUMBER - TYPE_CARD; serial++)
  324. boardname[serial] = readb(apbs[i].RamIO + TYPE_CARD + serial);
  326. boardname[serial] = 0;
  329. printk(KERN_INFO "Applicom board %d: %s, PROM V%d.%d",
  330.        i+1, boardname,
  331.        (int)(readb(apbs[i].RamIO + VERS) >> 4),
  332.        (int)(readb(apbs[i].RamIO + VERS) & 0xF));
  334. serial = (readb(apbs[i].RamIO + SERIAL_NUMBER) << 16) + 
  335. (readb(apbs[i].RamIO + SERIAL_NUMBER + 1) << 8) + 
  336. (readb(apbs[i].RamIO + SERIAL_NUMBER + 2) );
  338. if (serial != 0)
  339. printk(" S/N %dn", serial);
  340. else
  341. printk("n");
  342. }
  343. return 0;
  344. }
  346. else
  347. return -ENXIO;
  348. }
  351. #ifndef MODULE
  352. __initcall(applicom_init);
  353. #endif
  355. static ssize_t ac_write(struct file *file, const char *buf, size_t count, loff_t * ppos)
  356. {
  357. unsigned int NumCard; /* Board number 1 -> 8           */
  358. unsigned int IndexCard; /* Index board number 0 -> 7     */
  359. unsigned char TicCard; /* Board TIC to send             */
  360. unsigned long flags; /* Current priority              */
  361. struct st_ram_io st_loc;
  362. struct mailbox tmpmailbox;
  363. #ifdef DEBUG
  364. int c;
  365. #endif
  366. DECLARE_WAITQUEUE(wait, current);
  368. if (count != sizeof(struct st_ram_io) + sizeof(struct mailbox)) {
  369. static int warncount = 5;
  370. if (warncount) {
  371. printk(KERN_INFO "Hmmm. write() of Applicom card, length %d != expected %dn",
  372.        count, sizeof(struct st_ram_io) + sizeof(struct mailbox));
  373. warncount--;
  374. }
  375. return -EINVAL;
  376. }
  378. if(copy_from_user(&st_loc, buf, sizeof(struct st_ram_io))) 
  379. return -EFAULT;
  381. if(copy_from_user(&tmpmailbox, &buf[sizeof(struct st_ram_io)],
  382.   sizeof(struct mailbox))) 
  383. return -EFAULT;
  385. NumCard = st_loc.num_card; /* board number to send          */
  386. TicCard = st_loc.tic_des_from_pc; /* tic number to send            */
  387. IndexCard = NumCard - 1;
  389. if((NumCard < 1) || (NumCard > MAX_BOARD) || !apbs[IndexCard].RamIO)
  390. return -EINVAL;
  392. #ifdef DEBUG
  393. printk("Write to applicom card #%d. struct st_ram_io follows:",
  394.        IndexCard+1);
  396. for (c = 0; c < sizeof(struct st_ram_io);) {
  398. printk("n%5.5X: %2.2X", c, ((unsigned char *) &st_loc)[c]);
  400. for (c++; c % 8 && c < sizeof(struct st_ram_io); c++) {
  401. printk(" %2.2X", ((unsigned char *) &st_loc)[c]);
  402. }
  403. }
  405. printk("nstruct mailbox follows:");
  407. for (c = 0; c < sizeof(struct mailbox);) {
  408. printk("n%5.5X: %2.2X", c, ((unsigned char *) &tmpmailbox)[c]);
  410. for (c++; c % 8 && c < sizeof(struct mailbox); c++) {
  411. printk(" %2.2X", ((unsigned char *) &tmpmailbox)[c]);
  412. }
  413. }
  415. printk("n");
  416. #endif
  418. spin_lock_irqsave(&apbs[IndexCard].mutex, flags);
  420. /* Test octet ready correct */
  421. if(readb(apbs[IndexCard].RamIO + DATA_FROM_PC_READY) > 2) { 
  422. Dummy = readb(apbs[IndexCard].RamIO + VERS);
  423. spin_unlock_irqrestore(&apbs[IndexCard].mutex, flags);
  424. printk(KERN_WARNING "APPLICOM driver write error board %d, DataFromPcReady = %dn",
  425.        IndexCard,(int)readb(apbs[IndexCard].RamIO + DATA_FROM_PC_READY));
  426. DeviceErrorCount++;
  427. return -EIO;
  428. }
  430. /* Place ourselves on the wait queue */
  431. set_current_state(TASK_INTERRUPTIBLE);
  432. add_wait_queue(&apbs[IndexCard].FlagSleepSend, &wait);
  434. /* Check whether the card is ready for us */
  435. while (readb(apbs[IndexCard].RamIO + DATA_FROM_PC_READY) != 0) {
  436. Dummy = readb(apbs[IndexCard].RamIO + VERS);
  437. /* It's busy. Sleep. */
  439. spin_unlock_irqrestore(&apbs[IndexCard].mutex, flags);
  440. schedule();
  441. if (signal_pending(current)) {
  442. remove_wait_queue(&apbs[IndexCard].FlagSleepSend,
  443.   &wait);
  444. return -EINTR;
  445. }
  446. spin_lock_irqsave(&apbs[IndexCard].mutex, flags);
  447. set_current_state(TASK_INTERRUPTIBLE);
  448. }
  450. /* We may not have actually slept */
  451. set_current_state(TASK_RUNNING);
  452. remove_wait_queue(&apbs[IndexCard].FlagSleepSend, &wait);
  454. writeb(1, apbs[IndexCard].RamIO + DATA_FROM_PC_READY);
  456. /* Which is best - lock down the pages with rawio and then
  457.    copy directly, or use bounce buffers? For now we do the latter 
  458.    because it works with 2.2 still */
  459. {
  460. unsigned char *from = (unsigned char *) &tmpmailbox;
  461. unsigned long to = (unsigned long) apbs[IndexCard].RamIO + RAM_FROM_PC;
  462. int c;
  464. for (c = 0; c < sizeof(struct mailbox); c++)
  465. writeb(*(from++), to++);
  466. }
  468. writeb(0x20, apbs[IndexCard].RamIO + TIC_OWNER_FROM_PC);
  469. writeb(0xff, apbs[IndexCard].RamIO + NUMCARD_OWNER_FROM_PC);
  470. writeb(TicCard, apbs[IndexCard].RamIO + TIC_DES_FROM_PC);
  471. writeb(NumCard, apbs[IndexCard].RamIO + NUMCARD_DES_FROM_PC);
  472. writeb(2, apbs[IndexCard].RamIO + DATA_FROM_PC_READY);
  473. writeb(1, apbs[IndexCard].RamIO + RAM_IT_FROM_PC);
  474. Dummy = readb(apbs[IndexCard].RamIO + VERS);
  475. spin_unlock_irqrestore(&apbs[IndexCard].mutex, flags);
  476. return 0;
  477. }
  479. static int do_ac_read(int IndexCard, char *buf)
  480. {
  481. struct st_ram_io st_loc;
  482. struct mailbox tmpmailbox; /* bounce buffer - can't copy to user space with cli() */
  483. unsigned long from = (unsigned long)apbs[IndexCard].RamIO + RAM_TO_PC;
  484. unsigned char *to = (unsigned char *)&tmpmailbox;
  485. #ifdef DEBUG
  486. int c;
  487. #endif
  489. st_loc.tic_owner_to_pc = readb(apbs[IndexCard].RamIO + TIC_OWNER_TO_PC);
  490. st_loc.numcard_owner_to_pc = readb(apbs[IndexCard].RamIO + NUMCARD_OWNER_TO_PC);
  493. {
  494. int c;
  496. for (c = 0; c < sizeof(struct mailbox); c++)
  497. *(to++) = readb(from++);
  498. }
  499. writeb(1, apbs[IndexCard].RamIO + ACK_FROM_PC_READY);
  500. writeb(1, apbs[IndexCard].RamIO + TYP_ACK_FROM_PC);
  501. writeb(IndexCard+1, apbs[IndexCard].RamIO + NUMCARD_ACK_FROM_PC);
  502. writeb(readb(apbs[IndexCard].RamIO + TIC_OWNER_TO_PC), 
  503.        apbs[IndexCard].RamIO + TIC_ACK_FROM_PC);
  504. writeb(2, apbs[IndexCard].RamIO + ACK_FROM_PC_READY);
  505. writeb(0, apbs[IndexCard].RamIO + DATA_TO_PC_READY);
  506. writeb(2, apbs[IndexCard].RamIO + RAM_IT_FROM_PC);
  507. Dummy = readb(apbs[IndexCard].RamIO + VERS);
  509. #ifdef DEBUG
  510. printk("Read from applicom card #%d. struct st_ram_io follows:", NumCard);
  512. for (c = 0; c < sizeof(struct st_ram_io);) {
  513. printk("n%5.5X: %2.2X", c, ((unsigned char *) &st_loc)[c]);
  515. for (c++; c % 8 && c < sizeof(struct st_ram_io); c++) {
  516. printk(" %2.2X", ((unsigned char *) &st_loc)[c]);
  517. }
  518. }
  520. printk("nstruct mailbox follows:");
  522. for (c = 0; c < sizeof(struct mailbox);) {
  523. printk("n%5.5X: %2.2X", c, ((unsigned char *) &tmpmailbox)[c]);
  525. for (c++; c % 8 && c < sizeof(struct mailbox); c++) {
  526. printk(" %2.2X", ((unsigned char *) &tmpmailbox)[c]);
  527. }
  528. }
  529. printk("n");
  530. #endif
  532. #warning "Je suis stupide. DW. - copy*user in cli"
  534. if (copy_to_user(buf, &st_loc, sizeof(struct st_ram_io)))
  535. return -EFAULT;
  536. if (copy_to_user(&buf[sizeof(struct st_ram_io)], &tmpmailbox, sizeof(struct mailbox)))
  537. return -EFAULT;
  539. return (sizeof(struct st_ram_io) + sizeof(struct mailbox));
  540. }
  542. static ssize_t ac_read (struct file *filp, char *buf, size_t count, loff_t *ptr)
  543. {
  544. unsigned long flags;
  545. unsigned int i;
  546. unsigned char tmp;
  547. int ret = 0;
  548. DECLARE_WAITQUEUE(wait, current);
  549. #ifdef DEBUG
  550. int loopcount=0;
  551. #endif
  552. /* No need to ratelimit this. Only root can trigger it anyway */
  553. if (count != sizeof(struct st_ram_io) + sizeof(struct mailbox)) {
  554. printk( KERN_WARNING "Hmmm. read() of Applicom card, length %d != expected %dn",
  555. count,sizeof(struct st_ram_io) + sizeof(struct mailbox));
  556. return -EINVAL;
  557. }
  559. while(1) {
  560. /* Stick ourself on the wait queue */
  561. set_current_state(TASK_INTERRUPTIBLE);
  562. add_wait_queue(&FlagSleepRec, &wait);
  564. /* Scan each board, looking for one which has a packet for us */
  565. for (i=0; i < MAX_BOARD; i++) {
  566. if (!apbs[i].RamIO)
  567. continue;
  568. spin_lock_irqsave(&apbs[i].mutex, flags);
  570. tmp = readb(apbs[i].RamIO + DATA_TO_PC_READY);
  572. if (tmp == 2) {
  573. /* Got a packet for us */
  574. ret = do_ac_read(i, buf);
  575. spin_unlock_irqrestore(&apbs[i].mutex, flags);
  576. set_current_state(TASK_RUNNING);
  577. remove_wait_queue(&FlagSleepRec, &wait);
  578. return tmp;
  579. }
  581. if (tmp > 2) {
  582. /* Got an error */
  583. Dummy = readb(apbs[i].RamIO + VERS);
  585. spin_unlock_irqrestore(&apbs[i].mutex, flags);
  586. set_current_state(TASK_RUNNING);
  587. remove_wait_queue(&FlagSleepRec, &wait);
  589. printk(KERN_WARNING "APPLICOM driver read error board %d, DataToPcReady = %dn",
  590.        i,(int)readb(apbs[i].RamIO + DATA_TO_PC_READY));
  591. DeviceErrorCount++;
  592. return -EIO;
  593. }
  595. /* Nothing for us. Try the next board */
  596. Dummy = readb(apbs[i].RamIO + VERS);
  597. spin_unlock_irqrestore(&apbs[i].mutex, flags);
  599. } /* per board */
  601. /* OK - No boards had data for us. Sleep now */
  603. schedule();
  604. remove_wait_queue(&FlagSleepRec, &wait);
  606. if (signal_pending(current))
  607. return -EINTR;
  609. #ifdef DEBUG
  610. if (loopcount++ > 2) {
  611. printk("Looping in ac_read. loopcount %dn", loopcount);
  612. }
  613. #endif
  614. } 
  615. }
  617. static void ac_interrupt(int vec, void *dev_instance, struct pt_regs *regs)
  618. {
  619. unsigned int i;
  620. unsigned int FlagInt;
  621. unsigned int LoopCount;
  623. //    printk("Applicom interrupt on IRQ %d occurredn", vec);
  625. LoopCount = 0;
  627. do {
  628. FlagInt = 0;
  629. for (i = 0; i < MAX_BOARD; i++) {
  631. /* Skip if this board doesn't exist */
  632. if (!apbs[i].RamIO)
  633. continue;
  635. spin_lock(&apbs[i].mutex);
  637. /* Skip if this board doesn't want attention */
  638. if(readb(apbs[i].RamIO + RAM_IT_TO_PC) == 0) {
  639. spin_unlock(&apbs[i].mutex);
  640. continue;
  641. }
  643. FlagInt = 1;
  644. writeb(0, apbs[i].RamIO + RAM_IT_TO_PC);
  646. if (readb(apbs[i].RamIO + DATA_TO_PC_READY) > 2) {
  647. printk(KERN_WARNING "APPLICOM driver interrupt err board %d, DataToPcReady = %dn",
  648.        i+1,(int)readb(apbs[i].RamIO + DATA_TO_PC_READY));
  649. DeviceErrorCount++;
  650. }
  652. if((readb(apbs[i].RamIO + DATA_FROM_PC_READY) > 2) && 
  653.    (readb(apbs[i].RamIO + DATA_FROM_PC_READY) != 6)) {
  655. printk(KERN_WARNING "APPLICOM driver interrupt err board %d, DataFromPcReady = %dn",
  656.        i+1,(int)readb(apbs[i].RamIO + DATA_FROM_PC_READY));
  657. DeviceErrorCount++;
  658. }
  660. if (readb(apbs[i].RamIO + DATA_TO_PC_READY) == 2) { /* mailbox sent by the card ?   */
  661. if (waitqueue_active(&FlagSleepRec)) {
  662. wake_up_interruptible(&FlagSleepRec);
  663. }
  664. }
  666. if (readb(apbs[i].RamIO + DATA_FROM_PC_READY) == 0) { /* ram i/o free for write by pc ? */
  667. if (waitqueue_active(&apbs[i].FlagSleepSend)) { /* process sleep during read ?    */
  668. wake_up_interruptible(&apbs[i].FlagSleepSend);
  669. }
  670. }
  671. Dummy = readb(apbs[i].RamIO + VERS);
  673. if(readb(apbs[i].RamIO + RAM_IT_TO_PC)) {
  674. /* There's another int waiting on this card */
  675. spin_unlock(&apbs[i].mutex);
  676. i--;
  677. } else {
  678. spin_unlock(&apbs[i].mutex);
  679. }
  680. }
  681. if (FlagInt)
  682. LoopCount = 0;
  683. else
  684. LoopCount++;
  685. } while(LoopCount < 2);
  686. }
  690. static int ac_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  691.      
  692. { /* @ ADG ou ATO selon le cas */
  693. int i;
  694. unsigned char IndexCard;
  695. unsigned long pmem;
  696. int ret = 0;
  697. volatile unsigned char byte_reset_it;
  698. struct st_ram_io *adgl;
  700. /* In general, the device is only openable by root anyway, so we're not
  701.    particularly concerned that bogus ioctls can flood the console. */
  703. adgl = kmalloc(sizeof(struct st_ram_io), GFP_KERNEL);
  704. if (!adgl)
  705. return -ENOMEM;
  707. if (copy_from_user(adgl, (void *)arg,sizeof(struct st_ram_io))) {
  708. kfree(adgl);
  709. return -EFAULT;
  710. }
  712. IndexCard = adgl->num_card-1;
  713.  
  714. if(cmd != 0 && cmd != 6 &&
  715.    ((IndexCard >= MAX_BOARD) || !apbs[IndexCard].RamIO)) {
  716. static int warncount = 10;
  717. if (warncount) {
  718. printk( KERN_WARNING "APPLICOM driver IOCTL, bad board number %dn",(int)IndexCard+1);
  719. warncount--;
  720. }
  721. kfree(adgl);
  722. return -EINVAL;
  723. }
  725. switch (cmd) {
  727. case 0:
  728. pmem = apbs[IndexCard].RamIO;
  729. for (i = 0; i < sizeof(struct st_ram_io); i++)
  730. ((unsigned char *)adgl)[i]=readb(pmem++);
  731. if (copy_to_user((void *)arg, adgl, sizeof(struct st_ram_io)))
  732. ret = -EFAULT;
  733. break;
  734. case 1:
  735. pmem = apbs[IndexCard].RamIO + CONF_END_TEST;
  736. for (i = 0; i < 4; i++)
  737. adgl->conf_end_test[i] = readb(pmem++);
  738. for (i = 0; i < 2; i++)
  739. adgl->error_code[i] = readb(pmem++);
  740. for (i = 0; i < 4; i++)
  741. adgl->parameter_error[i] = readb(pmem++);
  742. pmem = apbs[IndexCard].RamIO + VERS;
  743. adgl->vers = readb(pmem);
  744. pmem = apbs[IndexCard].RamIO + TYPE_CARD;
  745. for (i = 0; i < 20; i++)
  746. adgl->reserv1[i] = readb(pmem++);
  747. *(int *)&adgl->reserv1[20] =  
  748. (readb(apbs[IndexCard].RamIO + SERIAL_NUMBER) << 16) + 
  749. (readb(apbs[IndexCard].RamIO + SERIAL_NUMBER + 1) << 8) + 
  750. (readb(apbs[IndexCard].RamIO + SERIAL_NUMBER + 2) );
  752. if (copy_to_user((void *)arg, adgl, sizeof(struct st_ram_io)))
  753. ret = -EFAULT;
  754. break;
  755. case 2:
  756. pmem = apbs[IndexCard].RamIO + CONF_END_TEST;
  757. for (i = 0; i < 10; i++)
  758. writeb(0xff, pmem++);
  759. writeb(adgl->data_from_pc_ready, 
  760.        apbs[IndexCard].RamIO + DATA_FROM_PC_READY);
  762. writeb(1, apbs[IndexCard].RamIO + RAM_IT_FROM_PC);
  764. for (i = 0; i < MAX_BOARD; i++) {
  765. if (apbs[i].RamIO) {
  766. byte_reset_it = readb(apbs[i].RamIO + RAM_IT_TO_PC);
  767. }
  768. }
  769. break;
  770. case 3:
  771. pmem = apbs[IndexCard].RamIO + TIC_DES_FROM_PC;
  772. writeb(adgl->tic_des_from_pc, pmem);
  773. break;
  774. case 4:
  775. pmem = apbs[IndexCard].RamIO + TIC_OWNER_TO_PC;
  776. adgl->tic_owner_to_pc     = readb(pmem++);
  777. adgl->numcard_owner_to_pc = readb(pmem);
  778. if (copy_to_user((void *)arg, adgl,sizeof(struct st_ram_io)))
  779. ret = -EFAULT;
  780. break;
  781. case 5:
  782. writeb(adgl->num_card, apbs[IndexCard].RamIO + NUMCARD_OWNER_TO_PC);
  783. writeb(adgl->num_card, apbs[IndexCard].RamIO + NUMCARD_DES_FROM_PC);
  784. writeb(adgl->num_card, apbs[IndexCard].RamIO + NUMCARD_ACK_FROM_PC);
  785. writeb(4, apbs[IndexCard].RamIO + DATA_FROM_PC_READY);
  786. writeb(1, apbs[IndexCard].RamIO + RAM_IT_FROM_PC);
  787. break;
  788. case 6:
  789. printk(KERN_INFO "APPLICOM driver release .... V2.8.0 ($Revision: 1.30 $)n");
  790. printk(KERN_INFO "Number of installed boards . %dn", (int) numboards);
  791. printk(KERN_INFO "Segment of board ........... %Xn", (int) mem);
  792. printk(KERN_INFO "Interrupt IRQ number ....... %dn", (int) irq);
  793. for (i = 0; i < MAX_BOARD; i++) {
  794. int serial;
  795. char boardname[(SERIAL_NUMBER - TYPE_CARD) + 1];
  797. if (!apbs[i].RamIO)
  798. continue;
  800. for (serial = 0; serial < SERIAL_NUMBER - TYPE_CARD; serial++)
  801. boardname[serial] = readb(apbs[i].RamIO + TYPE_CARD + serial);
  802. boardname[serial] = 0;
  804. printk(KERN_INFO "Prom version board %d ....... V%d.%d %s",
  805.        i+1,
  806.        (int)(readb(apbs[IndexCard].RamIO + VERS) >> 4),
  807.        (int)(readb(apbs[IndexCard].RamIO + VERS) & 0xF),
  808.        boardname);
  811. serial = (readb(apbs[i].RamIO + SERIAL_NUMBER) << 16) + 
  812. (readb(apbs[i].RamIO + SERIAL_NUMBER + 1) << 8) + 
  813. (readb(apbs[i].RamIO + SERIAL_NUMBER + 2) );
  815. if (serial != 0)
  816. printk(" S/N %dn", serial);
  817. else
  818. printk("n");
  819. }
  820. if (DeviceErrorCount != 0)
  821. printk(KERN_INFO "DeviceErrorCount ........... %dn", DeviceErrorCount);
  822. if (ReadErrorCount != 0)
  823. printk(KERN_INFO "ReadErrorCount ............. %dn", ReadErrorCount);
  824. if (WriteErrorCount != 0)
  825. printk(KERN_INFO "WriteErrorCount ............ %dn", WriteErrorCount);
  826. if (waitqueue_active(&FlagSleepRec))
  827. printk(KERN_INFO "Process in read pendingn");
  828. for (i = 0; i < MAX_BOARD; i++) {
  829. if (apbs[i].RamIO && waitqueue_active(&apbs[i].FlagSleepSend))
  830. printk(KERN_INFO "Process in write pending board %dn",i+1);
  831. }
  832. break;
  833. default:
  834. printk(KERN_INFO "APPLICOM driver ioctl, unknown function code %dn",cmd) ;
  835. ret = -EINVAL;
  836. break;
  837. }
  838. Dummy = readb(apbs[IndexCard].RamIO + VERS);
  839. kfree(adgl);
  840. return 0;
  841. }
  843. #ifndef MODULE
  844. static int __init applicom_setup(char *str)
  845. {
  846. int ints[4];
  848. (void) get_options(str, 4, ints);
  850. if (ints[0] > 2) {
  851. printk(KERN_WARNING "Too many arguments to 'applicom=', expected mem,irq only.n");
  852. }
  854. if (ints[0] < 2) {
  855. printk(KERN_INFO"applicom numargs: %dn", ints[0]);
  856. return 0;
  857. }
  859. mem = ints[1];
  860. irq = ints[2];
  861. return 1;
  862. }
  864. __setup("applicom=", applicom_setup);
  866. #endif /* MODULE */