drivers/net/wan/cosa.c

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