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