1 /* $Id: cosa.c,v 1.31 2000/03/08 17:47:16 kas Exp $ */
4 * Copyright (C) 1995-1997 Jan "Yenya" Kasprzak <kas@fi.muni.cz>
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.
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.
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.
22 * The driver for the SRP and COSA synchronous serial cards.
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.
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.
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.
45 * Both types have downloadable firmware and communicate via ISA DMA.
46 * COSA can be also a bus-mastering device.
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.
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).
61 * The Linux driver was written by Jan "Yenya" Kasprzak <kas@fi.muni.cz>.
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 :-).
67 * THE AUTHOR USED THE FOLLOWING SOURCES WHEN PROGRAMMING THE DRIVER
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
76 * 5/25/1999 : Marcelo Tosatti <marcelo@conectiva.com.br>
77 * fixed a deadlock in cosa_sppp_open
80 /* ---------- Headers, macros, data structures ---------- */
82 #include <linux/module.h>
83 #include <linux/kernel.h>
84 #include <linux/slab.h>
85 #include <linux/poll.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>
96 #undef COSA_SLOW_IO /* for testing purposes only */
100 #include <asm/byteorder.h>
102 #include <net/syncppp.h>
105 /* Maximum length of the identification string. */
106 #define COSA_MAX_ID_STRING 128
108 /* Maximum length of the channel name */
109 #define COSA_MAX_NAME (sizeof("cosaXXXcXXX")+1)
111 /* Per-channel data structure */
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 */
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
);
130 /* Character device parts */
131 struct semaphore rsem
, wsem
;
134 wait_queue_head_t txwaitq
, rxwaitq
;
135 int tx_status
, rx_status
;
137 /* SPPP/HDLC device parts */
138 struct ppp_device pppdev
;
139 struct sk_buff
*rx_skb
, *tx_skb
;
140 struct net_device_stats stats
;
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? */
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? */
161 int usage
; /* usage count */
162 int txchan
, txsize
, rxsize
;
163 struct channel_data
*rxchan
;
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 */
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.
176 /* #define COSA_ISA_AUTOPROBE 1 */
179 * Character device major number. 117 was allocated for us.
180 * The value of 0 means to allocate a first free one.
182 static int cosa_major
= 117;
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.
189 #define CARD_MINOR_BITS 4 /* How many bits in minor number are reserved
190 * for the single card */
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 :-(
196 /* #define MAX_CARDS (1 << (8-CARD_MINOR_BITS)) */
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 */
204 * for cosa->rxtx - indicates whether either transmit or receive is
205 * in progress. These values are mean number of the bit.
211 #define COSA_MTU 2000 /* FIXME: I don't know this exactly */
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 */
217 #define TX_TIMEOUT (5*HZ)
219 /* Maybe the following should be allocated dynamically */
220 static struct cosa_data cosa_cards
[MAX_CARDS
];
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, };
228 static int io
[MAX_CARDS
+1];
229 static int dma
[MAX_CARDS
+1];
231 /* IRQ can be safely autoprobed */
232 static int irq
[MAX_CARDS
+1] = { -1, -1, -1, -1, -1, -1, 0, };
235 static struct class *cosa_class
;
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");
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");
250 /* I use this mainly for testing purposes */
252 #define cosa_outb outb_p
253 #define cosa_outw outw_p
254 #define cosa_inb inb_p
255 #define cosa_inw inw_p
257 #define cosa_outb outb
258 #define cosa_outw outw
263 #define is_8bit(cosa) (!(cosa->datareg & 0x08))
265 #define cosa_getstatus(cosa) (cosa_inb(cosa->statusreg))
266 #define cosa_putstatus(cosa, stat) (cosa_outb(stat, cosa->statusreg))
267 #define cosa_getdata16(cosa) (cosa_inw(cosa->datareg))
268 #define cosa_getdata8(cosa) (cosa_inb(cosa->datareg))
269 #define cosa_putdata16(cosa, dt) (cosa_outw(dt, cosa->datareg))
270 #define cosa_putdata8(cosa, dt) (cosa_outb(dt, cosa->datareg))
272 /* Initialization stuff */
273 static int cosa_probe(int ioaddr
, int irq
, int dma
);
276 static void cosa_enable_rx(struct channel_data
*chan
);
277 static void cosa_disable_rx(struct channel_data
*chan
);
278 static int cosa_start_tx(struct channel_data
*channel
, char *buf
, int size
);
279 static void cosa_kick(struct cosa_data
*cosa
);
280 static int cosa_dma_able(struct channel_data
*chan
, char *buf
, int data
);
282 /* SPPP/HDLC stuff */
283 static void sppp_channel_init(struct channel_data
*chan
);
284 static void sppp_channel_delete(struct channel_data
*chan
);
285 static int cosa_sppp_open(struct net_device
*d
);
286 static int cosa_sppp_close(struct net_device
*d
);
287 static void cosa_sppp_timeout(struct net_device
*d
);
288 static int cosa_sppp_tx(struct sk_buff
*skb
, struct net_device
*d
);
289 static char *sppp_setup_rx(struct channel_data
*channel
, int size
);
290 static int sppp_rx_done(struct channel_data
*channel
);
291 static int sppp_tx_done(struct channel_data
*channel
, int size
);
292 static int cosa_sppp_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
);
293 static struct net_device_stats
*cosa_net_stats(struct net_device
*dev
);
295 /* Character device */
296 static void chardev_channel_init(struct channel_data
*chan
);
297 static char *chrdev_setup_rx(struct channel_data
*channel
, int size
);
298 static int chrdev_rx_done(struct channel_data
*channel
);
299 static int chrdev_tx_done(struct channel_data
*channel
, int size
);
300 static ssize_t
cosa_read(struct file
*file
,
301 char __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
);
313 static const struct file_operations cosa_fops
= {
314 .owner
= THIS_MODULE
,
319 .ioctl
= cosa_chardev_ioctl
,
321 .release
= cosa_release
,
322 #ifdef COSA_FASYNC_WORKING
323 .fasync
= cosa_fasync
,
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
);
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
);
339 /* Auxilliary functions */
340 static int get_wait_data(struct cosa_data
*cosa
);
341 static int put_wait_data(struct cosa_data
*cosa
, int data
);
342 static int puthexnumber(struct cosa_data
*cosa
, int number
);
343 static void put_driver_status(struct cosa_data
*cosa
);
344 static void put_driver_status_nolock(struct cosa_data
*cosa
);
346 /* Interrupt handling */
347 static irqreturn_t
cosa_interrupt(int irq
, void *cosa
);
349 /* I/O ops debugging */
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
);
359 /* ---------- Initialization stuff ---------- */
361 static int __init
cosa_init(void)
365 printk(KERN_INFO
"cosa v1.08 (c) 1997-2000 Jan Kasprzak <kas@fi.muni.cz>\n");
367 printk(KERN_INFO
"cosa: SMP found. Please mail any success/failure reports to the author.\n");
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",
377 if (!(cosa_major
=register_chrdev(0, "cosa", &cosa_fops
))) {
378 printk(KERN_WARNING
"cosa: unable to register chardev\n");
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
]);
388 printk(KERN_WARNING
"cosa: no devices found.\n");
389 unregister_chrdev(cosa_major
, "cosa");
393 cosa_class
= class_create(THIS_MODULE
, "cosa");
394 if (IS_ERR(cosa_class
)) {
395 err
= PTR_ERR(cosa_class
);
398 for (i
=0; i
<nr_cards
; i
++) {
399 class_device_create(cosa_class
, NULL
, MKDEV(cosa_major
, i
),
406 unregister_chrdev(cosa_major
, "cosa");
410 module_init(cosa_init
);
412 static void __exit
cosa_exit(void)
414 struct cosa_data
*cosa
;
416 printk(KERN_INFO
"Unloading the cosa module\n");
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
);
427 /* Clean up the per-card data */
429 kfree(cosa
->bouncebuf
);
430 free_irq(cosa
->irq
, cosa
);
432 release_region(cosa
->datareg
,is_8bit(cosa
)?2:4);
434 unregister_chrdev(cosa_major
, "cosa");
436 module_exit(cosa_exit
);
439 * This function should register all the net devices needed for the
442 static __inline__
void channel_init(struct channel_data
*chan
)
444 sprintf(chan
->name
, "cosa%dc%d", chan
->cosa
->num
, chan
->num
);
446 /* Initialize the chardev data structures */
447 chardev_channel_init(chan
);
449 /* Register the sppp interface */
450 sppp_channel_init(chan
);
453 static int cosa_probe(int base
, int irq
, int dma
)
455 struct cosa_data
*cosa
= cosa_cards
+nr_cards
;
458 memset(cosa
, 0, sizeof(struct cosa_data
));
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
);
466 /* I/O address should be between 0x100 and 0x3ff and should be
468 if (base
< 0x100 || base
> 0x3ff || base
& 0x7) {
469 printk (KERN_INFO
"cosa_probe: invalid I/O address 0x%x\n",
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
);
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
);
487 cosa
->datareg
= base
;
488 cosa
->statusreg
= is_8bit(cosa
)?base
+1:base
+2;
489 spin_lock_init(&cosa
->lock
);
491 if (!request_region(base
, is_8bit(cosa
)?2:4,"cosa"))
494 if (cosa_reset_and_read_id(cosa
, cosa
->id_string
) < 0) {
495 printk(KERN_DEBUG
"cosa: probe at 0x%x failed.\n", base
);
500 /* Test the validity of identification string */
501 if (!strncmp(cosa
->id_string
, "SRP", 3))
503 else if (!strncmp(cosa
->id_string
, "COSA", 4))
504 cosa
->type
= is_8bit(cosa
)? "cosa8": "cosa16";
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",
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
);
521 /* Now do IRQ autoprobe */
524 /* printk(KERN_INFO "IRQ autoprobe\n"); */
525 irqs
= probe_irq_on();
527 * Enable interrupt on tx buffer empty (it sure is)
529 * FIXME: When this code is not used as module, we should
530 * probably call udelay() instead of the interruptible sleep.
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 */
542 printk (KERN_INFO
"cosa IRQ autoprobe: multiple interrupts obtained (%d, board at 0x%x)\n",
548 printk (KERN_INFO
"cosa IRQ autoprobe: no interrupt obtained (board at 0x%x)\n",
555 cosa
->num
= nr_cards
;
557 cosa
->nchannels
= 2; /* FIXME: how to determine this? */
559 if (request_irq(cosa
->irq
, cosa_interrupt
, 0, cosa
->type
, cosa
)) {
563 if (request_dma(cosa
->dma
, cosa
->type
)) {
568 cosa
->bouncebuf
= kmalloc(COSA_MTU
, GFP_KERNEL
|GFP_DMA
);
569 if (!cosa
->bouncebuf
) {
573 sprintf(cosa
->name
, "cosa%d", cosa
->num
);
575 /* Initialize the per-channel data */
576 cosa
->chan
= kmalloc(sizeof(struct channel_data
)*cosa
->nchannels
,
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
);
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
);
595 kfree(cosa
->bouncebuf
);
599 free_irq(cosa
->irq
, cosa
);
601 release_region(cosa
->datareg
,is_8bit(cosa
)?2:4);
602 printk(KERN_NOTICE
"cosa%d: allocating resources failed\n",
608 /*---------- SPPP/HDLC netdevice ---------- */
610 static void cosa_setup(struct net_device
*d
)
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
;
621 static void sppp_channel_init(struct channel_data
*chan
)
623 struct net_device
*d
;
624 chan
->if_ptr
= &chan
->pppdev
;
625 d
= alloc_netdev(0, chan
->name
, cosa_setup
);
627 printk(KERN_WARNING
"%s: alloc_netdev failed.\n", chan
->name
);
630 chan
->pppdev
.dev
= d
;
631 d
->base_addr
= chan
->cosa
->datareg
;
632 d
->irq
= chan
->cosa
->irq
;
633 d
->dma
= chan
->cosa
->dma
;
635 sppp_attach(&chan
->pppdev
);
636 if (register_netdev(d
)) {
637 printk(KERN_WARNING
"%s: register_netdev failed.\n", d
->name
);
640 chan
->pppdev
.dev
= NULL
;
645 static void sppp_channel_delete(struct channel_data
*chan
)
647 unregister_netdev(chan
->pppdev
.dev
);
648 sppp_detach(chan
->pppdev
.dev
);
649 free_netdev(chan
->pppdev
.dev
);
650 chan
->pppdev
.dev
= NULL
;
653 static int cosa_sppp_open(struct net_device
*d
)
655 struct channel_data
*chan
= d
->priv
;
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
);
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
);
671 chan
->setup_rx
= sppp_setup_rx
;
672 chan
->tx_done
= sppp_tx_done
;
673 chan
->rx_done
= sppp_rx_done
;
676 spin_unlock_irqrestore(&chan
->cosa
->lock
, flags
);
680 spin_lock_irqsave(&chan
->cosa
->lock
, flags
);
684 spin_unlock_irqrestore(&chan
->cosa
->lock
, flags
);
688 netif_start_queue(d
);
689 cosa_enable_rx(chan
);
693 static int cosa_sppp_tx(struct sk_buff
*skb
, struct net_device
*dev
)
695 struct channel_data
*chan
= dev
->priv
;
697 netif_stop_queue(dev
);
700 cosa_start_tx(chan
, skb
->data
, skb
->len
);
704 static void cosa_sppp_timeout(struct net_device
*dev
)
706 struct channel_data
*chan
= dev
->priv
;
708 if (test_bit(RXBIT
, &chan
->cosa
->rxtx
)) {
709 chan
->stats
.rx_errors
++;
710 chan
->stats
.rx_missed_errors
++;
712 chan
->stats
.tx_errors
++;
713 chan
->stats
.tx_aborted_errors
++;
715 cosa_kick(chan
->cosa
);
717 dev_kfree_skb(chan
->tx_skb
);
720 netif_wake_queue(dev
);
723 static int cosa_sppp_close(struct net_device
*d
)
725 struct channel_data
*chan
= d
->priv
;
730 cosa_disable_rx(chan
);
731 spin_lock_irqsave(&chan
->cosa
->lock
, flags
);
733 kfree_skb(chan
->rx_skb
);
737 kfree_skb(chan
->tx_skb
);
742 spin_unlock_irqrestore(&chan
->cosa
->lock
, flags
);
746 static char *sppp_setup_rx(struct channel_data
*chan
, int size
)
749 * We can safely fall back to non-dma-able memory, because we have
750 * the cosa->bouncebuf pre-allocated.
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",
758 chan
->stats
.rx_dropped
++;
761 chan
->pppdev
.dev
->trans_start
= jiffies
;
762 return skb_put(chan
->rx_skb
, size
);
765 static int sppp_rx_done(struct channel_data
*chan
)
768 printk(KERN_WARNING
"%s: rx_done with empty skb!\n",
770 chan
->stats
.rx_errors
++;
771 chan
->stats
.rx_frame_errors
++;
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
);
781 chan
->pppdev
.dev
->last_rx
= jiffies
;
786 static int sppp_tx_done(struct channel_data
*chan
, int size
)
789 printk(KERN_WARNING
"%s: tx_done with empty skb!\n",
791 chan
->stats
.tx_errors
++;
792 chan
->stats
.tx_aborted_errors
++;
795 dev_kfree_skb_irq(chan
->tx_skb
);
797 chan
->stats
.tx_packets
++;
798 chan
->stats
.tx_bytes
+= size
;
799 netif_wake_queue(chan
->pppdev
.dev
);
803 static struct net_device_stats
*cosa_net_stats(struct net_device
*dev
)
805 struct channel_data
*chan
= dev
->priv
;
810 /*---------- Character device ---------- */
812 static void chardev_channel_init(struct channel_data
*chan
)
814 init_MUTEX(&chan
->rsem
);
815 init_MUTEX(&chan
->wsem
);
818 static ssize_t
cosa_read(struct file
*file
,
819 char __user
*buf
, size_t count
, loff_t
*ppos
)
821 DECLARE_WAITQUEUE(wait
, current
);
823 struct channel_data
*chan
= file
->private_data
;
824 struct cosa_data
*cosa
= chan
->cosa
;
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
);
832 if (down_interruptible(&chan
->rsem
))
835 if ((chan
->rxdata
= kmalloc(COSA_MTU
, GFP_DMA
|GFP_KERNEL
)) == NULL
) {
836 printk(KERN_INFO
"%s: cosa_read() - OOM\n", cosa
->name
);
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
);
849 spin_lock_irqsave(&cosa
->lock
, flags
);
850 if (signal_pending(current
) && chan
->rx_status
== 0) {
852 remove_wait_queue(&chan
->rxwaitq
, &wait
);
853 current
->state
= TASK_RUNNING
;
854 spin_unlock_irqrestore(&cosa
->lock
, flags
);
859 remove_wait_queue(&chan
->rxwaitq
, &wait
);
860 current
->state
= TASK_RUNNING
;
862 count
= chan
->rxsize
;
863 spin_unlock_irqrestore(&cosa
->lock
, flags
);
866 if (copy_to_user(buf
, kbuf
, count
)) {
874 static char *chrdev_setup_rx(struct channel_data
*chan
, int size
)
876 /* Expect size <= COSA_MTU */
881 static int chrdev_rx_done(struct channel_data
*chan
)
883 if (chan
->rx_status
) { /* Reader has died */
888 wake_up_interruptible(&chan
->rxwaitq
);
893 static ssize_t
cosa_write(struct file
*file
,
894 const char __user
*buf
, size_t count
, loff_t
*ppos
)
896 DECLARE_WAITQUEUE(wait
, current
);
897 struct channel_data
*chan
= file
->private_data
;
898 struct cosa_data
*cosa
= chan
->cosa
;
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
);
907 if (down_interruptible(&chan
->wsem
))
910 if (count
> COSA_MTU
)
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",
920 if (copy_from_user(kbuf
, buf
, count
)) {
926 cosa_start_tx(chan
, kbuf
, count
);
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
);
934 spin_lock_irqsave(&cosa
->lock
, flags
);
935 if (signal_pending(current
) && chan
->tx_status
== 0) {
937 remove_wait_queue(&chan
->txwaitq
, &wait
);
938 current
->state
= TASK_RUNNING
;
940 spin_unlock_irqrestore(&cosa
->lock
, flags
);
944 remove_wait_queue(&chan
->txwaitq
, &wait
);
945 current
->state
= TASK_RUNNING
;
947 spin_unlock_irqrestore(&cosa
->lock
, flags
);
952 static int chrdev_tx_done(struct channel_data
*chan
, int size
)
954 if (chan
->tx_status
) { /* Writer was interrupted */
959 wake_up_interruptible(&chan
->txwaitq
);
963 static unsigned int cosa_poll(struct file
*file
, poll_table
*poll
)
965 printk(KERN_INFO
"cosa_poll is here\n");
969 static int cosa_open(struct inode
*inode
, struct file
*file
)
971 struct cosa_data
*cosa
;
972 struct channel_data
*chan
;
976 if ((n
=iminor(file
->f_path
.dentry
->d_inode
)>>CARD_MINOR_BITS
)
981 if ((n
=iminor(file
->f_path
.dentry
->d_inode
)
982 & ((1<<CARD_MINOR_BITS
)-1)) >= cosa
->nchannels
)
984 chan
= cosa
->chan
+ n
;
986 file
->private_data
= chan
;
988 spin_lock_irqsave(&cosa
->lock
, flags
);
990 if (chan
->usage
< 0) { /* in netdev mode */
991 spin_unlock_irqrestore(&cosa
->lock
, flags
);
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
);
1004 static int cosa_release(struct inode
*inode
, struct file
*file
)
1006 struct channel_data
*channel
= file
->private_data
;
1007 struct cosa_data
*cosa
;
1008 unsigned long flags
;
1010 cosa
= channel
->cosa
;
1011 spin_lock_irqsave(&cosa
->lock
, flags
);
1014 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1018 #ifdef COSA_FASYNC_WORKING
1019 static struct fasync_struct
*fasync
[256] = { NULL
, };
1021 /* To be done ... */
1022 static int cosa_fasync(struct inode
*inode
, struct file
*file
, int on
)
1024 int port
= iminor(inode
);
1025 int rv
= fasync_helper(inode
, file
, on
, &fasync
[port
]);
1026 return rv
< 0 ? rv
: 0;
1031 /* ---------- Ioctls ---------- */
1034 * Ioctl subroutines can safely be made inline, because they are called
1035 * only from cosa_ioctl().
1037 static inline int cosa_reset(struct cosa_data
*cosa
)
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
);
1048 printk(KERN_INFO
"cosa%d: resetting device: %s\n", cosa
->num
,
1050 cosa
->firmware_status
|= COSA_FW_RESET
;
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
)
1057 struct cosa_download d
;
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
);
1069 if (copy_from_user(&d
, arg
, sizeof(d
)))
1072 if (d
.addr
< 0 || d
.addr
> COSA_MAX_FIRMWARE_SIZE
)
1074 if (d
.len
< 0 || d
.len
> COSA_MAX_FIRMWARE_SIZE
)
1078 /* If something fails, force the user to reset the card */
1079 cosa
->firmware_status
&= ~(COSA_FW_RESET
|COSA_FW_DOWNLOAD
);
1081 i
= download(cosa
, d
.code
, d
.len
, d
.addr
);
1083 printk(KERN_NOTICE
"cosa%d: microcode download failed: %d\n",
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
;
1093 /* High-level function to read COSA memory. Calls readmem() */
1094 static inline int cosa_readmem(struct cosa_data
*cosa
, void __user
*arg
)
1096 struct cosa_download d
;
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
);
1109 if (copy_from_user(&d
, arg
, sizeof(d
)))
1112 /* If something fails, force the user to reset the card */
1113 cosa
->firmware_status
&= ~COSA_FW_RESET
;
1115 i
= readmem(cosa
, d
.code
, d
.len
, d
.addr
);
1117 printk(KERN_NOTICE
"cosa%d: reading memory failed: %d\n",
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
;
1127 /* High-level function to start microcode. Calls startmicrocode(). */
1128 static inline int cosa_start(struct cosa_data
*cosa
, int address
)
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
);
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
);
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
);
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
;
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
)
1158 int l
= strlen(cosa
->id_string
)+1;
1159 if (copy_to_user(string
, cosa
->id_string
, l
))
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
)
1167 int l
= strlen(cosa
->type
)+1;
1168 if (copy_to_user(string
, cosa
->type
, l
))
1173 static int cosa_ioctl_common(struct cosa_data
*cosa
,
1174 struct channel_data
*channel
, unsigned int cmd
, unsigned long arg
)
1176 void __user
*argp
= (void __user
*)arg
;
1178 case COSAIORSET
: /* Reset the device */
1179 if (!capable(CAP_NET_ADMIN
))
1181 return cosa_reset(cosa
);
1182 case COSAIOSTRT
: /* Start the firmware */
1183 if (!capable(CAP_SYS_RAWIO
))
1185 return cosa_start(cosa
, arg
);
1186 case COSAIODOWNLD
: /* Download the firmware */
1187 if (!capable(CAP_SYS_RAWIO
))
1190 return cosa_download(cosa
, argp
);
1192 if (!capable(CAP_SYS_RAWIO
))
1194 return cosa_readmem(cosa
, argp
);
1196 return cosa_gettype(cosa
, argp
);
1198 return cosa_getidstr(cosa
, argp
);
1202 return cosa
->nchannels
;
1204 if (!capable(CAP_SYS_RAWIO
))
1208 if (arg
!= COSA_BM_OFF
&& arg
!= COSA_BM_ON
)
1210 cosa
->busmaster
= arg
;
1213 return cosa
->busmaster
;
1215 return -ENOIOCTLCMD
;
1218 static int cosa_sppp_ioctl(struct net_device
*dev
, struct ifreq
*ifr
,
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
);
1230 static int cosa_chardev_ioctl(struct inode
*inode
, struct file
*file
,
1231 unsigned int cmd
, unsigned long arg
)
1233 struct channel_data
*channel
= file
->private_data
;
1234 struct cosa_data
*cosa
= channel
->cosa
;
1235 return cosa_ioctl_common(cosa
, channel
, cmd
, arg
);
1239 /*---------- HW layer interface ---------- */
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.
1245 static void cosa_enable_rx(struct channel_data
*chan
)
1247 struct cosa_data
*cosa
= chan
->cosa
;
1249 if (!test_and_set_bit(chan
->num
, &cosa
->rxbitmap
))
1250 put_driver_status(cosa
);
1253 static void cosa_disable_rx(struct channel_data
*chan
)
1255 struct cosa_data
*cosa
= chan
->cosa
;
1257 if (test_and_clear_bit(chan
->num
, &cosa
->rxbitmap
))
1258 put_driver_status(cosa
);
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.
1267 static int cosa_start_tx(struct channel_data
*chan
, char *buf
, int len
)
1269 struct cosa_data
*cosa
= chan
->cosa
;
1270 unsigned long flags
;
1274 printk(KERN_INFO
"cosa%dc%d: starting tx(0x%x)", chan
->cosa
->num
,
1276 for (i
=0; i
<len
; i
++)
1277 printk(" %02x", buf
[i
]&0xff);
1280 spin_lock_irqsave(&cosa
->lock
, flags
);
1284 chan
->txsize
= COSA_MTU
;
1285 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1287 /* Tell the firmware we are ready */
1288 set_bit(chan
->num
, &cosa
->txbitmap
);
1289 put_driver_status(cosa
);
1294 static void put_driver_status(struct cosa_data
*cosa
)
1296 unsigned long flags
;
1299 spin_lock_irqsave(&cosa
->lock
, flags
);
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);
1306 if (cosa
->rxbitmap
|cosa
->txbitmap
) {
1307 if (!cosa
->enabled
) {
1308 cosa_putstatus(cosa
, SR_RX_INT_ENA
);
1310 debug_status_out(cosa
, SR_RX_INT_ENA
);
1314 } else if (cosa
->enabled
) {
1316 cosa_putstatus(cosa
, 0);
1318 debug_status_out(cosa
, 0);
1321 cosa_putdata8(cosa
, status
);
1323 debug_data_cmd(cosa
, status
);
1326 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1329 static void put_driver_status_nolock(struct cosa_data
*cosa
)
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);
1338 if (cosa
->rxbitmap
|cosa
->txbitmap
) {
1339 cosa_putstatus(cosa
, SR_RX_INT_ENA
);
1341 debug_status_out(cosa
, SR_RX_INT_ENA
);
1345 cosa_putstatus(cosa
, 0);
1347 debug_status_out(cosa
, 0);
1351 cosa_putdata8(cosa
, status
);
1353 debug_data_cmd(cosa
, status
);
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.
1362 static void cosa_kick(struct cosa_data
*cosa
)
1364 unsigned long flags
, flags1
;
1365 char *s
= "(probably) IRQ";
1367 if (test_bit(RXBIT
, &cosa
->rxtx
))
1369 if (test_bit(TXBIT
, &cosa
->rxtx
))
1372 printk(KERN_INFO
"%s: %s timeout - restarting.\n", cosa
->name
, s
);
1373 spin_lock_irqsave(&cosa
->lock
, flags
);
1376 flags1
= claim_dma_lock();
1377 disable_dma(cosa
->dma
);
1378 clear_dma_ff(cosa
->dma
);
1379 release_dma_lock(flags1
);
1381 /* FIXME: Anything else? */
1383 cosa_putstatus(cosa
, 0);
1385 (void) cosa_getdata8(cosa
);
1387 cosa_putdata8(cosa
, 0);
1389 put_driver_status_nolock(cosa
);
1390 spin_unlock_irqrestore(&cosa
->lock
, flags
);
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.
1398 static int cosa_dma_able(struct channel_data
*chan
, char *buf
, int len
)
1401 unsigned long b
= (unsigned long)buf
;
1402 if (b
+len
>= MAX_DMA_ADDRESS
)
1404 if ((b
^ (b
+len
)) & 0x10000) {
1406 printk(KERN_INFO
"%s: packet spanning a 64k boundary\n",
1414 /* ---------- The SRP/COSA ROM monitor functions ---------- */
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).
1424 static int download(struct cosa_data
*cosa
, const char __user
*microcode
, int length
, int address
)
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;
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;
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;
1443 #ifndef SRP_DOWNLOAD_AT_BOOT
1444 if (get_user(c
, microcode
))
1445 return -23; /* ??? */
1449 if (put_wait_data(cosa
, c
) == -1)
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;
1458 printk(KERN_DEBUG
"cosa%d: download completed.\n", cosa
->num
);
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>".
1469 static int startmicrocode(struct cosa_data
*cosa
, int address
)
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;
1475 if (puthexnumber(cosa
, address
) < 0) return -4;
1476 if (put_wait_data(cosa
, '\r') == -1) return -5;
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;
1484 printk(KERN_DEBUG
"cosa%d: microcode started\n", cosa
->num
);
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).
1495 * This routine is not needed during the normal operation and serves
1496 * for debugging purposes only.
1498 static int readmem(struct cosa_data
*cosa
, char __user
*microcode
, int length
, int address
)
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;
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;
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;
1516 if ((i
=get_wait_data(cosa
)) == -1) {
1517 printk (KERN_INFO
"cosa: 0x%04x bytes remaining\n",
1523 if (put_user(c
, microcode
))
1524 return -23; /* ??? */
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;
1535 printk(KERN_DEBUG
"cosa%d: readmem completed.\n", cosa
->num
);
1541 * This function resets the device and reads the initial prompt
1542 * of the device's ROM monitor.
1544 static int cosa_reset_and_read_id(struct cosa_data
*cosa
, char *idstring
)
1546 int i
=0, id
=0, prev
=0, curr
=0;
1548 /* Reset the card ... */
1549 cosa_putstatus(cosa
, 0);
1550 cosa_getdata8(cosa
);
1551 cosa_putstatus(cosa
, SR_RST
);
1557 /* Disable all IRQs from the card */
1558 cosa_putstatus(cosa
, 0);
1561 * Try to read the ID string. The card then prints out the
1562 * identification string ended by the "\n\x2e".
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.
1568 for (i
=0; i
<COSA_MAX_ID_STRING
-1; i
++, prev
=curr
) {
1569 if ((curr
= get_wait_data(cosa
)) == -1) {
1573 if (curr
!= '\r' && curr
!= '\n' && curr
!= 0x2e)
1574 idstring
[id
++] = curr
;
1575 if (curr
== 0x2e && prev
== '\n')
1578 /* Perhaps we should fail when i==COSA_MAX_ID_STRING-1 ? */
1579 idstring
[id
] = '\0';
1584 /* ---------- Auxiliary routines for COSA/SRP monitor ---------- */
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.
1591 static int get_wait_data(struct cosa_data
*cosa
)
1596 /* read data and return them */
1597 if (cosa_getstatus(cosa
) & SR_RX_RDY
) {
1599 r
= cosa_getdata8(cosa
);
1601 printk(KERN_INFO
"cosa: get_wait_data returning after %d retries\n", 999-retries
);
1605 /* sleep if not ready to read */
1606 schedule_timeout_interruptible(1);
1608 printk(KERN_INFO
"cosa: timeout in get_wait_data (status 0x%x)\n",
1609 cosa_getstatus(cosa
));
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).
1618 static int put_wait_data(struct cosa_data
*cosa
, int data
)
1622 /* read data and return them */
1623 if (cosa_getstatus(cosa
) & SR_TX_RDY
) {
1624 cosa_putdata8(cosa
, data
);
1626 printk(KERN_INFO
"Putdata: %d retries\n", 999-retries
);
1631 /* sleep if not ready to read */
1632 schedule_timeout_interruptible(1);
1635 printk(KERN_INFO
"cosa%d: timeout in put_wait_data (status 0x%x)\n",
1636 cosa
->num
, cosa_getstatus(cosa
));
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.
1646 static int puthexnumber(struct cosa_data
*cosa
, int number
)
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",
1659 if (get_wait_data(cosa
) != temp
[i
]) {
1660 printk(KERN_NOTICE
"cosa%d: puthexhumber failed to read echo of byte %d\n",
1669 /* ---------- Interrupt routines ---------- */
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.
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 :-(
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.
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.
1702 static inline void tx_interrupt(struct cosa_data
*cosa
, int status
)
1704 unsigned long flags
, flags1
;
1706 printk(KERN_INFO
"cosa%d: SR_DOWN_REQUEST status=0x%04x\n",
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 */
1714 if (!cosa
->txbitmap
) {
1715 printk(KERN_WARNING
"%s: No channel wants data "
1716 "in TX IRQ. Expect DMA timeout.",
1718 put_driver_status_nolock(cosa
);
1719 clear_bit(TXBIT
, &cosa
->rxtx
);
1720 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1726 if (cosa
->txchan
>= cosa
->nchannels
)
1728 if (!(cosa
->txbitmap
& (1<<cosa
->txchan
)))
1730 if (~status
& (1 << (cosa
->txchan
+DRIVER_TXMAP_SHIFT
)))
1732 /* in second pass, accept first ready-to-TX channel */
1733 if (i
> cosa
->nchannels
) {
1734 /* Can be safely ignored */
1736 printk(KERN_DEBUG
"%s: Forcing TX "
1737 "to not-ready channel %d\n",
1738 cosa
->name
, cosa
->txchan
);
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
;
1749 memcpy(cosa
->bouncebuf
, cosa
->chan
[cosa
->txchan
].txbuf
,
1751 cosa
->txbuf
= cosa
->bouncebuf
;
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));
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
));
1766 cosa_getdata8(cosa
);
1768 set_bit(IRQBIT
, &cosa
->rxtx
);
1769 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1772 clear_bit(IRQBIT
, &cosa
->rxtx
);
1773 cosa_putstatus(cosa
, 0);
1774 cosa_putdata8(cosa
, cosa
->txsize
&0xff);
1776 debug_status_out(cosa
, 0);
1777 debug_data_out(cosa
, cosa
->txsize
&0xff);
1781 cosa_putstatus(cosa
, SR_TX_INT_ENA
);
1782 cosa_putdata16(cosa
, ((cosa
->txchan
<<13) & 0xe000)
1783 | (cosa
->txsize
& 0x1fff));
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);
1791 cosa_getdata8(cosa
);
1793 cosa_putstatus(cosa
, 0);
1796 if (cosa
->busmaster
) {
1797 unsigned long addr
= virt_to_bus(cosa
->txbuf
);
1799 printk(KERN_INFO
"busmaster IRQ\n");
1800 while (!(cosa_getstatus(cosa
)&SR_TX_RDY
)) {
1803 if (count
> 1000) break;
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);
1810 while (!(cosa_getstatus(cosa
)&SR_TX_RDY
)) {
1812 if (count
> 1000) break;
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
);
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
);
1832 cosa_putstatus(cosa
, SR_TX_DMA_ENA
|SR_USR_INT_ENA
);
1834 debug_status_out(cosa
, SR_TX_DMA_ENA
|SR_USR_INT_ENA
);
1836 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1839 static inline void rx_interrupt(struct cosa_data
*cosa
, int status
)
1841 unsigned long flags
;
1843 printk(KERN_INFO
"cosa%d: SR_UP_REQUEST\n", cosa
->num
);
1846 spin_lock_irqsave(&cosa
->lock
, flags
);
1847 set_bit(RXBIT
, &cosa
->rxtx
);
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;
1855 debug_data_in(cosa
, cosa
->rxsize
>> 8);
1857 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1860 clear_bit(IRQBIT
, &cosa
->rxtx
);
1861 cosa
->rxsize
|= cosa_getdata8(cosa
) & 0xff;
1863 debug_data_in(cosa
, cosa
->rxsize
& 0xff);
1866 printk(KERN_INFO
"cosa%d: receive rxsize = (0x%04x).\n",
1867 cosa
->num
, cosa
->rxsize
);
1871 cosa
->rxsize
= cosa_getdata16(cosa
);
1873 debug_data_in(cosa
, cosa
->rxsize
);
1876 printk(KERN_INFO
"cosa%d: receive rxsize = (0x%04x).\n",
1877 cosa
->num
, cosa
->rxsize
);
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
);
1886 cosa
->rxchan
= cosa
->chan
+ ((cosa
->rxsize
& 0xe000) >> 13);
1887 cosa
->rxsize
&= 0x1fff;
1888 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1891 if (cosa
->rxchan
->setup_rx
)
1892 cosa
->rxbuf
= cosa
->rxchan
->setup_rx(cosa
->rxchan
, cosa
->rxsize
);
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
;
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
));
1909 set_dma_addr(cosa
->dma
, virt_to_bus(cosa
->bouncebuf
));
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
);
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
);
1923 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1926 static inline void eot_interrupt(struct cosa_data
*cosa
, int status
)
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
;
1937 if (chan
->tx_done(chan
, cosa
->txsize
))
1938 clear_bit(chan
->num
, &cosa
->txbitmap
);
1939 } else if (test_bit(RXBIT
, &cosa
->rxtx
)) {
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);
1950 /* Packet for unknown channel? */
1951 if (cosa
->rxbuf
== cosa
->bouncebuf
)
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
);
1959 printk(KERN_NOTICE
"cosa%d: unexpected EOT interrupt\n",
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
1970 put_driver_status_nolock(cosa
);
1971 spin_unlock_irqrestore(&cosa
->lock
, flags
);
1974 static irqreturn_t
cosa_interrupt(int irq
, void *cosa_
)
1978 struct cosa_data
*cosa
= cosa_
;
1980 status
= cosa_getstatus(cosa
);
1982 printk(KERN_INFO
"cosa%d: got IRQ, status 0x%02x\n", cosa
->num
,
1986 debug_status_in(cosa
, status
);
1988 switch (status
& SR_CMD_FROM_SRP_MASK
) {
1989 case SR_DOWN_REQUEST
:
1990 tx_interrupt(cosa
, status
);
1993 rx_interrupt(cosa
, status
);
1995 case SR_END_OF_TRANSFER
:
1996 eot_interrupt(cosa
, status
);
1999 /* We may be too fast for SRP. Try to wait a bit more. */
2000 if (count
++ < 100) {
2004 printk(KERN_INFO
"cosa%d: unknown status 0x%02x in IRQ after %d retries\n",
2005 cosa
->num
, status
& 0xff, count
);
2009 printk(KERN_INFO
"%s: %d-times got unknown status in IRQ\n",
2012 printk(KERN_INFO
"%s: returning from IRQ\n", cosa
->name
);
2018 /* ---------- I/O debugging routines ---------- */
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
2026 static void debug_status_in(struct cosa_data
*cosa
, int status
)
2029 switch(status
& SR_CMD_FROM_SRP_MASK
) {
2033 case SR_DOWN_REQUEST
:
2036 case SR_END_OF_TRANSFER
:
2043 printk(KERN_INFO
"%s: IO: status -> 0x%02x (%s%s%s%s)\n",
2046 status
& SR_USR_RQ
? "USR_RQ|":"",
2047 status
& SR_TX_RDY
? "TX_RDY|":"",
2048 status
& SR_RX_RDY
? "RX_RDY|":"",
2052 static void debug_status_out(struct cosa_data
*cosa
, int status
)
2054 printk(KERN_INFO
"%s: IO: status <- 0x%02x (%s%s%s%s%s%s)\n",
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");
2065 static void debug_data_in(struct cosa_data
*cosa
, int data
)
2067 printk(KERN_INFO
"%s: IO: data -> 0x%04x\n", cosa
->name
, data
);
2070 static void debug_data_out(struct cosa_data
*cosa
, int data
)
2072 printk(KERN_INFO
"%s: IO: data <- 0x%04x\n", cosa
->name
, data
);
2075 static void debug_data_cmd(struct cosa_data
*cosa
, int data
)
2077 printk(KERN_INFO
"%s: IO: data <- 0x%04x (%s|%s)\n",
2079 data
& SR_RDY_RCV
? "RX_RDY" : "!rx_rdy",
2080 data
& SR_RDY_SND
? "TX_RDY" : "!tx_rdy");
2084 /* EOF -- this file has not been truncated */