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