Lines Matching refs:cosa
2 /* $Id: cosa.c,v 1.31 2000/03/08 17:47:16 kas Exp $ */
18 * http://www.pavoucek.cz/cosa.html. The card documentation, firmwares
19 * and other goods can be downloaded from ftp://ftp.ics.muni.cz/pub/cosa/.
38 * The homepage of the Linux driver is at https://www.fi.muni.cz/~kas/cosa/.
87 #include "cosa.h"
100 struct cosa_data *cosa; /* Pointer to the per-card structure */
126 /* cosa->firmware_status bits */
188 * for cosa->rxtx - indicates whether either transmit or receive is
247 #define is_8bit(cosa) (!(cosa->datareg & 0x08))
249 #define cosa_getstatus(cosa) (cosa_inb(cosa->statusreg))
250 #define cosa_putstatus(cosa, stat) (cosa_outb(stat, cosa->statusreg))
251 #define cosa_getdata16(cosa) (cosa_inw(cosa->datareg))
252 #define cosa_getdata8(cosa) (cosa_inb(cosa->datareg))
253 #define cosa_putdata16(cosa, dt) (cosa_outw(dt, cosa->datareg))
254 #define cosa_putdata8(cosa, dt) (cosa_outb(dt, cosa->datareg))
263 static void cosa_kick(struct cosa_data *cosa);
310 static int cosa_start(struct cosa_data *cosa, int address);
311 static int cosa_reset(struct cosa_data *cosa);
312 static int cosa_download(struct cosa_data *cosa, void __user *a);
313 static int cosa_readmem(struct cosa_data *cosa, void __user *a);
316 static int download(struct cosa_data *cosa, const char __user *data, int addr, int len);
317 static int startmicrocode(struct cosa_data *cosa, int address);
318 static int readmem(struct cosa_data *cosa, char __user *data, int addr, int len);
319 static int cosa_reset_and_read_id(struct cosa_data *cosa, char *id);
322 static int get_wait_data(struct cosa_data *cosa);
323 static int put_wait_data(struct cosa_data *cosa, int data);
324 static int puthexnumber(struct cosa_data *cosa, int number);
325 static void put_driver_status(struct cosa_data *cosa);
326 static void put_driver_status_nolock(struct cosa_data *cosa);
329 static irqreturn_t cosa_interrupt(int irq, void *cosa);
333 static void debug_data_in(struct cosa_data *cosa, int data);
334 static void debug_data_out(struct cosa_data *cosa, int data);
335 static void debug_data_cmd(struct cosa_data *cosa, int data);
336 static void debug_status_in(struct cosa_data *cosa, int status);
337 static void debug_status_out(struct cosa_data *cosa, int status);
352 if (register_chrdev(cosa_major, "cosa", &cosa_fops)) {
358 if (!(cosa_major=register_chrdev(0, "cosa", &cosa_fops))) {
370 unregister_chrdev(cosa_major, "cosa");
374 cosa_class = class_create(THIS_MODULE, "cosa");
381 "cosa%d", i);
386 unregister_chrdev(cosa_major, "cosa");
394 struct cosa_data *cosa;
401 for (cosa = cosa_cards; nr_cards--; cosa++) {
403 for (i = 0; i < cosa->nchannels; i++) {
405 unregister_hdlc_device(cosa->chan[i].netdev);
406 free_netdev(cosa->chan[i].netdev);
409 kfree(cosa->chan);
410 kfree(cosa->bouncebuf);
411 free_irq(cosa->irq, cosa);
412 free_dma(cosa->dma);
413 release_region(cosa->datareg, is_8bit(cosa) ? 2 : 4);
415 unregister_chrdev(cosa_major, "cosa");
429 struct cosa_data *cosa = cosa_cards+nr_cards;
432 memset(cosa, 0, sizeof(struct cosa_data));
459 cosa->dma = dma;
460 cosa->datareg = base;
461 cosa->statusreg = is_8bit(cosa)?base+1:base+2;
462 spin_lock_init(&cosa->lock);
464 if (!request_region(base, is_8bit(cosa)?2:4,"cosa"))
467 if (cosa_reset_and_read_id(cosa, cosa->id_string) < 0) {
474 if (!strncmp(cosa->id_string, "SRP", 3))
475 cosa->type = "srp";
476 else if (!strncmp(cosa->id_string, "COSA", 4))
477 cosa->type = is_8bit(cosa)? "cosa8": "cosa16";
487 release_region(base, is_8bit(cosa)?2:4);
488 if (!request_region(base, is_8bit(cosa)?2:4, cosa->type)) {
505 cosa_putstatus(cosa, SR_TX_INT_ENA);
509 cosa_putstatus(cosa, 0);
511 cosa_getdata8(cosa);
515 irq, cosa->datareg);
521 cosa->datareg);
526 cosa->irq = irq;
527 cosa->num = nr_cards;
528 cosa->usage = 0;
529 cosa->nchannels = 2; /* FIXME: how to determine this? */
531 if (request_irq(cosa->irq, cosa_interrupt, 0, cosa->type, cosa)) {
535 if (request_dma(cosa->dma, cosa->type)) {
540 cosa->bouncebuf = kmalloc(COSA_MTU, GFP_KERNEL|GFP_DMA);
541 if (!cosa->bouncebuf) {
545 sprintf(cosa->name, "cosa%d", cosa->num);
548 cosa->chan = kcalloc(cosa->nchannels, sizeof(struct channel_data), GFP_KERNEL);
549 if (!cosa->chan) {
554 for (i = 0; i < cosa->nchannels; i++) {
555 struct channel_data *chan = &cosa->chan[i];
557 chan->cosa = cosa;
559 sprintf(chan->name, "cosa%dc%d", chan->cosa->num, i);
575 chan->netdev->base_addr = chan->cosa->datareg;
576 chan->netdev->irq = chan->cosa->irq;
577 chan->netdev->dma = chan->cosa->dma;
587 pr_info("cosa%d: %s (%s at 0x%x irq %d dma %d), %d channels\n",
588 cosa->num, cosa->id_string, cosa->type,
589 cosa->datareg, cosa->irq, cosa->dma, cosa->nchannels);
595 unregister_hdlc_device(cosa->chan[i].netdev);
596 free_netdev(cosa->chan[i].netdev);
598 kfree(cosa->chan);
600 kfree(cosa->bouncebuf);
602 free_dma(cosa->dma);
604 free_irq(cosa->irq, cosa);
606 release_region(cosa->datareg,is_8bit(cosa)?2:4);
607 pr_notice("cosa%d: allocating resources failed\n", cosa->num);
629 if (!(chan->cosa->firmware_status & COSA_FW_START)) {
631 chan->cosa->name, chan->cosa->firmware_status);
634 spin_lock_irqsave(&chan->cosa->lock, flags);
638 spin_unlock_irqrestore(&chan->cosa->lock, flags);
645 chan->cosa->usage++;
646 spin_unlock_irqrestore(&chan->cosa->lock, flags);
650 spin_lock_irqsave(&chan->cosa->lock, flags);
652 chan->cosa->usage--;
653 spin_unlock_irqrestore(&chan->cosa->lock, flags);
678 if (test_bit(RXBIT, &chan->cosa->rxtx)) {
685 cosa_kick(chan->cosa);
701 spin_lock_irqsave(&chan->cosa->lock, flags);
711 chan->cosa->usage--;
712 spin_unlock_irqrestore(&chan->cosa->lock, flags);
720 * the cosa->bouncebuf pre-allocated.
745 chan->netdev->stats.rx_bytes += chan->cosa->rxsize;
776 struct cosa_data *cosa = chan->cosa;
779 if (!(cosa->firmware_status & COSA_FW_START)) {
781 cosa->name, cosa->firmware_status);
795 spin_lock_irqsave(&cosa->lock, flags);
799 spin_unlock_irqrestore(&cosa->lock, flags);
801 spin_lock_irqsave(&cosa->lock, flags);
806 spin_unlock_irqrestore(&cosa->lock, flags);
815 spin_unlock_irqrestore(&cosa->lock, flags);
850 struct cosa_data *cosa = chan->cosa;
854 if (!(cosa->firmware_status & COSA_FW_START)) {
856 cosa->name, cosa->firmware_status);
879 spin_lock_irqsave(&cosa->lock, flags);
883 spin_unlock_irqrestore(&cosa->lock, flags);
885 spin_lock_irqsave(&cosa->lock, flags);
891 spin_unlock_irqrestore(&cosa->lock, flags);
900 spin_unlock_irqrestore(&cosa->lock, flags);
924 struct cosa_data *cosa;
936 cosa = cosa_cards+n;
939 & ((1<<CARD_MINOR_BITS)-1)) >= cosa->nchannels) {
943 chan = cosa->chan + n;
947 spin_lock_irqsave(&cosa->lock, flags);
950 spin_unlock_irqrestore(&cosa->lock, flags);
954 cosa->usage++;
960 spin_unlock_irqrestore(&cosa->lock, flags);
969 struct cosa_data *cosa;
972 cosa = channel->cosa;
973 spin_lock_irqsave(&cosa->lock, flags);
974 cosa->usage--;
976 spin_unlock_irqrestore(&cosa->lock, flags);
1000 static inline int cosa_reset(struct cosa_data *cosa)
1003 if (cosa->usage > 1)
1004 pr_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 pr_notice("cosa%d: reset failed\n", cosa->num);
1011 pr_info("cosa%d: resetting device: %s\n", cosa->num, idstring);
1012 cosa->firmware_status |= COSA_FW_RESET;
1017 static inline int cosa_download(struct cosa_data *cosa, void __user *arg)
1022 if (cosa->usage > 1)
1023 pr_info("%s: WARNING: download of microcode requested with cosa->usage > 1 (%d). Odd things may happen.\n",
1024 cosa->name, cosa->usage);
1025 if (!(cosa->firmware_status & COSA_FW_RESET)) {
1027 cosa->name, cosa->firmware_status);
1041 cosa->firmware_status &= ~(COSA_FW_RESET|COSA_FW_DOWNLOAD);
1043 i = download(cosa, d.code, d.len, d.addr);
1045 pr_notice("cosa%d: microcode download failed: %d\n",
1046 cosa->num, i);
1049 pr_info("cosa%d: downloading microcode - 0x%04x bytes at 0x%04x\n",
1050 cosa->num, d.len, d.addr);
1051 cosa->firmware_status |= COSA_FW_RESET|COSA_FW_DOWNLOAD;
1056 static inline int cosa_readmem(struct cosa_data *cosa, void __user *arg)
1061 if (cosa->usage > 1)
1062 pr_info("cosa%d: WARNING: readmem requested with cosa->usage > 1 (%d). Odd things may happen.\n",
1063 cosa->num, cosa->usage);
1064 if (!(cosa->firmware_status & COSA_FW_RESET)) {
1066 cosa->name, cosa->firmware_status);
1074 cosa->firmware_status &= ~COSA_FW_RESET;
1076 i = readmem(cosa, d.code, d.len, d.addr);
1078 pr_notice("cosa%d: reading memory failed: %d\n", cosa->num, i);
1081 pr_info("cosa%d: reading card memory - 0x%04x bytes at 0x%04x\n",
1082 cosa->num, d.len, d.addr);
1083 cosa->firmware_status |= COSA_FW_RESET;
1088 static inline int cosa_start(struct cosa_data *cosa, int address)
1092 if (cosa->usage > 1)
1093 pr_info("cosa%d: WARNING: start microcode requested with cosa->usage > 1 (%d). Odd things may happen.\n",
1094 cosa->num, cosa->usage);
1096 if ((cosa->firmware_status & (COSA_FW_RESET|COSA_FW_DOWNLOAD))
1099 cosa->name, cosa->firmware_status);
1102 cosa->firmware_status &= ~COSA_FW_RESET;
1103 if ((i=startmicrocode(cosa, address)) < 0) {
1104 pr_notice("cosa%d: start microcode at 0x%04x failed: %d\n",
1105 cosa->num, address, i);
1108 pr_info("cosa%d: starting microcode at 0x%04x\n", cosa->num, address);
1109 cosa->startaddr = address;
1110 cosa->firmware_status |= COSA_FW_START;
1115 static inline int cosa_getidstr(struct cosa_data *cosa, char __user *string)
1117 int l = strlen(cosa->id_string)+1;
1118 if (copy_to_user(string, cosa->id_string, l))
1124 static inline int cosa_gettype(struct cosa_data *cosa, char __user *string)
1126 int l = strlen(cosa->type)+1;
1127 if (copy_to_user(string, cosa->type, l))
1132 static int cosa_ioctl_common(struct cosa_data *cosa,
1140 return cosa_reset(cosa);
1144 return cosa_start(cosa, arg);
1149 return cosa_download(cosa, argp);
1153 return cosa_readmem(cosa, argp);
1155 return cosa_gettype(cosa, argp);
1157 return cosa_getidstr(cosa, argp);
1161 return cosa->nchannels;
1165 if (is_8bit(cosa))
1169 cosa->busmaster = arg;
1172 return cosa->busmaster;
1181 rv = cosa_ioctl_common(chan->cosa, chan, cmd,
1192 struct cosa_data *cosa;
1196 cosa = channel->cosa;
1197 ret = cosa_ioctl_common(cosa, channel, cmd, arg);
1212 struct cosa_data *cosa = chan->cosa;
1214 if (!test_and_set_bit(chan->num, &cosa->rxbitmap))
1215 put_driver_status(cosa);
1220 struct cosa_data *cosa = chan->cosa;
1222 if (test_and_clear_bit(chan->num, &cosa->rxbitmap))
1223 put_driver_status(cosa);
1234 struct cosa_data *cosa = chan->cosa;
1239 pr_info("cosa%dc%d: starting tx(0x%x)",
1240 chan->cosa->num, chan->num, len);
1245 spin_lock_irqsave(&cosa->lock, flags);
1250 spin_unlock_irqrestore(&cosa->lock, flags);
1253 set_bit(chan->num, &cosa->txbitmap);
1254 put_driver_status(cosa);
1259 static void put_driver_status(struct cosa_data *cosa)
1264 spin_lock_irqsave(&cosa->lock, flags);
1266 status = (cosa->rxbitmap ? DRIVER_RX_READY : 0)
1267 | (cosa->txbitmap ? DRIVER_TX_READY : 0)
1268 | (cosa->txbitmap? ~(cosa->txbitmap<<DRIVER_TXMAP_SHIFT)
1270 if (!cosa->rxtx) {
1271 if (cosa->rxbitmap|cosa->txbitmap) {
1272 if (!cosa->enabled) {
1273 cosa_putstatus(cosa, SR_RX_INT_ENA);
1275 debug_status_out(cosa, SR_RX_INT_ENA);
1277 cosa->enabled = 1;
1279 } else if (cosa->enabled) {
1280 cosa->enabled = 0;
1281 cosa_putstatus(cosa, 0);
1283 debug_status_out(cosa, 0);
1286 cosa_putdata8(cosa, status);
1288 debug_data_cmd(cosa, status);
1291 spin_unlock_irqrestore(&cosa->lock, flags);
1294 static void put_driver_status_nolock(struct cosa_data *cosa)
1298 status = (cosa->rxbitmap ? DRIVER_RX_READY : 0)
1299 | (cosa->txbitmap ? DRIVER_TX_READY : 0)
1300 | (cosa->txbitmap? ~(cosa->txbitmap<<DRIVER_TXMAP_SHIFT)
1303 if (cosa->rxbitmap|cosa->txbitmap) {
1304 cosa_putstatus(cosa, SR_RX_INT_ENA);
1306 debug_status_out(cosa, SR_RX_INT_ENA);
1308 cosa->enabled = 1;
1310 cosa_putstatus(cosa, 0);
1312 debug_status_out(cosa, 0);
1314 cosa->enabled = 0;
1316 cosa_putdata8(cosa, status);
1318 debug_data_cmd(cosa, status);
1327 static void cosa_kick(struct cosa_data *cosa)
1332 if (test_bit(RXBIT, &cosa->rxtx))
1334 if (test_bit(TXBIT, &cosa->rxtx))
1337 pr_info("%s: %s timeout - restarting\n", cosa->name, s);
1338 spin_lock_irqsave(&cosa->lock, flags);
1339 cosa->rxtx = 0;
1342 disable_dma(cosa->dma);
1343 clear_dma_ff(cosa->dma);
1348 cosa_putstatus(cosa, 0);
1350 (void) cosa_getdata8(cosa);
1352 cosa_putdata8(cosa, 0);
1354 put_driver_status_nolock(cosa);
1355 spin_unlock_irqrestore(&cosa->lock, flags);
1390 static int download(struct cosa_data *cosa, const char __user *microcode, int length, int address)
1394 if (put_wait_data(cosa, 'w') == -1) return -1;
1395 if ((i=get_wait_data(cosa)) != 'w') { printk("dnld: 0x%04x\n",i); return -2;}
1396 if (get_wait_data(cosa) != '=') return -3;
1398 if (puthexnumber(cosa, address) < 0) return -4;
1399 if (put_wait_data(cosa, ' ') == -1) return -10;
1400 if (get_wait_data(cosa) != ' ') return -11;
1401 if (get_wait_data(cosa) != '=') return -12;
1403 if (puthexnumber(cosa, address+length-1) < 0) return -13;
1404 if (put_wait_data(cosa, ' ') == -1) return -18;
1405 if (get_wait_data(cosa) != ' ') return -19;
1415 if (put_wait_data(cosa, c) == -1)
1420 if (get_wait_data(cosa) != '\r') return -21;
1421 if (get_wait_data(cosa) != '\n') return -22;
1422 if (get_wait_data(cosa) != '.') return -23;
1424 printk(KERN_DEBUG "cosa%d: download completed.\n", cosa->num);
1435 static int startmicrocode(struct cosa_data *cosa, int address)
1437 if (put_wait_data(cosa, 'g') == -1) return -1;
1438 if (get_wait_data(cosa) != 'g') return -2;
1439 if (get_wait_data(cosa) != '=') return -3;
1441 if (puthexnumber(cosa, address) < 0) return -4;
1442 if (put_wait_data(cosa, '\r') == -1) return -5;
1444 if (get_wait_data(cosa) != '\r') return -6;
1445 if (get_wait_data(cosa) != '\r') return -7;
1446 if (get_wait_data(cosa) != '\n') return -8;
1447 if (get_wait_data(cosa) != '\r') return -9;
1448 if (get_wait_data(cosa) != '\n') return -10;
1450 printk(KERN_DEBUG "cosa%d: microcode started\n", cosa->num);
1464 static int readmem(struct cosa_data *cosa, char __user *microcode, int length, int address)
1466 if (put_wait_data(cosa, 'r') == -1) return -1;
1467 if ((get_wait_data(cosa)) != 'r') return -2;
1468 if ((get_wait_data(cosa)) != '=') return -3;
1470 if (puthexnumber(cosa, address) < 0) return -4;
1471 if (put_wait_data(cosa, ' ') == -1) return -5;
1472 if (get_wait_data(cosa) != ' ') return -6;
1473 if (get_wait_data(cosa) != '=') return -7;
1475 if (puthexnumber(cosa, address+length-1) < 0) return -8;
1476 if (put_wait_data(cosa, ' ') == -1) return -9;
1477 if (get_wait_data(cosa) != ' ') return -10;
1482 if ((i=get_wait_data(cosa)) == -1) {
1496 if (get_wait_data(cosa) != '\r') return -21;
1497 if (get_wait_data(cosa) != '\n') return -22;
1498 if (get_wait_data(cosa) != '.') return -23;
1500 printk(KERN_DEBUG "cosa%d: readmem completed.\n", cosa->num);
1509 static int cosa_reset_and_read_id(struct cosa_data *cosa, char *idstring)
1514 cosa_putstatus(cosa, 0);
1515 cosa_getdata8(cosa);
1516 cosa_putstatus(cosa, SR_RST);
1519 cosa_putstatus(cosa, 0);
1530 if ((curr = get_wait_data(cosa)) == -1) {
1553 static int get_wait_data(struct cosa_data *cosa)
1559 if (cosa_getstatus(cosa) & SR_RX_RDY) {
1561 r = cosa_getdata8(cosa);
1572 cosa_getstatus(cosa));
1581 static int put_wait_data(struct cosa_data *cosa, int data)
1586 if (cosa_getstatus(cosa) & SR_TX_RDY) {
1587 cosa_putdata8(cosa, data);
1598 pr_info("cosa%d: timeout in put_wait_data (status 0x%x)\n",
1599 cosa->num, cosa_getstatus(cosa));
1609 static int puthexnumber(struct cosa_data *cosa, int number)
1617 if (put_wait_data(cosa, temp[i]) == -1) {
1618 pr_notice("cosa%d: puthexnumber failed to write byte %d\n",
1619 cosa->num, i);
1622 if (get_wait_data(cosa) != temp[i]) {
1623 pr_notice("cosa%d: puthexhumber failed to read echo of byte %d\n",
1624 cosa->num, i);
1666 static inline void tx_interrupt(struct cosa_data *cosa, int status)
1670 pr_info("cosa%d: SR_DOWN_REQUEST status=0x%04x\n", cosa->num, status);
1672 spin_lock_irqsave(&cosa->lock, flags);
1673 set_bit(TXBIT, &cosa->rxtx);
1674 if (!test_bit(IRQBIT, &cosa->rxtx)) {
1677 if (!cosa->txbitmap) {
1679 cosa->name);
1680 put_driver_status_nolock(cosa);
1681 clear_bit(TXBIT, &cosa->rxtx);
1682 spin_unlock_irqrestore(&cosa->lock, flags);
1686 cosa->txchan++;
1688 if (cosa->txchan >= cosa->nchannels)
1689 cosa->txchan = 0;
1690 if (!(cosa->txbitmap & (1<<cosa->txchan)))
1692 if (~status & (1 << (cosa->txchan+DRIVER_TXMAP_SHIFT)))
1695 if (i > cosa->nchannels) {
1700 cosa->name, cosa->txchan);
1706 cosa->txsize = cosa->chan[cosa->txchan].txsize;
1707 if (cosa_dma_able(cosa->chan+cosa->txchan,
1708 cosa->chan[cosa->txchan].txbuf, cosa->txsize)) {
1709 cosa->txbuf = cosa->chan[cosa->txchan].txbuf;
1711 memcpy(cosa->bouncebuf, cosa->chan[cosa->txchan].txbuf,
1712 cosa->txsize);
1713 cosa->txbuf = cosa->bouncebuf;
1717 if (is_8bit(cosa)) {
1718 if (!test_bit(IRQBIT, &cosa->rxtx)) {
1719 cosa_putstatus(cosa, SR_TX_INT_ENA);
1720 cosa_putdata8(cosa, ((cosa->txchan << 5) & 0xe0)|
1721 ((cosa->txsize >> 8) & 0x1f));
1723 debug_status_out(cosa, SR_TX_INT_ENA);
1724 debug_data_out(cosa, ((cosa->txchan << 5) & 0xe0)|
1725 ((cosa->txsize >> 8) & 0x1f));
1726 debug_data_in(cosa, cosa_getdata8(cosa));
1728 cosa_getdata8(cosa);
1730 set_bit(IRQBIT, &cosa->rxtx);
1731 spin_unlock_irqrestore(&cosa->lock, flags);
1734 clear_bit(IRQBIT, &cosa->rxtx);
1735 cosa_putstatus(cosa, 0);
1736 cosa_putdata8(cosa, cosa->txsize&0xff);
1738 debug_status_out(cosa, 0);
1739 debug_data_out(cosa, cosa->txsize&0xff);
1743 cosa_putstatus(cosa, SR_TX_INT_ENA);
1744 cosa_putdata16(cosa, ((cosa->txchan<<13) & 0xe000)
1745 | (cosa->txsize & 0x1fff));
1747 debug_status_out(cosa, SR_TX_INT_ENA);
1748 debug_data_out(cosa, ((cosa->txchan<<13) & 0xe000)
1749 | (cosa->txsize & 0x1fff));
1750 debug_data_in(cosa, cosa_getdata8(cosa));
1751 debug_status_out(cosa, 0);
1753 cosa_getdata8(cosa);
1755 cosa_putstatus(cosa, 0);
1758 if (cosa->busmaster) {
1759 unsigned long addr = virt_to_bus(cosa->txbuf);
1762 while (!(cosa_getstatus(cosa)&SR_TX_RDY)) {
1767 pr_info("status %x\n", cosa_getstatus(cosa));
1769 cosa_putdata16(cosa, (addr >> 16)&0xffff);
1772 while (!(cosa_getstatus(cosa)&SR_TX_RDY)) {
1778 cosa_putdata16(cosa, addr &0xffff);
1780 set_dma_mode(cosa->dma, DMA_MODE_CASCADE);
1781 enable_dma(cosa->dma);
1786 disable_dma(cosa->dma);
1787 clear_dma_ff(cosa->dma);
1788 set_dma_mode(cosa->dma, DMA_MODE_WRITE);
1789 set_dma_addr(cosa->dma, virt_to_bus(cosa->txbuf));
1790 set_dma_count(cosa->dma, cosa->txsize);
1791 enable_dma(cosa->dma);
1794 cosa_putstatus(cosa, SR_TX_DMA_ENA|SR_USR_INT_ENA);
1796 debug_status_out(cosa, SR_TX_DMA_ENA|SR_USR_INT_ENA);
1798 spin_unlock_irqrestore(&cosa->lock, flags);
1801 static inline void rx_interrupt(struct cosa_data *cosa, int status)
1805 pr_info("cosa%d: SR_UP_REQUEST\n", cosa->num);
1808 spin_lock_irqsave(&cosa->lock, flags);
1809 set_bit(RXBIT, &cosa->rxtx);
1811 if (is_8bit(cosa)) {
1812 if (!test_bit(IRQBIT, &cosa->rxtx)) {
1813 set_bit(IRQBIT, &cosa->rxtx);
1814 put_driver_status_nolock(cosa);
1815 cosa->rxsize = cosa_getdata8(cosa) <<8;
1817 debug_data_in(cosa, cosa->rxsize >> 8);
1819 spin_unlock_irqrestore(&cosa->lock, flags);
1822 clear_bit(IRQBIT, &cosa->rxtx);
1823 cosa->rxsize |= cosa_getdata8(cosa) & 0xff;
1825 debug_data_in(cosa, cosa->rxsize & 0xff);
1828 pr_info("cosa%d: receive rxsize = (0x%04x)\n",
1829 cosa->num, cosa->rxsize);
1833 cosa->rxsize = cosa_getdata16(cosa);
1835 debug_data_in(cosa, cosa->rxsize);
1838 pr_info("cosa%d: receive rxsize = (0x%04x)\n",
1839 cosa->num, cosa->rxsize);
1842 if (((cosa->rxsize & 0xe000) >> 13) >= cosa->nchannels) {
1844 cosa->name, cosa->rxsize);
1845 spin_unlock_irqrestore(&cosa->lock, flags);
1848 cosa->rxchan = cosa->chan + ((cosa->rxsize & 0xe000) >> 13);
1849 cosa->rxsize &= 0x1fff;
1850 spin_unlock_irqrestore(&cosa->lock, flags);
1852 cosa->rxbuf = NULL;
1853 if (cosa->rxchan->setup_rx)
1854 cosa->rxbuf = cosa->rxchan->setup_rx(cosa->rxchan, cosa->rxsize);
1856 if (!cosa->rxbuf) {
1858 pr_info("cosa%d: rejecting packet on channel %d\n",
1859 cosa->num, cosa->rxchan->num);
1860 cosa->rxbuf = cosa->bouncebuf;
1865 disable_dma(cosa->dma);
1866 clear_dma_ff(cosa->dma);
1867 set_dma_mode(cosa->dma, DMA_MODE_READ);
1868 if (cosa_dma_able(cosa->rxchan, cosa->rxbuf, cosa->rxsize & 0x1fff)) {
1869 set_dma_addr(cosa->dma, virt_to_bus(cosa->rxbuf));
1871 set_dma_addr(cosa->dma, virt_to_bus(cosa->bouncebuf));
1873 set_dma_count(cosa->dma, (cosa->rxsize&0x1fff));
1874 enable_dma(cosa->dma);
1876 spin_lock_irqsave(&cosa->lock, flags);
1877 cosa_putstatus(cosa, SR_RX_DMA_ENA|SR_USR_INT_ENA);
1878 if (!is_8bit(cosa) && (status & SR_TX_RDY))
1879 cosa_putdata8(cosa, DRIVER_RX_READY);
1881 debug_status_out(cosa, SR_RX_DMA_ENA|SR_USR_INT_ENA);
1882 if (!is_8bit(cosa) && (status & SR_TX_RDY))
1883 debug_data_cmd(cosa, DRIVER_RX_READY);
1885 spin_unlock_irqrestore(&cosa->lock, flags);
1888 static inline void eot_interrupt(struct cosa_data *cosa, int status)
1891 spin_lock_irqsave(&cosa->lock, flags);
1893 disable_dma(cosa->dma);
1894 clear_dma_ff(cosa->dma);
1896 if (test_bit(TXBIT, &cosa->rxtx)) {
1897 struct channel_data *chan = cosa->chan+cosa->txchan;
1899 if (chan->tx_done(chan, cosa->txsize))
1900 clear_bit(chan->num, &cosa->txbitmap);
1901 } else if (test_bit(RXBIT, &cosa->rxtx)) {
1905 pr_info("cosa%dc%d: done rx(0x%x)",
1906 cosa->num, cosa->rxchan->num, cosa->rxsize);
1907 for (i=0; i<cosa->rxsize; i++)
1908 pr_cont(" %02x", cosa->rxbuf[i]&0xff);
1913 if (cosa->rxbuf == cosa->bouncebuf)
1915 if (!cosa_dma_able(cosa->rxchan, cosa->rxbuf, cosa->rxsize))
1916 memcpy(cosa->rxbuf, cosa->bouncebuf, cosa->rxsize);
1917 if (cosa->rxchan->rx_done)
1918 if (cosa->rxchan->rx_done(cosa->rxchan))
1919 clear_bit(cosa->rxchan->num, &cosa->rxbitmap);
1921 pr_notice("cosa%d: unexpected EOT interrupt\n", cosa->num);
1930 cosa->rxtx = 0;
1931 put_driver_status_nolock(cosa);
1932 spin_unlock_irqrestore(&cosa->lock, flags);
1939 struct cosa_data *cosa = cosa_;
1941 status = cosa_getstatus(cosa);
1943 pr_info("cosa%d: got IRQ, status 0x%02x\n", cosa->num, status & 0xff);
1946 debug_status_in(cosa, status);
1950 tx_interrupt(cosa, status);
1953 rx_interrupt(cosa, status);
1956 eot_interrupt(cosa, status);
1964 pr_info("cosa%d: unknown status 0x%02x in IRQ after %d retries\n",
1965 cosa->num, status & 0xff, count);
1970 cosa->name, count);
1972 pr_info("%s: returning from IRQ\n", cosa->name);
1987 static void debug_status_in(struct cosa_data *cosa, int status)
2005 cosa->name,
2013 static void debug_status_out(struct cosa_data *cosa, int status)
2016 cosa->name,
2026 static void debug_data_in(struct cosa_data *cosa, int data)
2028 pr_info("%s: IO: data -> 0x%04x\n", cosa->name, data);
2031 static void debug_data_out(struct cosa_data *cosa, int data)
2033 pr_info("%s: IO: data <- 0x%04x\n", cosa->name, data);
2036 static void debug_data_cmd(struct cosa_data *cosa, int data)
2039 cosa->name, data,