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

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

Linux/Unix编程

开发平台：

Unix_Linux

cosa.c：源码内容
  1. /* $Id: cosa.c,v 1.31 2000/03/08 17:47:16 kas Exp $ */
  3. /*
  4.  *  Copyright (C) 1995-1997  Jan "Yenya" Kasprzak <kas@fi.muni.cz>
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  21. /*
  22.  * The driver for the SRP and COSA synchronous serial cards.
  23.  *
  24.  * HARDWARE INFO
  25.  *
  26.  * Both cards are developed at the Institute of Computer Science,
  27.  * Masaryk University (http://www.ics.muni.cz/). The hardware is
  28.  * developed by Jiri Novotny <novotny@ics.muni.cz>. More information
  29.  * and the photo of both cards is available at
  30.  * http://www.pavoucek.cz/cosa.html. The card documentation, firmwares
  31.  * and other goods can be downloaded from ftp://ftp.ics.muni.cz/pub/cosa/.
  32.  * For Linux-specific utilities, see below in the "Software info" section.
  33.  * If you want to order the card, contact Jiri Novotny.
  34.  *
  35.  * The SRP (serial port?, the Czech word "srp" means "sickle") card
  36.  * is a 2-port intelligent (with its own 8-bit CPU) synchronous serial card
  37.  * with V.24 interfaces up to 80kb/s each.
  38.  *
  39.  * The COSA (communication serial adapter?, the Czech word "kosa" means
  40.  * "scythe") is a next-generation sync/async board with two interfaces
  41.  * - currently any of V.24, X.21, V.35 and V.36 can be selected.
  42.  * It has a 16-bit SAB80166 CPU and can do up to 10 Mb/s per channel.
  43.  * The 8-channels version is in development.
  44.  *
  45.  * Both types have downloadable firmware and communicate via ISA DMA.
  46.  * COSA can be also a bus-mastering device.
  47.  *
  48.  * SOFTWARE INFO
  49.  *
  50.  * The homepage of the Linux driver is at http://www.fi.muni.cz/~kas/cosa/.
  51.  * The CVS tree of Linux driver can be viewed there, as well as the
  52.  * firmware binaries and user-space utilities for downloading the firmware
  53.  * into the card and setting up the card.
  54.  *
  55.  * The Linux driver (unlike the present *BSD drivers :-) can work even
  56.  * for the COSA and SRP in one computer and allows each channel to work
  57.  * in one of the three modes (character device, Cisco HDLC, Sync PPP).
  58.  *
  59.  * AUTHOR
  60.  *
  61.  * The Linux driver was written by Jan "Yenya" Kasprzak <kas@fi.muni.cz>.
  62.  *
  63.  * You can mail me bugfixes and even success reports. I am especially
  64.  * interested in the SMP and/or muliti-channel success/failure reports
  65.  * (I wonder if I did the locking properly :-).
  66.  *
  67.  * THE AUTHOR USED THE FOLLOWING SOURCES WHEN PROGRAMMING THE DRIVER
  68.  *
  69.  * The COSA/SRP NetBSD driver by Zdenek Salvet and Ivos Cernohlavek
  70.  * The skeleton.c by Donald Becker
  71.  * The SDL Riscom/N2 driver by Mike Natale
  72.  * The Comtrol Hostess SV11 driver by Alan Cox
  73.  * The Sync PPP/Cisco HDLC layer (syncppp.c) ported to Linux by Alan Cox
  74.  */
  75. /*
  76.  *     5/25/1999 : Marcelo Tosatti <marcelo@conectiva.com.br>
  77.  *             fixed a deadlock in cosa_sppp_open
  78.  */
  80. /* ---------- Headers, macros, data structures ---------- */
  82. #include <linux/config.h>
  83. #include <linux/module.h>
  84. #include <linux/kernel.h>
  85. #include <linux/slab.h>
  86. #include <linux/poll.h>
  87. #include <linux/fs.h>
  88. #include <linux/devfs_fs_kernel.h>
  89. #include <linux/sched.h>
  90. #include <linux/interrupt.h>
  91. #include <linux/delay.h>
  92. #include <linux/errno.h>
  93. #include <linux/ioport.h>
  94. #include <linux/netdevice.h>
  95. #include <linux/spinlock.h>
  96. #include <linux/smp_lock.h>
  98. #undef COSA_SLOW_IO /* for testing purposes only */
  99. #undef REALLY_SLOW_IO
  101. #include <asm/io.h>
  102. #include <asm/dma.h>
  103. #include <asm/byteorder.h>
  105. #include <net/syncppp.h>
  106. #include "cosa.h"
  108. /* Maximum length of the identification string. */
  109. #define COSA_MAX_ID_STRING 128
  111. /* Maximum length of the channel name */
  112. #define COSA_MAX_NAME (sizeof("cosaXXXcXXX")+1)
  114. /* Per-channel data structure */
  116. struct channel_data {
  117. void *if_ptr; /* General purpose pointer (used by SPPP) */
  118. int usage; /* Usage count; >0 for chrdev, -1 for netdev */
  119. int num; /* Number of the channel */
  120. struct cosa_data *cosa; /* Pointer to the per-card structure */
  121. int txsize; /* Size of transmitted data */
  122. char *txbuf; /* Transmit buffer */
  123. char name[COSA_MAX_NAME]; /* channel name */
  125. /* The HW layer interface */
  126. /* routine called from the RX interrupt */
  127. char *(*setup_rx)(struct channel_data *channel, int size);
  128. /* routine called when the RX is done (from the EOT interrupt) */
  129. int (*rx_done)(struct channel_data *channel);
  130. /* routine called when the TX is done (from the EOT interrupt) */
  131. int (*tx_done)(struct channel_data *channel, int size);
  133. /* Character device parts */
  134. struct semaphore rsem, wsem;
  135. char *rxdata;
  136. int rxsize;
  137. wait_queue_head_t txwaitq, rxwaitq;
  138. int tx_status, rx_status;
  140. /* SPPP/HDLC device parts */
  141. struct ppp_device pppdev;
  142. struct sk_buff *rx_skb, *tx_skb;
  143. struct net_device_stats stats;
  144. };
  146. /* cosa->firmware_status bits */
  147. #define COSA_FW_RESET (1<<0) /* Is the ROM monitor active? */
  148. #define COSA_FW_DOWNLOAD (1<<1) /* Is the microcode downloaded? */
  149. #define COSA_FW_START (1<<2) /* Is the microcode running? */
  151. struct cosa_data {
  152. int num; /* Card number */
  153. char name[COSA_MAX_NAME]; /* Card name - e.g "cosa0" */
  154. unsigned int datareg, statusreg; /* I/O ports */
  155. unsigned short irq, dma; /* IRQ and DMA number */
  156. unsigned short startaddr; /* Firmware start address */
  157. unsigned short busmaster; /* Use busmastering? */
  158. int nchannels; /* # of channels on this card */
  159. int driver_status; /* For communicating with firware */
  160. int firmware_status; /* Downloaded, reseted, etc. */
  161. long int rxbitmap, txbitmap; /* Bitmap of channels who are willing to send/receive data */
  162. long int rxtx; /* RX or TX in progress? */
  163. int enabled;
  164. int usage; /* usage count */
  165. int txchan, txsize, rxsize;
  166. struct channel_data *rxchan;
  167. char *bouncebuf;
  168. char *txbuf, *rxbuf;
  169. struct channel_data *chan;
  170. spinlock_t lock; /* For exclusive operations on this structure */
  171. char id_string[COSA_MAX_ID_STRING]; /* ROM monitor ID string */
  172. char *type; /* card type */
  173. };
  175. /*
  176.  * Define this if you want all the possible ports to be autoprobed.
  177.  * It is here but it probably is not a good idea to use this.
  178.  */
  179. /* #define COSA_ISA_AUTOPROBE 1 */
  181. /*
  182.  * Character device major number. 117 was allocated for us.
  183.  * The value of 0 means to allocate a first free one.
  184.  */
  185. static int cosa_major = 117;
  187. /*
  188.  * Encoding of the minor numbers:
  189.  * The lowest CARD_MINOR_BITS bits means the channel on the single card,
  190.  * the highest bits means the card number.
  191.  */
  192. #define CARD_MINOR_BITS 4 /* How many bits in minor number are reserved
  193.  * for the single card */
  194. /*
  195.  * The following depends on CARD_MINOR_BITS. Unfortunately, the "MODULE_STRING"
  196.  * macro doesn't like anything other than the raw number as an argument :-(
  197.  */
  198. #define MAX_CARDS 16
  199. /* #define MAX_CARDS (1 << (8-CARD_MINOR_BITS)) */
  201. #define DRIVER_RX_READY 0x0001
  202. #define DRIVER_TX_READY 0x0002
  203. #define DRIVER_TXMAP_SHIFT 2
  204. #define DRIVER_TXMAP_MASK 0x0c /* FIXME: 0xfc for 8-channel version */
  206. /*
  207.  * for cosa->rxtx - indicates whether either transmit or receive is
  208.  * in progress. These values are mean number of the bit.
  209.  */
  210. #define TXBIT 0
  211. #define RXBIT 1
  212. #define IRQBIT 2
  214. #define COSA_MTU 2000 /* FIXME: I don't know this exactly */
  216. #undef DEBUG_DATA //1 /* Dump the data read or written to the channel */
  217. #undef DEBUG_IRQS //1 /* Print the message when the IRQ is received */
  218. #undef DEBUG_IO   //1 /* Dump the I/O traffic */
  220. #define TX_TIMEOUT (5*HZ)
  222. /* Maybe the following should be allocated dynamically */
  223. static struct cosa_data cosa_cards[MAX_CARDS];
  224. static int nr_cards;
  226. #ifdef COSA_ISA_AUTOPROBE
  227. static int io[MAX_CARDS+1]  = { 0x220, 0x228, 0x210, 0x218, 0, };
  228. /* NOTE: DMA is not autoprobed!!! */
  229. static int dma[MAX_CARDS+1] = { 1, 7, 1, 7, 1, 7, 1, 7, 0, };
  230. #else
  231. int io[MAX_CARDS+1]  = { 0, };
  232. int dma[MAX_CARDS+1] = { 0, };
  233. #endif
  234. /* IRQ can be safely autoprobed */
  235. static int irq[MAX_CARDS+1] = { -1, -1, -1, -1, -1, -1, 0, };
  237. #ifdef MODULE
  238. MODULE_PARM(io, "1-" __MODULE_STRING(MAX_CARDS) "i");
  239. MODULE_PARM_DESC(io, "The I/O bases of the COSA or SRP cards");
  240. MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_CARDS) "i");
  241. MODULE_PARM_DESC(irq, "The IRQ lines of the COSA or SRP cards");
  242. MODULE_PARM(dma, "1-" __MODULE_STRING(MAX_CARDS) "i");
  243. MODULE_PARM_DESC(dma, "The DMA channels of the COSA or SRP cards");
  245. MODULE_AUTHOR("Jan "Yenya" Kasprzak, <kas@fi.muni.cz>");
  246. MODULE_DESCRIPTION("Modular driver for the COSA or SRP synchronous card");
  247. MODULE_LICENSE("GPL");
  248. #endif
  250. /* I use this mainly for testing purposes */
  251. #ifdef COSA_SLOW_IO
  252. #define cosa_outb outb_p
  253. #define cosa_outw outw_p
  254. #define cosa_inb  inb_p
  255. #define cosa_inw  inw_p
  256. #else
  257. #define cosa_outb outb
  258. #define cosa_outw outw
  259. #define cosa_inb  inb
  260. #define cosa_inw  inw
  261. #endif
  263. #define is_8bit(cosa) (!(cosa->datareg & 0x08))
  265. #define cosa_getstatus(cosa) (cosa_inb(cosa->statusreg))
  266. #define cosa_putstatus(cosa, stat) (cosa_outb(stat, cosa->statusreg))
  267. #define cosa_getdata16(cosa) (cosa_inw(cosa->datareg))
  268. #define cosa_getdata8(cosa) (cosa_inb(cosa->datareg))
  269. #define cosa_putdata16(cosa, dt) (cosa_outw(dt, cosa->datareg))
  270. #define cosa_putdata8(cosa, dt) (cosa_outb(dt, cosa->datareg))
  272. /* Initialization stuff */
  273. static int cosa_probe(int ioaddr, int irq, int dma);
  275. /* HW interface */
  276. static void cosa_enable_rx(struct channel_data *chan);
  277. static void cosa_disable_rx(struct channel_data *chan);
  278. static int cosa_start_tx(struct channel_data *channel, char *buf, int size);
  279. static void cosa_kick(struct cosa_data *cosa);
  280. static int cosa_dma_able(struct channel_data *chan, char *buf, int data);
  282. /* SPPP/HDLC stuff */
  283. static void sppp_channel_init(struct channel_data *chan);
  284. static void sppp_channel_delete(struct channel_data *chan);
  285. static int cosa_sppp_open(struct net_device *d);
  286. static int cosa_sppp_close(struct net_device *d);
  287. static void cosa_sppp_timeout(struct net_device *d);
  288. static int cosa_sppp_tx(struct sk_buff *skb, struct net_device *d);
  289. static char *sppp_setup_rx(struct channel_data *channel, int size);
  290. static int sppp_rx_done(struct channel_data *channel);
  291. static int sppp_tx_done(struct channel_data *channel, int size);
  292. static int cosa_sppp_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
  293. static struct net_device_stats *cosa_net_stats(struct net_device *dev);
  295. /* Character device */
  296. static void chardev_channel_init(struct channel_data *chan);
  297. static char *chrdev_setup_rx(struct channel_data *channel, int size);
  298. static int chrdev_rx_done(struct channel_data *channel);
  299. static int chrdev_tx_done(struct channel_data *channel, int size);
  300. static ssize_t cosa_read(struct file *file,
  301. char *buf, size_t count, loff_t *ppos);
  302. static ssize_t cosa_write(struct file *file,
  303. const char *buf, size_t count, loff_t *ppos);
  304. static unsigned int cosa_poll(struct file *file, poll_table *poll);
  305. static int cosa_open(struct inode *inode, struct file *file);
  306. static int cosa_release(struct inode *inode, struct file *file);
  307. static int cosa_chardev_ioctl(struct inode *inode, struct file *file,
  308. unsigned int cmd, unsigned long arg);
  309. #ifdef COSA_FASYNC_WORKING
  310. static int cosa_fasync(struct inode *inode, struct file *file, int on);
  311. #endif
  313. static struct file_operations cosa_fops = {
  314. owner: THIS_MODULE,
  315. llseek: no_llseek,
  316. read: cosa_read,
  317. write: cosa_write,
  318. poll: cosa_poll,
  319. ioctl: cosa_chardev_ioctl,
  320. open: cosa_open,
  321. release: cosa_release,
  322. #ifdef COSA_FASYNC_WORKING
  323. fasync: cosa_fasync,
  324. #endif
  325. };
  327. /* Ioctls */
  328. static int cosa_start(struct cosa_data *cosa, int address);
  329. static int cosa_reset(struct cosa_data *cosa);
  330. static int cosa_download(struct cosa_data *cosa, struct cosa_download *d);
  331. static int cosa_readmem(struct cosa_data *cosa, struct cosa_download *d);
  333. /* COSA/SRP ROM monitor */
  334. static int download(struct cosa_data *cosa, char *data, int addr, int len);
  335. static int startmicrocode(struct cosa_data *cosa, int address);
  336. static int readmem(struct cosa_data *cosa, char *data, int addr, int len);
  337. static int cosa_reset_and_read_id(struct cosa_data *cosa, char *id);
  339. /* Auxilliary functions */
  340. static int get_wait_data(struct cosa_data *cosa);
  341. static int put_wait_data(struct cosa_data *cosa, int data);
  342. static int puthexnumber(struct cosa_data *cosa, int number);
  343. static void put_driver_status(struct cosa_data *cosa);
  344. static void put_driver_status_nolock(struct cosa_data *cosa);
  346. /* Interrupt handling */
  347. static void cosa_interrupt(int irq, void *cosa, struct pt_regs *regs);
  349. /* I/O ops debugging */
  350. #ifdef DEBUG_IO
  351. static void debug_data_in(struct cosa_data *cosa, int data);
  352. static void debug_data_out(struct cosa_data *cosa, int data);
  353. static void debug_data_cmd(struct cosa_data *cosa, int data);
  354. static void debug_status_in(struct cosa_data *cosa, int status);
  355. static void debug_status_out(struct cosa_data *cosa, int status);
  356. #endif
  359. /* ---------- Initialization stuff ---------- */
  361. static devfs_handle_t devfs_handle;
  363. #ifdef MODULE
  364. int init_module(void)
  365. #else
  366. static int __init cosa_init(void)
  367. #endif
  368. {
  369. int i;
  371. printk(KERN_INFO "cosa v1.08 (c) 1997-2000 Jan Kasprzak <kas@fi.muni.cz>n");
  372. #ifdef CONFIG_SMP
  373. printk(KERN_INFO "cosa: SMP found. Please mail any success/failure reports to the author.n");
  374. #endif
  375. if (cosa_major > 0) {
  376. if (devfs_register_chrdev(cosa_major, "cosa", &cosa_fops)) {
  377. printk(KERN_WARNING "cosa: unable to get major %dn",
  378. cosa_major);
  379. return -EIO;
  380. }
  381. } else {
  382. if (!(cosa_major=devfs_register_chrdev(0, "cosa", &cosa_fops))) {
  383. printk(KERN_WARNING "cosa: unable to register chardevn");
  384. return -EIO;
  385. }
  386. }
  387. for (i=0; i<MAX_CARDS; i++)
  388. cosa_cards[i].num = -1;
  389. for (i=0; io[i] != 0 && i < MAX_CARDS; i++)
  390. cosa_probe(io[i], irq[i], dma[i]);
  391. devfs_handle = devfs_mk_dir (NULL, "cosa", NULL);
  392. devfs_register_series (devfs_handle, "%u", nr_cards, DEVFS_FL_DEFAULT,
  393.        cosa_major, 0,
  394.        S_IFCHR | S_IRUSR | S_IWUSR,
  395.        &cosa_fops, NULL);
  396. if (!nr_cards) {
  397. printk(KERN_WARNING "cosa: no devices found.n");
  398. devfs_unregister_chrdev(cosa_major, "cosa");
  399. return -ENODEV;
  400. }
  401. return 0;
  402. }
  404. #ifdef MODULE
  405. void cleanup_module (void)
  406. {
  407. struct cosa_data *cosa;
  408. printk(KERN_INFO "Unloading the cosa modulen");
  410. devfs_unregister (devfs_handle);
  411. for (cosa=cosa_cards; nr_cards--; cosa++) {
  412. int i;
  413. /* Clean up the per-channel data */
  414. for (i=0; i<cosa->nchannels; i++) {
  415. /* Chardev driver has no alloc'd per-channel data */
  416. sppp_channel_delete(cosa->chan+i);
  417. }
  418. /* Clean up the per-card data */
  419. kfree(cosa->chan);
  420. kfree(cosa->bouncebuf);
  421. free_irq(cosa->irq, cosa);
  422. free_dma(cosa->dma);
  423. release_region(cosa->datareg,is_8bit(cosa)?2:4);
  424. }
  425. devfs_unregister_chrdev(cosa_major, "cosa");
  426. }
  427. #endif
  429. /*
  430.  * This function should register all the net devices needed for the
  431.  * single channel.
  432.  */
  433. static __inline__ void channel_init(struct channel_data *chan)
  434. {
  435. sprintf(chan->name, "cosa%dc%d", chan->cosa->num, chan->num);
  437. /* Initialize the chardev data structures */
  438. chardev_channel_init(chan);
  440. /* Register the sppp interface */
  441. sppp_channel_init(chan);
  442. }
  444. static int cosa_probe(int base, int irq, int dma)
  445. {
  446. struct cosa_data *cosa = cosa_cards+nr_cards;
  447. int i;
  449. memset(cosa, 0, sizeof(struct cosa_data));
  451. /* Checking validity of parameters: */
  452. /* IRQ should be 2-7 or 10-15; negative IRQ means autoprobe */
  453. if ((irq >= 0  && irq < 2) || irq > 15 || (irq < 10 && irq > 7)) {
  454. printk (KERN_INFO "cosa_probe: invalid IRQ %dn", irq);
  455. return -1;
  456. }
  457. /* I/O address should be between 0x100 and 0x3ff and should be
  458.  * multiple of 8. */
  459. if (base < 0x100 || base > 0x3ff || base & 0x7) {
  460. printk (KERN_INFO "cosa_probe: invalid I/O address 0x%xn",
  461. base);
  462. return -1;
  463. }
  464. /* DMA should be 0,1 or 3-7 */
  465. if (dma < 0 || dma == 4 || dma > 7) {
  466. printk (KERN_INFO "cosa_probe: invalid DMA %dn", dma);
  467. return -1;
  468. }
  469. /* and finally, on 16-bit COSA DMA should be 4-7 and 
  470.  * I/O base should not be multiple of 0x10 */
  471. if (((base & 0x8) && dma < 4) || (!(base & 0x8) && dma > 3)) {
  472. printk (KERN_INFO "cosa_probe: 8/16 bit base and DMA mismatch"
  473. " (base=0x%x, dma=%d)n", base, dma);
  474. return -1;
  475. }
  477. cosa->dma = dma;
  478. cosa->datareg = base;
  479. cosa->statusreg = is_8bit(cosa)?base+1:base+2;
  480. spin_lock_init(&cosa->lock);
  482. if (check_region(base, is_8bit(cosa)?2:4))
  483. return -1;
  485. if (cosa_reset_and_read_id(cosa, cosa->id_string) < 0) {
  486. printk(KERN_DEBUG "cosa: probe at 0x%x failed.n", base);
  487. return -1;
  488. }
  490. /* Test the validity of identification string */
  491. if (!strncmp(cosa->id_string, "SRP", 3))
  492. cosa->type = "srp";
  493. else if (!strncmp(cosa->id_string, "COSA", 4))
  494. cosa->type = is_8bit(cosa)? "cosa8": "cosa16";
  495. else {
  496. /* Print a warning only if we are not autoprobing */
  497. #ifndef COSA_ISA_AUTOPROBE
  498. printk(KERN_INFO "cosa: valid signature not found at 0x%x.n",
  499. base);
  500. #endif
  501. return -1;
  502. }
  504. /* Now do IRQ autoprobe */
  505. if (irq < 0) {
  506. unsigned long irqs;
  507. /* printk(KERN_INFO "IRQ autoproben"); */
  508. sti();
  509. irqs = probe_irq_on();
  510. /* 
  511.  * Enable interrupt on tx buffer empty (it sure is) 
  512.  * really sure ?
  513.  * FIXME: When this code is not used as module, we should
  514.  * probably call udelay() instead of the interruptible sleep.
  515.  */
  516. current->state = TASK_INTERRUPTIBLE;
  517. cosa_putstatus(cosa, SR_TX_INT_ENA);
  518. schedule_timeout(30);
  519. current->state = TASK_RUNNING;
  520. irq = probe_irq_off(irqs);
  521. /* Disable all IRQs from the card */
  522. cosa_putstatus(cosa, 0);
  523. /* Empty the received data register */
  524. cosa_getdata8(cosa);
  526. if (irq < 0) {
  527. printk (KERN_INFO "cosa IRQ autoprobe: multiple interrupts obtained (%d, board at 0x%x)n",
  528. irq, cosa->datareg);
  529. return -1;
  530. }
  531. if (irq == 0) {
  532. printk (KERN_INFO "cosa IRQ autoprobe: no interrupt obtained (board at 0x%x)n",
  533. cosa->datareg);
  534. /* return -1; */
  535. }
  536. }
  538. cosa->irq = irq;
  539. cosa->num = nr_cards;
  540. cosa->usage = 0;
  541. cosa->nchannels = 2; /* FIXME: how to determine this? */
  543. request_region(base, is_8bit(cosa)?2:4, cosa->type);
  544. if (request_irq(cosa->irq, cosa_interrupt, 0, cosa->type, cosa))
  545. goto bad1;
  546. if (request_dma(cosa->dma, cosa->type)) {
  547. free_irq(cosa->irq, cosa);
  548. bad1: release_region(cosa->datareg,is_8bit(cosa)?2:4);
  549. printk(KERN_NOTICE "cosa%d: allocating resources failedn",
  550. cosa->num);
  551. return -1;
  552. }
  554. cosa->bouncebuf = kmalloc(COSA_MTU, GFP_KERNEL|GFP_DMA);
  555. sprintf(cosa->name, "cosa%d", cosa->num);
  557. /* Initialize the per-channel data */
  558. cosa->chan = kmalloc(sizeof(struct channel_data)*cosa->nchannels,
  559. GFP_KERNEL);
  560. memset(cosa->chan, 0, sizeof(struct channel_data)*cosa->nchannels);
  561. for (i=0; i<cosa->nchannels; i++) {
  562. cosa->chan[i].cosa = cosa;
  563. cosa->chan[i].num = i;
  564. channel_init(cosa->chan+i);
  565. }
  567. printk (KERN_INFO "cosa%d: %s (%s at 0x%x irq %d dma %d), %d channelsn",
  568. cosa->num, cosa->id_string, cosa->type,
  569. cosa->datareg, cosa->irq, cosa->dma, cosa->nchannels);
  571. return nr_cards++;
  572. }
  575. /*---------- SPPP/HDLC netdevice ---------- */
  577. static void sppp_channel_init(struct channel_data *chan)
  578. {
  579. struct net_device *d;
  580. chan->if_ptr = &chan->pppdev;
  581. chan->pppdev.dev = kmalloc(sizeof(struct net_device), GFP_KERNEL);
  582. memset(chan->pppdev.dev, 0, sizeof(struct net_device));
  583. sppp_attach(&chan->pppdev);
  584. d=chan->pppdev.dev;
  585. strcpy(d->name, chan->name);
  586. d->base_addr = chan->cosa->datareg;
  587. d->irq = chan->cosa->irq;
  588. d->dma = chan->cosa->dma;
  589. d->priv = chan;
  590. d->init = NULL;
  591. d->open = cosa_sppp_open;
  592. d->stop = cosa_sppp_close;
  593. d->hard_start_xmit = cosa_sppp_tx;
  594. d->do_ioctl = cosa_sppp_ioctl;
  595. d->get_stats = cosa_net_stats;
  596. d->tx_timeout = cosa_sppp_timeout;
  597. d->watchdog_timeo = TX_TIMEOUT;
  598. if (register_netdev(d) == -1) {
  599. printk(KERN_WARNING "%s: register_netdev failed.n", d->name);
  600. sppp_detach(chan->pppdev.dev);
  601. return;
  602. }
  603. }
  605. static void sppp_channel_delete(struct channel_data *chan)
  606. {
  607. sppp_detach(chan->pppdev.dev);
  608. unregister_netdev(chan->pppdev.dev);
  609. }
  611. static int cosa_sppp_open(struct net_device *d)
  612. {
  613. struct channel_data *chan = d->priv;
  614. int err;
  615. unsigned long flags;
  617. if (!(chan->cosa->firmware_status & COSA_FW_START)) {
  618. printk(KERN_NOTICE "%s: start the firmware first (status %d)n",
  619. chan->cosa->name, chan->cosa->firmware_status);
  620. return -EPERM;
  621. }
  622. spin_lock_irqsave(&chan->cosa->lock, flags);
  623. if (chan->usage != 0) {
  624. printk(KERN_WARNING "%s: sppp_open called with usage count %dn",
  625. chan->name, chan->usage);
  626. spin_unlock_irqrestore(&chan->cosa->lock, flags);
  627. return -EBUSY;
  628. }
  629. chan->setup_rx = sppp_setup_rx;
  630. chan->tx_done = sppp_tx_done;
  631. chan->rx_done = sppp_rx_done;
  632. chan->usage=-1;
  633. chan->cosa->usage++;
  634. MOD_INC_USE_COUNT;
  635. spin_unlock_irqrestore(&chan->cosa->lock, flags);
  637. err = sppp_open(d);
  638. if (err) {
  639. spin_lock_irqsave(&chan->cosa->lock, flags);
  640. chan->usage=0;
  641. chan->cosa->usage--;
  642. MOD_DEC_USE_COUNT;
  644. spin_unlock_irqrestore(&chan->cosa->lock, flags);
  645. return err;
  646. }
  648. netif_start_queue(d);
  649. cosa_enable_rx(chan);
  650. return 0;
  651. }
  653. static int cosa_sppp_tx(struct sk_buff *skb, struct net_device *dev)
  654. {
  655. struct channel_data *chan = dev->priv;
  657. netif_stop_queue(dev);
  659. chan->tx_skb = skb;
  660. cosa_start_tx(chan, skb->data, skb->len);
  661. return 0;
  662. }
  664. static void cosa_sppp_timeout(struct net_device *dev)
  665. {
  666. struct channel_data *chan = dev->priv;
  668. if (test_bit(RXBIT, &chan->cosa->rxtx)) {
  669. chan->stats.rx_errors++;
  670. chan->stats.rx_missed_errors++;
  671. } else {
  672. chan->stats.tx_errors++;
  673. chan->stats.tx_aborted_errors++;
  674. }
  675. cosa_kick(chan->cosa);
  676. if (chan->tx_skb) {
  677. dev_kfree_skb(chan->tx_skb);
  678. chan->tx_skb = 0;
  679. }
  680. netif_wake_queue(dev);
  681. }
  683. static int cosa_sppp_close(struct net_device *d)
  684. {
  685. struct channel_data *chan = d->priv;
  686. unsigned long flags;
  688. netif_stop_queue(d);
  689. sppp_close(d);
  690. cosa_disable_rx(chan);
  691. spin_lock_irqsave(&chan->cosa->lock, flags);
  692. if (chan->rx_skb) {
  693. kfree_skb(chan->rx_skb);
  694. chan->rx_skb = 0;
  695. }
  696. if (chan->tx_skb) {
  697. kfree_skb(chan->tx_skb);
  698. chan->tx_skb = 0;
  699. }
  700. chan->usage=0;
  701. chan->cosa->usage--;
  702. MOD_DEC_USE_COUNT;
  703. spin_unlock_irqrestore(&chan->cosa->lock, flags);
  704. return 0;
  705. }
  707. static char *sppp_setup_rx(struct channel_data *chan, int size)
  708. {
  709. /*
  710.  * We can safely fall back to non-dma-able memory, because we have
  711.  * the cosa->bouncebuf pre-allocated.
  712.  */
  713. if (chan->rx_skb)
  714. kfree_skb(chan->rx_skb);
  715. chan->rx_skb = dev_alloc_skb(size);
  716. if (chan->rx_skb == NULL) {
  717. printk(KERN_NOTICE "%s: Memory squeeze, dropping packetn",
  718. chan->name);
  719. chan->stats.rx_dropped++;
  720. return NULL;
  721. }
  722. chan->pppdev.dev->trans_start = jiffies;
  723. return skb_put(chan->rx_skb, size);
  724. }
  726. static int sppp_rx_done(struct channel_data *chan)
  727. {
  728. if (!chan->rx_skb) {
  729. printk(KERN_WARNING "%s: rx_done with empty skb!n",
  730. chan->name);
  731. chan->stats.rx_errors++;
  732. chan->stats.rx_frame_errors++;
  733. return 0;
  734. }
  735. chan->rx_skb->protocol = htons(ETH_P_WAN_PPP);
  736. chan->rx_skb->dev = chan->pppdev.dev;
  737. chan->rx_skb->mac.raw = chan->rx_skb->data;
  738. chan->stats.rx_packets++;
  739. chan->stats.rx_bytes += chan->cosa->rxsize;
  740. netif_rx(chan->rx_skb);
  741. chan->rx_skb = 0;
  742. chan->pppdev.dev->last_rx = jiffies;
  743. return 0;
  744. }
  746. /* ARGSUSED */
  747. static int sppp_tx_done(struct channel_data *chan, int size)
  748. {
  749. if (!chan->tx_skb) {
  750. printk(KERN_WARNING "%s: tx_done with empty skb!n",
  751. chan->name);
  752. chan->stats.tx_errors++;
  753. chan->stats.tx_aborted_errors++;
  754. return 1;
  755. }
  756. dev_kfree_skb_irq(chan->tx_skb);
  757. chan->tx_skb = 0;
  758. chan->stats.tx_packets++;
  759. chan->stats.tx_bytes += size;
  760. netif_wake_queue(chan->pppdev.dev);
  761. return 1;
  762. }
  764. static struct net_device_stats *cosa_net_stats(struct net_device *dev)
  765. {
  766. struct channel_data *chan = dev->priv;
  767. return &chan->stats;
  768. }
  771. /*---------- Character device ---------- */
  773. static void chardev_channel_init(struct channel_data *chan)
  774. {
  775. init_MUTEX(&chan->rsem);
  776. init_MUTEX(&chan->wsem);
  777. }
  779. static ssize_t cosa_read(struct file *file,
  780. char *buf, size_t count, loff_t *ppos)
  781. {
  782. DECLARE_WAITQUEUE(wait, current);
  783. unsigned long flags;
  784. struct channel_data *chan = (struct channel_data *)file->private_data;
  785. struct cosa_data *cosa = chan->cosa;
  786. char *kbuf;
  788. if (!(cosa->firmware_status & COSA_FW_START)) {
  789. printk(KERN_NOTICE "%s: start the firmware first (status %d)n",
  790. cosa->name, cosa->firmware_status);
  791. return -EPERM;
  792. }
  793. if (down_interruptible(&chan->rsem))
  794. return -ERESTARTSYS;
  796. if ((chan->rxdata = kmalloc(COSA_MTU, GFP_DMA|GFP_KERNEL)) == NULL) {
  797. printk(KERN_INFO "%s: cosa_read() - OOMn", cosa->name);
  798. up(&chan->rsem);
  799. return -ENOMEM;
  800. }
  802. chan->rx_status = 0;
  803. cosa_enable_rx(chan);
  804. spin_lock_irqsave(&cosa->lock, flags);
  805. add_wait_queue(&chan->rxwaitq, &wait);
  806. while(!chan->rx_status) {
  807. current->state = TASK_INTERRUPTIBLE;
  808. spin_unlock_irqrestore(&cosa->lock, flags);
  809. schedule();
  810. spin_lock_irqsave(&cosa->lock, flags);
  811. if (signal_pending(current) && chan->rx_status == 0) {
  812. chan->rx_status = 1;
  813. remove_wait_queue(&chan->rxwaitq, &wait);
  814. current->state = TASK_RUNNING;
  815. spin_unlock_irqrestore(&cosa->lock, flags);
  816. up(&chan->rsem);
  817. return -ERESTARTSYS;
  818. }
  819. }
  820. remove_wait_queue(&chan->rxwaitq, &wait);
  821. current->state = TASK_RUNNING;
  822. kbuf = chan->rxdata;
  823. count = chan->rxsize;
  824. spin_unlock_irqrestore(&cosa->lock, flags);
  825. up(&chan->rsem);
  827. if (copy_to_user(buf, kbuf, count)) {
  828. kfree(kbuf);
  829. return -EFAULT;
  830. }
  831. kfree(kbuf);
  832. return count;
  833. }
  835. static char *chrdev_setup_rx(struct channel_data *chan, int size)
  836. {
  837. /* Expect size <= COSA_MTU */
  838. chan->rxsize = size;
  839. return chan->rxdata;
  840. }
  842. static int chrdev_rx_done(struct channel_data *chan)
  843. {
  844. if (chan->rx_status) { /* Reader has died */
  845. kfree(chan->rxdata);
  846. up(&chan->wsem);
  847. }
  848. chan->rx_status = 1;
  849. wake_up_interruptible(&chan->rxwaitq);
  850. return 1;
  851. }
  854. static ssize_t cosa_write(struct file *file,
  855. const char *buf, size_t count, loff_t *ppos)
  856. {
  857. DECLARE_WAITQUEUE(wait, current);
  858. struct channel_data *chan = (struct channel_data *)file->private_data;
  859. struct cosa_data *cosa = chan->cosa;
  860. unsigned long flags;
  861. char *kbuf;
  863. if (!(cosa->firmware_status & COSA_FW_START)) {
  864. printk(KERN_NOTICE "%s: start the firmware first (status %d)n",
  865. cosa->name, cosa->firmware_status);
  866. return -EPERM;
  867. }
  868. if (down_interruptible(&chan->wsem))
  869. return -ERESTARTSYS;
  871. if (count > COSA_MTU)
  872. count = COSA_MTU;
  874. /* Allocate the buffer */
  875. if ((kbuf = kmalloc(count, GFP_KERNEL|GFP_DMA)) == NULL) {
  876. printk(KERN_NOTICE "%s: cosa_write() OOM - dropping packetn",
  877. cosa->name);
  878. up(&chan->wsem);
  879. return -ENOMEM;
  880. }
  881. if (copy_from_user(kbuf, buf, count)) {
  882. up(&chan->wsem);
  883. kfree(kbuf);
  884. return -EFAULT;
  885. }
  886. chan->tx_status=0;
  887. cosa_start_tx(chan, kbuf, count);
  889. spin_lock_irqsave(&cosa->lock, flags);
  890. add_wait_queue(&chan->txwaitq, &wait);
  891. while(!chan->tx_status) {
  892. current->state = TASK_INTERRUPTIBLE;
  893. spin_unlock_irqrestore(&cosa->lock, flags);
  894. schedule();
  895. spin_lock_irqsave(&cosa->lock, flags);
  896. if (signal_pending(current) && chan->tx_status == 0) {
  897. chan->tx_status = 1;
  898. remove_wait_queue(&chan->txwaitq, &wait);
  899. current->state = TASK_RUNNING;
  900. chan->tx_status = 1;
  901. spin_unlock_irqrestore(&cosa->lock, flags);
  902. return -ERESTARTSYS;
  903. }
  904. }
  905. remove_wait_queue(&chan->txwaitq, &wait);
  906. current->state = TASK_RUNNING;
  907. up(&chan->wsem);
  908. spin_unlock_irqrestore(&cosa->lock, flags);
  909. kfree(kbuf);
  910. return count;
  911. }
  913. static int chrdev_tx_done(struct channel_data *chan, int size)
  914. {
  915. if (chan->tx_status) { /* Writer was interrupted */
  916. kfree(chan->txbuf);
  917. up(&chan->wsem);
  918. }
  919. chan->tx_status = 1;
  920. wake_up_interruptible(&chan->txwaitq);
  921. return 1;
  922. }
  924. static unsigned int cosa_poll(struct file *file, poll_table *poll)
  925. {
  926. printk(KERN_INFO "cosa_poll is heren");
  927. return 0;
  928. }
  930. static int cosa_open(struct inode *inode, struct file *file)
  931. {
  932. struct cosa_data *cosa;
  933. struct channel_data *chan;
  934. unsigned long flags;
  935. int n;
  937. if ((n=MINOR(file->f_dentry->d_inode->i_rdev)>>CARD_MINOR_BITS)
  938. >= nr_cards)
  939. return -ENODEV;
  940. cosa = cosa_cards+n;
  942. if ((n=MINOR(file->f_dentry->d_inode->i_rdev)
  943. & ((1<<CARD_MINOR_BITS)-1)) >= cosa->nchannels)
  944. return -ENODEV;
  945. chan = cosa->chan + n;
  947. file->private_data = chan;
  949. spin_lock_irqsave(&cosa->lock, flags);
  951. if (chan->usage < 0) { /* in netdev mode */
  952. spin_unlock_irqrestore(&cosa->lock, flags);
  953. return -EBUSY;
  954. }
  955. cosa->usage++;
  956. chan->usage++;
  958. chan->tx_done = chrdev_tx_done;
  959. chan->setup_rx = chrdev_setup_rx;
  960. chan->rx_done = chrdev_rx_done;
  961. spin_unlock_irqrestore(&cosa->lock, flags);
  962. return 0;
  963. }
  965. static int cosa_release(struct inode *inode, struct file *file)
  966. {
  967. struct channel_data *channel = (struct channel_data *)file->private_data;
  968. struct cosa_data *cosa;
  969. unsigned long flags;
  971. lock_kernel();
  972. cosa = channel->cosa;
  973. spin_lock_irqsave(&cosa->lock, flags);
  974. cosa->usage--;
  975. channel->usage--;
  976. spin_unlock_irqrestore(&cosa->lock, flags);
  977. unlock_kernel();
  978. return 0;
  979. }
  981. #ifdef COSA_FASYNC_WORKING
  982. static struct fasync_struct *fasync[256] = { NULL, };
  984. /* To be done ... */
  985. static int cosa_fasync(struct inode *inode, struct file *file, int on)
  986. {
  987.         int port = MINOR(inode->i_rdev);
  988.         int rv = fasync_helper(inode, file, on, &fasync[port]);
  989.         return rv < 0 ? rv : 0;
  990. }
  991. #endif
  994. /* ---------- Ioctls ---------- */
  996. /*
  997.  * Ioctl subroutines can safely be made inline, because they are called
  998.  * only from cosa_ioctl().
  999.  */
  1000. static inline int cosa_reset(struct cosa_data *cosa)
  1001. {
  1002. char idstring[COSA_MAX_ID_STRING];
  1003. if (cosa->usage > 1)
  1004. printk(KERN_INFO "cosa%d: WARNING: reset requested with cosa->usage > 1 (%d). Odd things may happen.n",
  1005. cosa->num, cosa->usage);
  1006. cosa->firmware_status &= ~(COSA_FW_RESET|COSA_FW_START);
  1007. if (cosa_reset_and_read_id(cosa, idstring) < 0) {
  1008. printk(KERN_NOTICE "cosa%d: reset failedn", cosa->num);
  1009. return -EIO;
  1010. }
  1011. printk(KERN_INFO "cosa%d: resetting device: %sn", cosa->num,
  1012. idstring);
  1013. cosa->firmware_status |= COSA_FW_RESET;
  1014. return 0;
  1015. }
  1017. /* High-level function to download data into COSA memory. Calls download() */
  1018. static inline int cosa_download(struct cosa_data *cosa, struct cosa_download *d)
  1019. {
  1020. int i;
  1021. int addr, len;
  1022. char *code;
  1024. if (cosa->usage > 1)
  1025. printk(KERN_INFO "%s: WARNING: download of microcode requested with cosa->usage > 1 (%d). Odd things may happen.n",
  1026. cosa->name, cosa->usage);
  1027. if (!(cosa->firmware_status & COSA_FW_RESET)) {
  1028. printk(KERN_NOTICE "%s: reset the card first (status %d).n",
  1029. cosa->name, cosa->firmware_status);
  1030. return -EPERM;
  1031. }
  1033. if (get_user(addr, &(d->addr)) ||
  1034.     __get_user(len, &(d->len)) ||
  1035.     __get_user(code, &(d->code)))
  1036. return -EFAULT;
  1038. if (addr < 0 || addr > COSA_MAX_FIRMWARE_SIZE)
  1039. return -EINVAL;
  1040. if (len < 0 || len > COSA_MAX_FIRMWARE_SIZE)
  1041. return -EINVAL;
  1043. /* If something fails, force the user to reset the card */
  1044. cosa->firmware_status &= ~(COSA_FW_RESET|COSA_FW_DOWNLOAD);
  1046. if ((i=download(cosa, code, len, addr)) < 0) {
  1047. printk(KERN_NOTICE "cosa%d: microcode download failed: %dn",
  1048. cosa->num, i);
  1049. return -EIO;
  1050. }
  1051. printk(KERN_INFO "cosa%d: downloading microcode - 0x%04x bytes at 0x%04xn",
  1052. cosa->num, len, addr);
  1053. cosa->firmware_status |= COSA_FW_RESET|COSA_FW_DOWNLOAD;
  1054. return 0;
  1055. }
  1057. /* High-level function to read COSA memory. Calls readmem() */
  1058. static inline int cosa_readmem(struct cosa_data *cosa, struct cosa_download *d)
  1059. {
  1060. int i;
  1061. int addr, len;
  1062. char *code;
  1064. if (cosa->usage > 1)
  1065. printk(KERN_INFO "cosa%d: WARNING: readmem requested with "
  1066. "cosa->usage > 1 (%d). Odd things may happen.n",
  1067. cosa->num, cosa->usage);
  1068. if (!(cosa->firmware_status & COSA_FW_RESET)) {
  1069. printk(KERN_NOTICE "%s: reset the card first (status %d).n",
  1070. cosa->name, cosa->firmware_status);
  1071. return -EPERM;
  1072. }
  1074. if (get_user(addr, &(d->addr)) ||
  1075.     __get_user(len, &(d->len)) ||
  1076.     __get_user(code, &(d->code)))
  1077. return -EFAULT;
  1079. /* If something fails, force the user to reset the card */
  1080. cosa->firmware_status &= ~COSA_FW_RESET;
  1082. if ((i=readmem(cosa, d->code, len, addr)) < 0) {
  1083. printk(KERN_NOTICE "cosa%d: reading memory failed: %dn",
  1084. cosa->num, i);
  1085. return -EIO;
  1086. }
  1087. printk(KERN_INFO "cosa%d: reading card memory - 0x%04x bytes at 0x%04xn",
  1088. cosa->num, len, addr);
  1089. cosa->firmware_status |= COSA_FW_RESET;
  1090. return 0;
  1091. }
  1093. /* High-level function to start microcode. Calls startmicrocode(). */
  1094. static inline int cosa_start(struct cosa_data *cosa, int address)
  1095. {
  1096. int i;
  1098. if (cosa->usage > 1)
  1099. printk(KERN_INFO "cosa%d: WARNING: start microcode requested with cosa->usage > 1 (%d). Odd things may happen.n",
  1100. cosa->num, cosa->usage);
  1102. if ((cosa->firmware_status & (COSA_FW_RESET|COSA_FW_DOWNLOAD))
  1103. != (COSA_FW_RESET|COSA_FW_DOWNLOAD)) {
  1104. printk(KERN_NOTICE "%s: download the microcode and/or reset the card first (status %d).n",
  1105. cosa->name, cosa->firmware_status);
  1106. return -EPERM;
  1107. }
  1108. cosa->firmware_status &= ~COSA_FW_RESET;
  1109. if ((i=startmicrocode(cosa, address)) < 0) {
  1110. printk(KERN_NOTICE "cosa%d: start microcode at 0x%04x failed: %dn",
  1111. cosa->num, address, i);
  1112. return -EIO;
  1113. }
  1114. printk(KERN_INFO "cosa%d: starting microcode at 0x%04xn",
  1115. cosa->num, address);
  1116. cosa->startaddr = address;
  1117. cosa->firmware_status |= COSA_FW_START;
  1118. return 0;
  1119. }
  1121. /* Buffer of size at least COSA_MAX_ID_STRING is expected */
  1122. static inline int cosa_getidstr(struct cosa_data *cosa, char *string)
  1123. {
  1124. int l = strlen(cosa->id_string)+1;
  1125. if (copy_to_user(string, cosa->id_string, l))
  1126. return -EFAULT;
  1127. return l;
  1128. }
  1130. /* Buffer of size at least COSA_MAX_ID_STRING is expected */
  1131. static inline int cosa_gettype(struct cosa_data *cosa, char *string)
  1132. {
  1133. int l = strlen(cosa->type)+1;
  1134. if (copy_to_user(string, cosa->type, l))
  1135. return -EFAULT;
  1136. return l;
  1137. }
  1139. static int cosa_ioctl_common(struct cosa_data *cosa,
  1140. struct channel_data *channel, unsigned int cmd, unsigned long arg)
  1141. {
  1142. switch(cmd) {
  1143. case COSAIORSET: /* Reset the device */
  1144. if (!capable(CAP_NET_ADMIN))
  1145. return -EACCES;
  1146. return cosa_reset(cosa);
  1147. case COSAIOSTRT: /* Start the firmware */
  1148. if (!capable(CAP_SYS_RAWIO))
  1149. return -EACCES;
  1150. return cosa_start(cosa, arg);
  1151. case COSAIODOWNLD: /* Download the firmware */
  1152. if (!capable(CAP_SYS_RAWIO))
  1153. return -EACCES;
  1154. return cosa_download(cosa, (struct cosa_download *)arg);
  1155. case COSAIORMEM:
  1156. if (!capable(CAP_SYS_RAWIO))
  1157. return -EACCES;
  1158. return cosa_readmem(cosa, (struct cosa_download *)arg);
  1159. case COSAIORTYPE:
  1160. return cosa_gettype(cosa, (char *)arg);
  1161. case COSAIORIDSTR:
  1162. return cosa_getidstr(cosa, (char *)arg);
  1163. /*
  1164.  * These two are _very_ugly_hack_(tm). Don't even look at this.
  1165.  * Implementing this saved me few reboots after some process segfaulted
  1166.  * inside this module.
  1167.  */
  1168. #ifdef MODULE
  1169. #if 0
  1170. case COSAIOMINC:
  1171. MOD_INC_USE_COUNT;
  1172. return 0;
  1173. case COSAIOMDEC:
  1174. MOD_DEC_USE_COUNT;
  1175. return 0;
  1176. #endif
  1177. #endif
  1178. case COSAIONRCARDS:
  1179. return nr_cards;
  1180. case COSAIONRCHANS:
  1181. return cosa->nchannels;
  1182. case COSAIOBMSET:
  1183. if (!capable(CAP_SYS_RAWIO))
  1184. return -EACCES;
  1185. if (is_8bit(cosa))
  1186. return -EINVAL;
  1187. if (arg != COSA_BM_OFF && arg != COSA_BM_ON)
  1188. return -EINVAL;
  1189. cosa->busmaster = arg;
  1190. return 0;
  1191. case COSAIOBMGET:
  1192. return cosa->busmaster;
  1193. }
  1194. return -ENOIOCTLCMD;
  1195. }
  1197. static int cosa_sppp_ioctl(struct net_device *dev, struct ifreq *ifr,
  1198. int cmd)
  1199. {
  1200. int rv;
  1201. struct channel_data *chan = (struct channel_data *)dev->priv;
  1202. rv = cosa_ioctl_common(chan->cosa, chan, cmd, (unsigned long)ifr->ifr_data);
  1203. if (rv == -ENOIOCTLCMD) {
  1204. return sppp_do_ioctl(dev, ifr, cmd);
  1205. }
  1206. return rv;
  1207. }
  1209. static int cosa_chardev_ioctl(struct inode *inode, struct file *file,
  1210. unsigned int cmd, unsigned long arg)
  1211. {
  1212. struct channel_data *channel = (struct channel_data *)file->private_data;
  1213. struct cosa_data *cosa = channel->cosa;
  1214. return cosa_ioctl_common(cosa, channel, cmd, arg);
  1215. }
  1218. /*---------- HW layer interface ---------- */
  1220. /*
  1221.  * The higher layer can bind itself to the HW layer by setting the callbacks
  1222.  * in the channel_data structure and by using these routines.
  1223.  */
  1224. static void cosa_enable_rx(struct channel_data *chan)
  1225. {
  1226. struct cosa_data *cosa = chan->cosa;
  1228. if (!test_and_set_bit(chan->num, &cosa->rxbitmap))
  1229. put_driver_status(cosa);
  1230. }
  1232. static void cosa_disable_rx(struct channel_data *chan)
  1233. {
  1234. struct cosa_data *cosa = chan->cosa;
  1236. if (test_and_clear_bit(chan->num, &cosa->rxbitmap))
  1237. put_driver_status(cosa);
  1238. }
  1240. /*
  1241.  * FIXME: This routine probably should check for cosa_start_tx() called when
  1242.  * the previous transmit is still unfinished. In this case the non-zero
  1243.  * return value should indicate to the caller that the queuing(sp?) up
  1244.  * the transmit has failed.
  1245.  */
  1246. static int cosa_start_tx(struct channel_data *chan, char *buf, int len)
  1247. {
  1248. struct cosa_data *cosa = chan->cosa;
  1249. unsigned long flags;
  1250. #ifdef DEBUG_DATA
  1251. int i;
  1253. printk(KERN_INFO "cosa%dc%d: starting tx(0x%x)", chan->cosa->num,
  1254. chan->num, len);
  1255. for (i=0; i<len; i++)
  1256. printk(" %02x", buf[i]&0xff);
  1257. printk("n");
  1258. #endif
  1259. spin_lock_irqsave(&cosa->lock, flags);
  1260. chan->txbuf = buf;
  1261. chan->txsize = len;
  1262. if (len > COSA_MTU)
  1263. chan->txsize = COSA_MTU;
  1264. spin_unlock_irqrestore(&cosa->lock, flags);
  1266. /* Tell the firmware we are ready */
  1267. set_bit(chan->num, &cosa->txbitmap);
  1268. put_driver_status(cosa);
  1270. return 0;
  1271. }
  1273. static void put_driver_status(struct cosa_data *cosa)
  1274. {
  1275. unsigned long flags;
  1276. int status;
  1278. spin_lock_irqsave(&cosa->lock, flags);
  1280. status = (cosa->rxbitmap ? DRIVER_RX_READY : 0)
  1281. | (cosa->txbitmap ? DRIVER_TX_READY : 0)
  1282. | (cosa->txbitmap? ~(cosa->txbitmap<<DRIVER_TXMAP_SHIFT)
  1283. &DRIVER_TXMAP_MASK : 0);
  1284. if (!cosa->rxtx) {
  1285. if (cosa->rxbitmap|cosa->txbitmap) {
  1286. if (!cosa->enabled) {
  1287. cosa_putstatus(cosa, SR_RX_INT_ENA);
  1288. #ifdef DEBUG_IO
  1289. debug_status_out(cosa, SR_RX_INT_ENA);
  1290. #endif
  1291. cosa->enabled = 1;
  1292. }
  1293. } else if (cosa->enabled) {
  1294. cosa->enabled = 0;
  1295. cosa_putstatus(cosa, 0);
  1296. #ifdef DEBUG_IO
  1297. debug_status_out(cosa, 0);
  1298. #endif
  1299. }
  1300. cosa_putdata8(cosa, status);
  1301. #ifdef DEBUG_IO
  1302. debug_data_cmd(cosa, status);
  1303. #endif
  1304. }
  1305. spin_unlock_irqrestore(&cosa->lock, flags);
  1306. }
  1308. static void put_driver_status_nolock(struct cosa_data *cosa)
  1309. {
  1310. int status;
  1312. status = (cosa->rxbitmap ? DRIVER_RX_READY : 0)
  1313. | (cosa->txbitmap ? DRIVER_TX_READY : 0)
  1314. | (cosa->txbitmap? ~(cosa->txbitmap<<DRIVER_TXMAP_SHIFT)
  1315. &DRIVER_TXMAP_MASK : 0);
  1317. if (cosa->rxbitmap|cosa->txbitmap) {
  1318. cosa_putstatus(cosa, SR_RX_INT_ENA);
  1319. #ifdef DEBUG_IO
  1320. debug_status_out(cosa, SR_RX_INT_ENA);
  1321. #endif
  1322. cosa->enabled = 1;
  1323. } else {
  1324. cosa_putstatus(cosa, 0);
  1325. #ifdef DEBUG_IO
  1326. debug_status_out(cosa, 0);
  1327. #endif
  1328. cosa->enabled = 0;
  1329. }
  1330. cosa_putdata8(cosa, status);
  1331. #ifdef DEBUG_IO
  1332. debug_data_cmd(cosa, status);
  1333. #endif
  1334. }
  1336. /*
  1337.  * The "kickme" function: When the DMA times out, this is called to
  1338.  * clean up the driver status.
  1339.  * FIXME: Preliminary support, the interface is probably wrong.
  1340.  */
  1341. static void cosa_kick(struct cosa_data *cosa)
  1342. {
  1343. unsigned long flags, flags1;
  1344. char *s = "(probably) IRQ";
  1346. if (test_bit(RXBIT, &cosa->rxtx))
  1347. s = "RX DMA";
  1348. if (test_bit(TXBIT, &cosa->rxtx))
  1349. s = "TX DMA";
  1351. printk(KERN_INFO "%s: %s timeout - restarting.n", cosa->name, s); 
  1352. spin_lock_irqsave(&cosa->lock, flags);
  1353. cosa->rxtx = 0;
  1355. flags1 = claim_dma_lock();
  1356. disable_dma(cosa->dma);
  1357. clear_dma_ff(cosa->dma);
  1358. release_dma_lock(flags1);
  1360. /* FIXME: Anything else? */
  1361. udelay(100);
  1362. cosa_putstatus(cosa, 0);
  1363. udelay(100);
  1364. (void) cosa_getdata8(cosa);
  1365. udelay(100);
  1366. cosa_putdata8(cosa, 0);
  1367. udelay(100);
  1368. put_driver_status_nolock(cosa);
  1369. spin_unlock_irqrestore(&cosa->lock, flags);
  1370. }
  1372. /*
  1373.  * Check if the whole buffer is DMA-able. It means it is below the 16M of
  1374.  * physical memory and doesn't span the 64k boundary. For now it seems
  1375.  * SKB's never do this, but we'll check this anyway.
  1376.  */
  1377. static int cosa_dma_able(struct channel_data *chan, char *buf, int len)
  1378. {
  1379. static int count;
  1380. unsigned long b = (unsigned long)buf;
  1381. if (b+len >= MAX_DMA_ADDRESS)
  1382. return 0;
  1383. if ((b^ (b+len)) & 0x10000) {
  1384. if (count++ < 5)
  1385. printk(KERN_INFO "%s: packet spanning a 64k boundaryn",
  1386. chan->name);
  1387. return 0;
  1388. }
  1389. return 1;
  1390. }
  1393. /* ---------- The SRP/COSA ROM monitor functions ---------- */
  1395. /*
  1396.  * Downloading SRP microcode: say "w" to SRP monitor, it answers by "w=",
  1397.  * drivers need to say 4-digit hex number meaning start address of the microcode
  1398.  * separated by a single space. Monitor replies by saying " =". Now driver
  1399.  * has to write 4-digit hex number meaning the last byte address ended
  1400.  * by a single space. Monitor has to reply with a space. Now the download
  1401.  * begins. After the download monitor replies with "rn." (CR LF dot).
  1402.  */
  1403. static int download(struct cosa_data *cosa, char *microcode, int length, int address)
  1404. {
  1405. int i;
  1407. if (put_wait_data(cosa, 'w') == -1) return -1;
  1408. if ((i=get_wait_data(cosa)) != 'w') { printk("dnld: 0x%04xn",i); return -2;}
  1409. if (get_wait_data(cosa) != '=') return -3;
  1411. if (puthexnumber(cosa, address) < 0) return -4;
  1412. if (put_wait_data(cosa, ' ') == -1) return -10;
  1413. if (get_wait_data(cosa) != ' ') return -11;
  1414. if (get_wait_data(cosa) != '=') return -12;
  1416. if (puthexnumber(cosa, address+length-1) < 0) return -13;
  1417. if (put_wait_data(cosa, ' ') == -1) return -18;
  1418. if (get_wait_data(cosa) != ' ') return -19;
  1420. while (length--) {
  1421. char c;
  1422. #ifndef SRP_DOWNLOAD_AT_BOOT
  1423. if (get_user(c, microcode))
  1424. return -23; /* ??? */
  1425. #else
  1426. c = *microcode;
  1427. #endif
  1428. if (put_wait_data(cosa, c) == -1)
  1429. return -20;
  1430. microcode++;
  1431. }
  1433. if (get_wait_data(cosa) != 'r') return -21;
  1434. if (get_wait_data(cosa) != 'n') return -22;
  1435. if (get_wait_data(cosa) != '.') return -23;
  1436. #if 0
  1437. printk(KERN_DEBUG "cosa%d: download completed.n", cosa->num);
  1438. #endif
  1439. return 0;
  1440. }
  1443. /*
  1444.  * Starting microcode is done via the "g" command of the SRP monitor.
  1445.  * The chat should be the following: "g" "g=" "<addr><CR>"
  1446.  * "<CR><CR><LF><CR><LF>".
  1447.  */
  1448. static int startmicrocode(struct cosa_data *cosa, int address)
  1449. {
  1450. if (put_wait_data(cosa, 'g') == -1) return -1;
  1451. if (get_wait_data(cosa) != 'g') return -2;
  1452. if (get_wait_data(cosa) != '=') return -3;
  1454. if (puthexnumber(cosa, address) < 0) return -4;
  1455. if (put_wait_data(cosa, 'r') == -1) return -5;
  1457. if (get_wait_data(cosa) != 'r') return -6;
  1458. if (get_wait_data(cosa) != 'r') return -7;
  1459. if (get_wait_data(cosa) != 'n') return -8;
  1460. if (get_wait_data(cosa) != 'r') return -9;
  1461. if (get_wait_data(cosa) != 'n') return -10;
  1462. #if 0
  1463. printk(KERN_DEBUG "cosa%d: microcode startedn", cosa->num);
  1464. #endif
  1465. return 0;
  1466. }
  1468. /*
  1469.  * Reading memory is done via the "r" command of the SRP monitor.
  1470.  * The chat is the following "r" "r=" "<addr> " " =" "<last_byte> " " "
  1471.  * Then driver can read the data and the conversation is finished
  1472.  * by SRP monitor sending "<CR><LF>." (dot at the end).
  1473.  *
  1474.  * This routine is not needed during the normal operation and serves
  1475.  * for debugging purposes only.
  1476.  */
  1477. static int readmem(struct cosa_data *cosa, char *microcode, int length, int address)
  1478. {
  1479. if (put_wait_data(cosa, 'r') == -1) return -1;
  1480. if ((get_wait_data(cosa)) != 'r') return -2;
  1481. if ((get_wait_data(cosa)) != '=') return -3;
  1483. if (puthexnumber(cosa, address) < 0) return -4;
  1484. if (put_wait_data(cosa, ' ') == -1) return -5;
  1485. if (get_wait_data(cosa) != ' ') return -6;
  1486. if (get_wait_data(cosa) != '=') return -7;
  1488. if (puthexnumber(cosa, address+length-1) < 0) return -8;
  1489. if (put_wait_data(cosa, ' ') == -1) return -9;
  1490. if (get_wait_data(cosa) != ' ') return -10;
  1492. while (length--) {
  1493. char c;
  1494. int i;
  1495. if ((i=get_wait_data(cosa)) == -1) {
  1496. printk (KERN_INFO "cosa: 0x%04x bytes remainingn",
  1497. length);
  1498. return -11;
  1499. }
  1500. c=i;
  1501. #if 1
  1502. if (put_user(c, microcode))
  1503. return -23; /* ??? */
  1504. #else
  1505. *microcode = c;
  1506. #endif
  1507. microcode++;
  1508. }
  1510. if (get_wait_data(cosa) != 'r') return -21;
  1511. if (get_wait_data(cosa) != 'n') return -22;
  1512. if (get_wait_data(cosa) != '.') return -23;
  1513. #if 0
  1514. printk(KERN_DEBUG "cosa%d: readmem completed.n", cosa->num);
  1515. #endif
  1516. return 0;
  1517. }
  1519. /*
  1520.  * This function resets the device and reads the initial prompt
  1521.  * of the device's ROM monitor.
  1522.  */
  1523. static int cosa_reset_and_read_id(struct cosa_data *cosa, char *idstring)
  1524. {
  1525. int i=0, id=0, prev=0, curr=0;
  1527. /* Reset the card ... */
  1528. cosa_putstatus(cosa, 0);
  1529. cosa_getdata8(cosa);
  1530. cosa_putstatus(cosa, SR_RST);
  1531. #ifdef MODULE
  1532. current->state = TASK_INTERRUPTIBLE;
  1533. schedule_timeout(HZ/2);
  1534. current->state = TASK_RUNNING;
  1535. #else
  1536. udelay(5*100000);
  1537. #endif
  1538. /* Disable all IRQs from the card */
  1539. cosa_putstatus(cosa, 0);
  1541. /*
  1542.  * Try to read the ID string. The card then prints out the
  1543.  * identification string ended by the "nx2e".
  1544.  *
  1545.  * The following loop is indexed through i (instead of id)
  1546.  * to avoid looping forever when for any reason
  1547.  * the port returns 'r', 'n' or 'x2e' permanently.
  1548.  */
  1549. for (i=0; i<COSA_MAX_ID_STRING-1; i++, prev=curr) {
  1550. if ((curr = get_wait_data(cosa)) == -1) {
  1551. return -1;
  1552. }
  1553. curr &= 0xff;
  1554. if (curr != 'r' && curr != 'n' && curr != 0x2e)
  1555. idstring[id++] = curr;
  1556. if (curr == 0x2e && prev == 'n')
  1557. break;
  1558. }
  1559. /* Perhaps we should fail when i==COSA_MAX_ID_STRING-1 ? */
  1560. idstring[id] = '';
  1561. return id;
  1562. }
  1565. /* ---------- Auxiliary routines for COSA/SRP monitor ---------- */
  1567. /*
  1568.  * This routine gets the data byte from the card waiting for the SR_RX_RDY
  1569.  * bit to be set in a loop. It should be used in the exceptional cases
  1570.  * only (for example when resetting the card or downloading the firmware.
  1571.  */
  1572. static int get_wait_data(struct cosa_data *cosa)
  1573. {
  1574. int retries = 1000;
  1576. while (--retries) {
  1577. /* read data and return them */
  1578. if (cosa_getstatus(cosa) & SR_RX_RDY) {
  1579. short r;
  1580. r = cosa_getdata8(cosa);
  1581. #if 0
  1582. printk(KERN_INFO "cosa: get_wait_data returning after %d retriesn", 999-retries);
  1583. #endif
  1584. return r;
  1585. }
  1586. /* sleep if not ready to read */
  1587. current->state = TASK_INTERRUPTIBLE;
  1588. schedule_timeout(1);
  1589. }
  1590. printk(KERN_INFO "cosa: timeout in get_wait_data (status 0x%x)n",
  1591. cosa_getstatus(cosa));
  1592. return -1;
  1593. }
  1595. /*
  1596.  * This routine puts the data byte to the card waiting for the SR_TX_RDY
  1597.  * bit to be set in a loop. It should be used in the exceptional cases
  1598.  * only (for example when resetting the card or downloading the firmware).
  1599.  */
  1600. static int put_wait_data(struct cosa_data *cosa, int data)
  1601. {
  1602. int retries = 1000;
  1603. while (--retries) {
  1604. /* read data and return them */
  1605. if (cosa_getstatus(cosa) & SR_TX_RDY) {
  1606. cosa_putdata8(cosa, data);
  1607. #if 0
  1608. printk(KERN_INFO "Putdata: %d retriesn", 999-retries);
  1609. #endif
  1610. return 0;
  1611. }
  1612. #if 0
  1613. /* sleep if not ready to read */
  1614. current->state = TASK_INTERRUPTIBLE;
  1615. schedule_timeout(1);
  1616. #endif
  1617. }
  1618. printk(KERN_INFO "cosa%d: timeout in put_wait_data (status 0x%x)n",
  1619. cosa->num, cosa_getstatus(cosa));
  1620. return -1;
  1621. }
  1623. /* 
  1624.  * The following routine puts the hexadecimal number into the SRP monitor
  1625.  * and verifies the proper echo of the sent bytes. Returns 0 on success,
  1626.  * negative number on failure (-1,-3,-5,-7) means that put_wait_data() failed,
  1627.  * (-2,-4,-6,-8) means that reading echo failed.
  1628.  */
  1629. static int puthexnumber(struct cosa_data *cosa, int number)
  1630. {
  1631. char temp[5];
  1632. int i;
  1634. /* Well, I should probably replace this by something faster. */
  1635. sprintf(temp, "%04X", number);
  1636. for (i=0; i<4; i++) {
  1637. if (put_wait_data(cosa, temp[i]) == -1) {
  1638. printk(KERN_NOTICE "cosa%d: puthexnumber failed to write byte %dn",
  1639. cosa->num, i);
  1640. return -1-2*i;
  1641. }
  1642. if (get_wait_data(cosa) != temp[i]) {
  1643. printk(KERN_NOTICE "cosa%d: puthexhumber failed to read echo of byte %dn",
  1644. cosa->num, i);
  1645. return -2-2*i;
  1646. }
  1647. }
  1648. return 0;
  1649. }
  1652. /* ---------- Interrupt routines ---------- */
  1654. /*
  1655.  * There are three types of interrupt:
  1656.  * At the beginning of transmit - this handled is in tx_interrupt(),
  1657.  * at the beginning of receive - it is in rx_interrupt() and
  1658.  * at the end of transmit/receive - it is the eot_interrupt() function.
  1659.  * These functions are multiplexed by cosa_interrupt() according to the
  1660.  * COSA status byte. I have moved the rx/tx/eot interrupt handling into
  1661.  * separate functions to make it more readable. These functions are inline,
  1662.  * so there should be no overhead of function call.
  1663.  * 
  1664.  * In the COSA bus-master mode, we need to tell the card the address of a
  1665.  * buffer. Unfortunately, COSA may be too slow for us, so we must busy-wait.
  1666.  * It's time to use the bottom half :-(
  1667.  */
  1669. /*
  1670.  * Transmit interrupt routine - called when COSA is willing to obtain
  1671.  * data from the OS. The most tricky part of the routine is selection
  1672.  * of channel we (OS) want to send packet for. For SRP we should probably
  1673.  * use the round-robin approach. The newer COSA firmwares have a simple
  1674.  * flow-control - in the status word has bits 2 and 3 set to 1 means that the
  1675.  * channel 0 or 1 doesn't want to receive data.
  1676.  *
  1677.  * It seems there is a bug in COSA firmware (need to trace it further):
  1678.  * When the driver status says that the kernel has no more data for transmit
  1679.  * (e.g. at the end of TX DMA) and then the kernel changes its mind
  1680.  * (e.g. new packet is queued to hard_start_xmit()), the card issues
  1681.  * the TX interrupt but does not mark the channel as ready-to-transmit.
  1682.  * The fix seems to be to push the packet to COSA despite its request.
  1683.  * We first try to obey the card's opinion, and then fall back to forced TX.
  1684.  */
  1685. static inline void tx_interrupt(struct cosa_data *cosa, int status)
  1686. {
  1687. unsigned long flags, flags1;
  1688. #ifdef DEBUG_IRQS
  1689. printk(KERN_INFO "cosa%d: SR_DOWN_REQUEST status=0x%04xn",
  1690. cosa->num, status);
  1691. #endif
  1692. spin_lock_irqsave(&cosa->lock, flags);
  1693. set_bit(TXBIT, &cosa->rxtx);
  1694. if (!test_bit(IRQBIT, &cosa->rxtx)) {
  1695. /* flow control, see the comment above */
  1696. int i=0;
  1697. if (!cosa->txbitmap) {
  1698. printk(KERN_WARNING "%s: No channel wants data "
  1699. "in TX IRQ. Expect DMA timeout.",
  1700. cosa->name);
  1701. put_driver_status_nolock(cosa);
  1702. clear_bit(TXBIT, &cosa->rxtx);
  1703. spin_unlock_irqrestore(&cosa->lock, flags);
  1704. return;
  1705. }
  1706. while(1) {
  1707. cosa->txchan++;
  1708. i++;
  1709. if (cosa->txchan >= cosa->nchannels)
  1710. cosa->txchan = 0;
  1711. if (!(cosa->txbitmap & (1<<cosa->txchan)))
  1712. continue;
  1713. if (~status & (1 << (cosa->txchan+DRIVER_TXMAP_SHIFT)))
  1714. break;
  1715. /* in second pass, accept first ready-to-TX channel */
  1716. if (i > cosa->nchannels) {
  1717. /* Can be safely ignored */
  1718. #ifdef DEBUG_IRQS
  1719. printk(KERN_DEBUG "%s: Forcing TX "
  1720. "to not-ready channel %dn",
  1721. cosa->name, cosa->txchan);
  1722. #endif
  1723. break;
  1724. }
  1725. }
  1727. cosa->txsize = cosa->chan[cosa->txchan].txsize;
  1728. if (cosa_dma_able(cosa->chan+cosa->txchan,
  1729. cosa->chan[cosa->txchan].txbuf, cosa->txsize)) {
  1730. cosa->txbuf = cosa->chan[cosa->txchan].txbuf;
  1731. } else {
  1732. memcpy(cosa->bouncebuf, cosa->chan[cosa->txchan].txbuf,
  1733. cosa->txsize);
  1734. cosa->txbuf = cosa->bouncebuf;
  1735. }
  1736. }
  1738. if (is_8bit(cosa)) {
  1739. if (!test_bit(IRQBIT, &cosa->rxtx)) {
  1740. cosa_putstatus(cosa, SR_TX_INT_ENA);
  1741. cosa_putdata8(cosa, ((cosa->txchan << 5) & 0xe0)|
  1742. ((cosa->txsize >> 8) & 0x1f));
  1743. #ifdef DEBUG_IO
  1744. debug_status_out(cosa, SR_TX_INT_ENA);
  1745. debug_data_out(cosa, ((cosa->txchan << 5) & 0xe0)|
  1746.                                 ((cosa->txsize >> 8) & 0x1f));
  1747. debug_data_in(cosa, cosa_getdata8(cosa));
  1748. #else
  1749. cosa_getdata8(cosa);
  1750. #endif
  1751. set_bit(IRQBIT, &cosa->rxtx);
  1752. spin_unlock_irqrestore(&cosa->lock, flags);
  1753. return;
  1754. } else {
  1755. clear_bit(IRQBIT, &cosa->rxtx);
  1756. cosa_putstatus(cosa, 0);
  1757. cosa_putdata8(cosa, cosa->txsize&0xff);
  1758. #ifdef DEBUG_IO
  1759. debug_status_out(cosa, 0);
  1760. debug_data_out(cosa, cosa->txsize&0xff);
  1761. #endif
  1762. }
  1763. } else {
  1764. cosa_putstatus(cosa, SR_TX_INT_ENA);
  1765. cosa_putdata16(cosa, ((cosa->txchan<<13) & 0xe000)
  1766. | (cosa->txsize & 0x1fff));
  1767. #ifdef DEBUG_IO
  1768. debug_status_out(cosa, SR_TX_INT_ENA);
  1769. debug_data_out(cosa, ((cosa->txchan<<13) & 0xe000)
  1770.                         | (cosa->txsize & 0x1fff));
  1771. debug_data_in(cosa, cosa_getdata8(cosa));
  1772. debug_status_out(cosa, 0);
  1773. #else
  1774. cosa_getdata8(cosa);
  1775. #endif
  1776. cosa_putstatus(cosa, 0);
  1777. }
  1779. if (cosa->busmaster) {
  1780. unsigned long addr = virt_to_bus(cosa->txbuf);
  1781. int count=0;
  1782. printk(KERN_INFO "busmaster IRQn");
  1783. while (!(cosa_getstatus(cosa)&SR_TX_RDY)) {
  1784. count++;
  1785. udelay(10);
  1786. if (count > 1000) break;
  1787. }
  1788. printk(KERN_INFO "status %xn", cosa_getstatus(cosa));
  1789. printk(KERN_INFO "ready after %d loopsn", count);
  1790. cosa_putdata16(cosa, (addr >> 16)&0xffff);
  1792. count = 0;
  1793. while (!(cosa_getstatus(cosa)&SR_TX_RDY)) {
  1794. count++;
  1795. if (count > 1000) break;
  1796. udelay(10);
  1797. }
  1798. printk(KERN_INFO "ready after %d loopsn", count);
  1799. cosa_putdata16(cosa, addr &0xffff);
  1800. flags1 = claim_dma_lock();
  1801. set_dma_mode(cosa->dma, DMA_MODE_CASCADE);
  1802. enable_dma(cosa->dma);
  1803. release_dma_lock(flags1);
  1804. } else {
  1805. /* start the DMA */
  1806. flags1 = claim_dma_lock();
  1807. disable_dma(cosa->dma);
  1808. clear_dma_ff(cosa->dma);
  1809. set_dma_mode(cosa->dma, DMA_MODE_WRITE);
  1810. set_dma_addr(cosa->dma, virt_to_bus(cosa->txbuf));
  1811. set_dma_count(cosa->dma, cosa->txsize);
  1812. enable_dma(cosa->dma);
  1813. release_dma_lock(flags1);
  1814. }
  1815. cosa_putstatus(cosa, SR_TX_DMA_ENA|SR_USR_INT_ENA);
  1816. #ifdef DEBUG_IO
  1817. debug_status_out(cosa, SR_TX_DMA_ENA|SR_USR_INT_ENA);
  1818. #endif
  1819. spin_unlock_irqrestore(&cosa->lock, flags);
  1820. }
  1822. static inline void rx_interrupt(struct cosa_data *cosa, int status)
  1823. {
  1824. unsigned long flags;
  1825. #ifdef DEBUG_IRQS
  1826. printk(KERN_INFO "cosa%d: SR_UP_REQUESTn", cosa->num);
  1827. #endif
  1829. spin_lock_irqsave(&cosa->lock, flags);
  1830. set_bit(RXBIT, &cosa->rxtx);
  1832. if (is_8bit(cosa)) {
  1833. if (!test_bit(IRQBIT, &cosa->rxtx)) {
  1834. set_bit(IRQBIT, &cosa->rxtx);
  1835. put_driver_status_nolock(cosa);
  1836. cosa->rxsize = cosa_getdata8(cosa) <<8;
  1837. #ifdef DEBUG_IO
  1838. debug_data_in(cosa, cosa->rxsize >> 8);
  1839. #endif
  1840. spin_unlock_irqrestore(&cosa->lock, flags);
  1841. return;
  1842. } else {
  1843. clear_bit(IRQBIT, &cosa->rxtx);
  1844. cosa->rxsize |= cosa_getdata8(cosa) & 0xff;
  1845. #ifdef DEBUG_IO
  1846. debug_data_in(cosa, cosa->rxsize & 0xff);
  1847. #endif
  1848. #if 0
  1849. printk(KERN_INFO "cosa%d: receive rxsize = (0x%04x).n",
  1850. cosa->num, cosa->rxsize);
  1851. #endif
  1852. }
  1853. } else {
  1854. cosa->rxsize = cosa_getdata16(cosa);
  1855. #ifdef DEBUG_IO
  1856. debug_data_in(cosa, cosa->rxsize);
  1857. #endif
  1858. #if 0
  1859. printk(KERN_INFO "cosa%d: receive rxsize = (0x%04x).n",
  1860. cosa->num, cosa->rxsize);
  1861. #endif
  1862. }
  1863. if (((cosa->rxsize & 0xe000) >> 13) >= cosa->nchannels) {
  1864. printk(KERN_WARNING "%s: rx for unknown channel (0x%04x)n",
  1865. cosa->name, cosa->rxsize);
  1866. spin_unlock_irqrestore(&cosa->lock, flags);
  1867. goto reject;
  1868. }
  1869. cosa->rxchan = cosa->chan + ((cosa->rxsize & 0xe000) >> 13);
  1870. cosa->rxsize &= 0x1fff;
  1871. spin_unlock_irqrestore(&cosa->lock, flags);
  1873. cosa->rxbuf = NULL;
  1874. if (cosa->rxchan->setup_rx)
  1875. cosa->rxbuf = cosa->rxchan->setup_rx(cosa->rxchan, cosa->rxsize);
  1877. if (!cosa->rxbuf) {
  1878. reject: /* Reject the packet */
  1879. printk(KERN_INFO "cosa%d: rejecting packet on channel %dn",
  1880. cosa->num, cosa->rxchan->num);
  1881. cosa->rxbuf = cosa->bouncebuf;
  1882. }
  1884. /* start the DMA */
  1885. flags = claim_dma_lock();
  1886. disable_dma(cosa->dma);
  1887. clear_dma_ff(cosa->dma);
  1888. set_dma_mode(cosa->dma, DMA_MODE_READ);
  1889. if (cosa_dma_able(cosa->rxchan, cosa->rxbuf, cosa->rxsize & 0x1fff)) {
  1890. set_dma_addr(cosa->dma, virt_to_bus(cosa->rxbuf));
  1891. } else {
  1892. set_dma_addr(cosa->dma, virt_to_bus(cosa->bouncebuf));
  1893. }
  1894. set_dma_count(cosa->dma, (cosa->rxsize&0x1fff));
  1895. enable_dma(cosa->dma);
  1896. release_dma_lock(flags);
  1897. spin_lock_irqsave(&cosa->lock, flags);
  1898. cosa_putstatus(cosa, SR_RX_DMA_ENA|SR_USR_INT_ENA);
  1899. if (!is_8bit(cosa) && (status & SR_TX_RDY))
  1900. cosa_putdata8(cosa, DRIVER_RX_READY);
  1901. #ifdef DEBUG_IO
  1902. debug_status_out(cosa, SR_RX_DMA_ENA|SR_USR_INT_ENA);
  1903. if (!is_8bit(cosa) && (status & SR_TX_RDY))
  1904. debug_data_cmd(cosa, DRIVER_RX_READY);
  1905. #endif
  1906. spin_unlock_irqrestore(&cosa->lock, flags);
  1907. }
  1909. static void inline eot_interrupt(struct cosa_data *cosa, int status)
  1910. {
  1911. unsigned long flags, flags1;
  1912. spin_lock_irqsave(&cosa->lock, flags);
  1913. flags1 = claim_dma_lock();
  1914. disable_dma(cosa->dma);
  1915. clear_dma_ff(cosa->dma);
  1916. release_dma_lock(flags1);
  1917. if (test_bit(TXBIT, &cosa->rxtx)) {
  1918. struct channel_data *chan = cosa->chan+cosa->txchan;
  1919. if (chan->tx_done)
  1920. if (chan->tx_done(chan, cosa->txsize))
  1921. clear_bit(chan->num, &cosa->txbitmap);
  1922. } else if (test_bit(RXBIT, &cosa->rxtx)) {
  1923. #ifdef DEBUG_DATA
  1924. {
  1925. int i;
  1926. printk(KERN_INFO "cosa%dc%d: done rx(0x%x)", cosa->num, 
  1927. cosa->rxchan->num, cosa->rxsize);
  1928. for (i=0; i<cosa->rxsize; i++)
  1929. printk (" %02x", cosa->rxbuf[i]&0xff);
  1930. printk("n");
  1931. }
  1932. #endif
  1933. /* Packet for unknown channel? */
  1934. if (cosa->rxbuf == cosa->bouncebuf)
  1935. goto out;
  1936. if (!cosa_dma_able(cosa->rxchan, cosa->rxbuf, cosa->rxsize))
  1937. memcpy(cosa->rxbuf, cosa->bouncebuf, cosa->rxsize);
  1938. if (cosa->rxchan->rx_done)
  1939. if (cosa->rxchan->rx_done(cosa->rxchan))
  1940. clear_bit(cosa->rxchan->num, &cosa->rxbitmap);
  1941. } else {
  1942. printk(KERN_NOTICE "cosa%d: unexpected EOT interruptn",
  1943. cosa->num);
  1944. }
  1945. /*
  1946.  * Clear the RXBIT, TXBIT and IRQBIT (the latest should be
  1947.  * cleared anyway). We should do it as soon as possible
  1948.  * so that we can tell the COSA we are done and to give it a time
  1949.  * for recovery.
  1950.  */
  1951. out:
  1952. cosa->rxtx = 0;
  1953. put_driver_status_nolock(cosa);
  1954. spin_unlock_irqrestore(&cosa->lock, flags);
  1955. }
  1957. static void cosa_interrupt(int irq, void *cosa_, struct pt_regs *regs)
  1958. {
  1959. unsigned status;
  1960. int count = 0;
  1961. struct cosa_data *cosa = cosa_;
  1962. again:
  1963. status = cosa_getstatus(cosa);
  1964. #ifdef DEBUG_IRQS
  1965. printk(KERN_INFO "cosa%d: got IRQ, status 0x%02xn", cosa->num,
  1966. status & 0xff);
  1967. #endif
  1968. #ifdef DEBUG_IO
  1969. debug_status_in(cosa, status);
  1970. #endif
  1971. switch (status & SR_CMD_FROM_SRP_MASK) {
  1972. case SR_DOWN_REQUEST:
  1973. tx_interrupt(cosa, status);
  1974. break;
  1975. case SR_UP_REQUEST:
  1976. rx_interrupt(cosa, status);
  1977. break;
  1978. case SR_END_OF_TRANSFER:
  1979. eot_interrupt(cosa, status);
  1980. break;
  1981. default:
  1982. /* We may be too fast for SRP. Try to wait a bit more. */
  1983. if (count++ < 100) {
  1984. udelay(100);
  1985. goto again;
  1986. }
  1987. printk(KERN_INFO "cosa%d: unknown status 0x%02x in IRQ after %d retriesn",
  1988. cosa->num, status & 0xff, count);
  1989. }
  1990. #ifdef DEBUG_IRQS
  1991. if (count)
  1992. printk(KERN_INFO "%s: %d-times got unknown status in IRQn",
  1993. cosa->name, count);
  1994. else
  1995. printk(KERN_INFO "%s: returning from IRQn", cosa->name);
  1996. #endif
  1997. }
  2000. /* ---------- I/O debugging routines ---------- */
  2001. /*
  2002.  * These routines can be used to monitor COSA/SRP I/O and to printk()
  2003.  * the data being transferred on the data and status I/O port in a
  2004.  * readable way.
  2005.  */
  2007. #ifdef DEBUG_IO
  2008. static void debug_status_in(struct cosa_data *cosa, int status)
  2009. {
  2010. char *s;
  2011. switch(status & SR_CMD_FROM_SRP_MASK) {
  2012. case SR_UP_REQUEST:
  2013. s = "RX_REQ";
  2014. break;
  2015. case SR_DOWN_REQUEST:
  2016. s = "TX_REQ";
  2017. break;
  2018. case SR_END_OF_TRANSFER:
  2019. s = "ET_REQ";
  2020. break;
  2021. default:
  2022. s = "NO_REQ";
  2023. break;
  2024. }
  2025. printk(KERN_INFO "%s: IO: status -> 0x%02x (%s%s%s%s)n",
  2026. cosa->name,
  2027. status,
  2028. status & SR_USR_RQ ? "USR_RQ|":"",
  2029. status & SR_TX_RDY ? "TX_RDY|":"",
  2030. status & SR_RX_RDY ? "RX_RDY|":"",
  2031. s);
  2032. }
  2034. static void debug_status_out(struct cosa_data *cosa, int status)
  2035. {
  2036. printk(KERN_INFO "%s: IO: status <- 0x%02x (%s%s%s%s%s%s)n",
  2037. cosa->name,
  2038. status,
  2039. status & SR_RX_DMA_ENA  ? "RXDMA|":"!rxdma|",
  2040. status & SR_TX_DMA_ENA  ? "TXDMA|":"!txdma|",
  2041. status & SR_RST         ? "RESET|":"",
  2042. status & SR_USR_INT_ENA ? "USRINT|":"!usrint|",
  2043. status & SR_TX_INT_ENA  ? "TXINT|":"!txint|",
  2044. status & SR_RX_INT_ENA  ? "RXINT":"!rxint");
  2045. }
  2047. static void debug_data_in(struct cosa_data *cosa, int data)
  2048. {
  2049. printk(KERN_INFO "%s: IO: data -> 0x%04xn", cosa->name, data);
  2050. }
  2052. static void debug_data_out(struct cosa_data *cosa, int data)
  2053. {
  2054. printk(KERN_INFO "%s: IO: data <- 0x%04xn", cosa->name, data);
  2055. }
  2057. static void debug_data_cmd(struct cosa_data *cosa, int data)
  2058. {
  2059. printk(KERN_INFO "%s: IO: data <- 0x%04x (%s|%s)n",
  2060. cosa->name, data,
  2061. data & SR_RDY_RCV ? "RX_RDY" : "!rx_rdy",
  2062. data & SR_RDY_SND ? "TX_RDY" : "!tx_rdy");
  2063. }
  2064. #endif
  2066. /* EOF -- this file has not been truncated */