blob: 848ea6a399f236b14cc5d9a79dd38038e0331aec [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* $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>
Krzysztof Hałasaaca257532008-07-01 23:40:29 +02005 * Generic HDLC port Copyright (C) 2008 Krzysztof Halasa <khc@pm.waw.pl>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22/*
23 * The driver for the SRP and COSA synchronous serial cards.
24 *
25 * HARDWARE INFO
26 *
27 * Both cards are developed at the Institute of Computer Science,
28 * Masaryk University (http://www.ics.muni.cz/). The hardware is
29 * developed by Jiri Novotny <novotny@ics.muni.cz>. More information
30 * and the photo of both cards is available at
31 * http://www.pavoucek.cz/cosa.html. The card documentation, firmwares
32 * and other goods can be downloaded from ftp://ftp.ics.muni.cz/pub/cosa/.
33 * For Linux-specific utilities, see below in the "Software info" section.
34 * If you want to order the card, contact Jiri Novotny.
35 *
36 * The SRP (serial port?, the Czech word "srp" means "sickle") card
37 * is a 2-port intelligent (with its own 8-bit CPU) synchronous serial card
38 * with V.24 interfaces up to 80kb/s each.
39 *
40 * The COSA (communication serial adapter?, the Czech word "kosa" means
41 * "scythe") is a next-generation sync/async board with two interfaces
42 * - currently any of V.24, X.21, V.35 and V.36 can be selected.
43 * It has a 16-bit SAB80166 CPU and can do up to 10 Mb/s per channel.
44 * The 8-channels version is in development.
45 *
46 * Both types have downloadable firmware and communicate via ISA DMA.
47 * COSA can be also a bus-mastering device.
48 *
49 * SOFTWARE INFO
50 *
51 * The homepage of the Linux driver is at http://www.fi.muni.cz/~kas/cosa/.
52 * The CVS tree of Linux driver can be viewed there, as well as the
53 * firmware binaries and user-space utilities for downloading the firmware
54 * into the card and setting up the card.
55 *
56 * The Linux driver (unlike the present *BSD drivers :-) can work even
57 * for the COSA and SRP in one computer and allows each channel to work
Krzysztof Hałasaaca257532008-07-01 23:40:29 +020058 * in one of the two modes (character or network device).
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 *
60 * AUTHOR
61 *
62 * The Linux driver was written by Jan "Yenya" Kasprzak <kas@fi.muni.cz>.
63 *
64 * You can mail me bugfixes and even success reports. I am especially
65 * interested in the SMP and/or muliti-channel success/failure reports
66 * (I wonder if I did the locking properly :-).
67 *
68 * THE AUTHOR USED THE FOLLOWING SOURCES WHEN PROGRAMMING THE DRIVER
69 *
70 * The COSA/SRP NetBSD driver by Zdenek Salvet and Ivos Cernohlavek
71 * The skeleton.c by Donald Becker
72 * The SDL Riscom/N2 driver by Mike Natale
73 * The Comtrol Hostess SV11 driver by Alan Cox
74 * The Sync PPP/Cisco HDLC layer (syncppp.c) ported to Linux by Alan Cox
75 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Joe Perches9cbe50d2011-06-26 19:01:29 +000077#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#include <linux/module.h>
80#include <linux/kernel.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040081#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#include <linux/slab.h>
83#include <linux/poll.h>
84#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#include <linux/interrupt.h>
86#include <linux/delay.h>
Krzysztof Hałasaaca257532008-07-01 23:40:29 +020087#include <linux/hdlc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070088#include <linux/errno.h>
89#include <linux/ioport.h>
90#include <linux/netdevice.h>
91#include <linux/spinlock.h>
Matthias Kaehlcke6387c4b2008-03-05 18:53:01 -080092#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070093#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include <asm/io.h>
95#include <asm/dma.h>
96#include <asm/byteorder.h>
97
Krzysztof Hałasaaca257532008-07-01 23:40:29 +020098#undef COSA_SLOW_IO /* for testing purposes only */
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100#include "cosa.h"
101
102/* Maximum length of the identification string. */
103#define COSA_MAX_ID_STRING 128
104
105/* Maximum length of the channel name */
106#define COSA_MAX_NAME (sizeof("cosaXXXcXXX")+1)
107
108/* Per-channel data structure */
109
110struct channel_data {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 int usage; /* Usage count; >0 for chrdev, -1 for netdev */
112 int num; /* Number of the channel */
113 struct cosa_data *cosa; /* Pointer to the per-card structure */
114 int txsize; /* Size of transmitted data */
115 char *txbuf; /* Transmit buffer */
116 char name[COSA_MAX_NAME]; /* channel name */
117
118 /* The HW layer interface */
119 /* routine called from the RX interrupt */
120 char *(*setup_rx)(struct channel_data *channel, int size);
121 /* routine called when the RX is done (from the EOT interrupt) */
122 int (*rx_done)(struct channel_data *channel);
123 /* routine called when the TX is done (from the EOT interrupt) */
124 int (*tx_done)(struct channel_data *channel, int size);
125
126 /* Character device parts */
Matthias Kaehlcke6387c4b2008-03-05 18:53:01 -0800127 struct mutex rlock;
128 struct semaphore wsem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 char *rxdata;
130 int rxsize;
131 wait_queue_head_t txwaitq, rxwaitq;
132 int tx_status, rx_status;
133
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200134 /* generic HDLC device parts */
135 struct net_device *netdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 struct sk_buff *rx_skb, *tx_skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137};
138
139/* cosa->firmware_status bits */
140#define COSA_FW_RESET (1<<0) /* Is the ROM monitor active? */
141#define COSA_FW_DOWNLOAD (1<<1) /* Is the microcode downloaded? */
142#define COSA_FW_START (1<<2) /* Is the microcode running? */
143
144struct cosa_data {
145 int num; /* Card number */
146 char name[COSA_MAX_NAME]; /* Card name - e.g "cosa0" */
147 unsigned int datareg, statusreg; /* I/O ports */
148 unsigned short irq, dma; /* IRQ and DMA number */
149 unsigned short startaddr; /* Firmware start address */
150 unsigned short busmaster; /* Use busmastering? */
151 int nchannels; /* # of channels on this card */
152 int driver_status; /* For communicating with firmware */
153 int firmware_status; /* Downloaded, reseted, etc. */
Al Viro64b33612007-10-14 19:35:20 +0100154 unsigned long rxbitmap, txbitmap;/* Bitmap of channels who are willing to send/receive data */
155 unsigned long rxtx; /* RX or TX in progress? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 int enabled;
157 int usage; /* usage count */
158 int txchan, txsize, rxsize;
159 struct channel_data *rxchan;
160 char *bouncebuf;
161 char *txbuf, *rxbuf;
162 struct channel_data *chan;
163 spinlock_t lock; /* For exclusive operations on this structure */
164 char id_string[COSA_MAX_ID_STRING]; /* ROM monitor ID string */
165 char *type; /* card type */
166};
167
168/*
169 * Define this if you want all the possible ports to be autoprobed.
170 * It is here but it probably is not a good idea to use this.
171 */
172/* #define COSA_ISA_AUTOPROBE 1 */
173
174/*
175 * Character device major number. 117 was allocated for us.
176 * The value of 0 means to allocate a first free one.
177 */
Arnd Bergmann15fd0cd2010-07-11 11:18:57 +0000178static DEFINE_MUTEX(cosa_chardev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179static int cosa_major = 117;
180
181/*
182 * Encoding of the minor numbers:
183 * The lowest CARD_MINOR_BITS bits means the channel on the single card,
184 * the highest bits means the card number.
185 */
186#define CARD_MINOR_BITS 4 /* How many bits in minor number are reserved
187 * for the single card */
188/*
189 * The following depends on CARD_MINOR_BITS. Unfortunately, the "MODULE_STRING"
190 * macro doesn't like anything other than the raw number as an argument :-(
191 */
192#define MAX_CARDS 16
193/* #define MAX_CARDS (1 << (8-CARD_MINOR_BITS)) */
194
195#define DRIVER_RX_READY 0x0001
196#define DRIVER_TX_READY 0x0002
197#define DRIVER_TXMAP_SHIFT 2
198#define DRIVER_TXMAP_MASK 0x0c /* FIXME: 0xfc for 8-channel version */
199
200/*
201 * for cosa->rxtx - indicates whether either transmit or receive is
202 * in progress. These values are mean number of the bit.
203 */
204#define TXBIT 0
205#define RXBIT 1
206#define IRQBIT 2
207
208#define COSA_MTU 2000 /* FIXME: I don't know this exactly */
209
210#undef DEBUG_DATA //1 /* Dump the data read or written to the channel */
211#undef DEBUG_IRQS //1 /* Print the message when the IRQ is received */
212#undef DEBUG_IO //1 /* Dump the I/O traffic */
213
214#define TX_TIMEOUT (5*HZ)
215
216/* Maybe the following should be allocated dynamically */
217static struct cosa_data cosa_cards[MAX_CARDS];
218static int nr_cards;
219
220#ifdef COSA_ISA_AUTOPROBE
221static int io[MAX_CARDS+1] = { 0x220, 0x228, 0x210, 0x218, 0, };
222/* NOTE: DMA is not autoprobed!!! */
223static int dma[MAX_CARDS+1] = { 1, 7, 1, 7, 1, 7, 1, 7, 0, };
224#else
225static int io[MAX_CARDS+1];
226static int dma[MAX_CARDS+1];
227#endif
228/* IRQ can be safely autoprobed */
229static int irq[MAX_CARDS+1] = { -1, -1, -1, -1, -1, -1, 0, };
230
231/* for class stuff*/
gregkh@suse.de56b22932005-03-23 10:01:41 -0800232static struct class *cosa_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
234#ifdef MODULE
235module_param_array(io, int, NULL, 0);
236MODULE_PARM_DESC(io, "The I/O bases of the COSA or SRP cards");
237module_param_array(irq, int, NULL, 0);
238MODULE_PARM_DESC(irq, "The IRQ lines of the COSA or SRP cards");
239module_param_array(dma, int, NULL, 0);
240MODULE_PARM_DESC(dma, "The DMA channels of the COSA or SRP cards");
241
242MODULE_AUTHOR("Jan \"Yenya\" Kasprzak, <kas@fi.muni.cz>");
243MODULE_DESCRIPTION("Modular driver for the COSA or SRP synchronous card");
244MODULE_LICENSE("GPL");
245#endif
246
247/* I use this mainly for testing purposes */
248#ifdef COSA_SLOW_IO
249#define cosa_outb outb_p
250#define cosa_outw outw_p
251#define cosa_inb inb_p
252#define cosa_inw inw_p
253#else
254#define cosa_outb outb
255#define cosa_outw outw
256#define cosa_inb inb
257#define cosa_inw inw
258#endif
259
260#define is_8bit(cosa) (!(cosa->datareg & 0x08))
261
262#define cosa_getstatus(cosa) (cosa_inb(cosa->statusreg))
263#define cosa_putstatus(cosa, stat) (cosa_outb(stat, cosa->statusreg))
264#define cosa_getdata16(cosa) (cosa_inw(cosa->datareg))
265#define cosa_getdata8(cosa) (cosa_inb(cosa->datareg))
266#define cosa_putdata16(cosa, dt) (cosa_outw(dt, cosa->datareg))
267#define cosa_putdata8(cosa, dt) (cosa_outb(dt, cosa->datareg))
268
269/* Initialization stuff */
270static int cosa_probe(int ioaddr, int irq, int dma);
271
272/* HW interface */
273static void cosa_enable_rx(struct channel_data *chan);
274static void cosa_disable_rx(struct channel_data *chan);
275static int cosa_start_tx(struct channel_data *channel, char *buf, int size);
276static void cosa_kick(struct cosa_data *cosa);
277static int cosa_dma_able(struct channel_data *chan, char *buf, int data);
278
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200279/* Network device stuff */
280static int cosa_net_attach(struct net_device *dev, unsigned short encoding,
281 unsigned short parity);
282static int cosa_net_open(struct net_device *d);
283static int cosa_net_close(struct net_device *d);
284static void cosa_net_timeout(struct net_device *d);
Stephen Hemmingerd71a6742009-08-31 19:50:47 +0000285static netdev_tx_t cosa_net_tx(struct sk_buff *skb, struct net_device *d);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200286static char *cosa_net_setup_rx(struct channel_data *channel, int size);
287static int cosa_net_rx_done(struct channel_data *channel);
288static int cosa_net_tx_done(struct channel_data *channel, int size);
289static int cosa_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
291/* Character device */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292static char *chrdev_setup_rx(struct channel_data *channel, int size);
293static int chrdev_rx_done(struct channel_data *channel);
294static int chrdev_tx_done(struct channel_data *channel, int size);
295static ssize_t cosa_read(struct file *file,
296 char __user *buf, size_t count, loff_t *ppos);
297static ssize_t cosa_write(struct file *file,
298 const char __user *buf, size_t count, loff_t *ppos);
299static unsigned int cosa_poll(struct file *file, poll_table *poll);
300static int cosa_open(struct inode *inode, struct file *file);
301static int cosa_release(struct inode *inode, struct file *file);
Alan Cox2395f0e2009-10-14 05:22:24 +0000302static long cosa_chardev_ioctl(struct file *file, unsigned int cmd,
303 unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304#ifdef COSA_FASYNC_WORKING
305static int cosa_fasync(struct inode *inode, struct file *file, int on);
306#endif
307
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800308static const struct file_operations cosa_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 .owner = THIS_MODULE,
310 .llseek = no_llseek,
311 .read = cosa_read,
312 .write = cosa_write,
313 .poll = cosa_poll,
Alan Cox2395f0e2009-10-14 05:22:24 +0000314 .unlocked_ioctl = cosa_chardev_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 .open = cosa_open,
316 .release = cosa_release,
317#ifdef COSA_FASYNC_WORKING
318 .fasync = cosa_fasync,
319#endif
320};
321
322/* Ioctls */
323static int cosa_start(struct cosa_data *cosa, int address);
324static int cosa_reset(struct cosa_data *cosa);
325static int cosa_download(struct cosa_data *cosa, void __user *a);
326static int cosa_readmem(struct cosa_data *cosa, void __user *a);
327
328/* COSA/SRP ROM monitor */
329static int download(struct cosa_data *cosa, const char __user *data, int addr, int len);
330static int startmicrocode(struct cosa_data *cosa, int address);
331static int readmem(struct cosa_data *cosa, char __user *data, int addr, int len);
332static int cosa_reset_and_read_id(struct cosa_data *cosa, char *id);
333
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300334/* Auxiliary functions */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335static int get_wait_data(struct cosa_data *cosa);
336static int put_wait_data(struct cosa_data *cosa, int data);
337static int puthexnumber(struct cosa_data *cosa, int number);
338static void put_driver_status(struct cosa_data *cosa);
339static void put_driver_status_nolock(struct cosa_data *cosa);
340
341/* Interrupt handling */
David Howells7d12e782006-10-05 14:55:46 +0100342static irqreturn_t cosa_interrupt(int irq, void *cosa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344/* I/O ops debugging */
345#ifdef DEBUG_IO
346static void debug_data_in(struct cosa_data *cosa, int data);
347static void debug_data_out(struct cosa_data *cosa, int data);
348static void debug_data_cmd(struct cosa_data *cosa, int data);
349static void debug_status_in(struct cosa_data *cosa, int status);
350static void debug_status_out(struct cosa_data *cosa, int status);
351#endif
352
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200353static inline struct channel_data* dev_to_chan(struct net_device *dev)
354{
355 return (struct channel_data *)dev_to_hdlc(dev)->priv;
356}
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358/* ---------- Initialization stuff ---------- */
359
360static int __init cosa_init(void)
361{
362 int i, err = 0;
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 if (cosa_major > 0) {
365 if (register_chrdev(cosa_major, "cosa", &cosa_fops)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000366 pr_warn("unable to get major %d\n", cosa_major);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 err = -EIO;
368 goto out;
369 }
370 } else {
371 if (!(cosa_major=register_chrdev(0, "cosa", &cosa_fops))) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000372 pr_warn("unable to register chardev\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 err = -EIO;
374 goto out;
375 }
376 }
377 for (i=0; i<MAX_CARDS; i++)
378 cosa_cards[i].num = -1;
379 for (i=0; io[i] != 0 && i < MAX_CARDS; i++)
380 cosa_probe(io[i], irq[i], dma[i]);
381 if (!nr_cards) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000382 pr_warn("no devices found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 unregister_chrdev(cosa_major, "cosa");
384 err = -ENODEV;
385 goto out;
386 }
gregkh@suse.de56b22932005-03-23 10:01:41 -0800387 cosa_class = class_create(THIS_MODULE, "cosa");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if (IS_ERR(cosa_class)) {
389 err = PTR_ERR(cosa_class);
390 goto out_chrdev;
391 }
Greg Kroah-Hartmane17da9c2008-05-21 12:52:33 -0700392 for (i = 0; i < nr_cards; i++)
Greg Kroah-Hartman6e05d6c2008-07-21 20:03:34 -0700393 device_create(cosa_class, NULL, MKDEV(cosa_major, i), NULL,
394 "cosa%d", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 err = 0;
396 goto out;
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398out_chrdev:
399 unregister_chrdev(cosa_major, "cosa");
400out:
401 return err;
402}
403module_init(cosa_init);
404
405static void __exit cosa_exit(void)
406{
407 struct cosa_data *cosa;
408 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200410 for (i = 0; i < nr_cards; i++)
Tony Jones02ff82c2007-09-25 02:03:03 +0200411 device_destroy(cosa_class, MKDEV(cosa_major, i));
gregkh@suse.de56b22932005-03-23 10:01:41 -0800412 class_destroy(cosa_class);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200413
414 for (cosa = cosa_cards; nr_cards--; cosa++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 /* Clean up the per-channel data */
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200416 for (i = 0; i < cosa->nchannels; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 /* Chardev driver has no alloc'd per-channel data */
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200418 unregister_hdlc_device(cosa->chan[i].netdev);
419 free_netdev(cosa->chan[i].netdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
421 /* Clean up the per-card data */
422 kfree(cosa->chan);
423 kfree(cosa->bouncebuf);
424 free_irq(cosa->irq, cosa);
425 free_dma(cosa->dma);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200426 release_region(cosa->datareg, is_8bit(cosa) ? 2 : 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 }
428 unregister_chrdev(cosa_major, "cosa");
429}
430module_exit(cosa_exit);
431
Krzysztof Hałasa991990a2009-01-08 22:52:11 +0100432static const struct net_device_ops cosa_ops = {
433 .ndo_open = cosa_net_open,
434 .ndo_stop = cosa_net_close,
435 .ndo_change_mtu = hdlc_change_mtu,
436 .ndo_start_xmit = hdlc_start_xmit,
437 .ndo_do_ioctl = cosa_net_ioctl,
438 .ndo_tx_timeout = cosa_net_timeout,
439};
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441static int cosa_probe(int base, int irq, int dma)
442{
443 struct cosa_data *cosa = cosa_cards+nr_cards;
444 int i, err = 0;
445
446 memset(cosa, 0, sizeof(struct cosa_data));
447
448 /* Checking validity of parameters: */
449 /* IRQ should be 2-7 or 10-15; negative IRQ means autoprobe */
450 if ((irq >= 0 && irq < 2) || irq > 15 || (irq < 10 && irq > 7)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000451 pr_info("invalid IRQ %d\n", irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return -1;
453 }
454 /* I/O address should be between 0x100 and 0x3ff and should be
455 * multiple of 8. */
456 if (base < 0x100 || base > 0x3ff || base & 0x7) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000457 pr_info("invalid I/O address 0x%x\n", base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 return -1;
459 }
460 /* DMA should be 0,1 or 3-7 */
461 if (dma < 0 || dma == 4 || dma > 7) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000462 pr_info("invalid DMA %d\n", dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return -1;
464 }
465 /* and finally, on 16-bit COSA DMA should be 4-7 and
466 * I/O base should not be multiple of 0x10 */
467 if (((base & 0x8) && dma < 4) || (!(base & 0x8) && dma > 3)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000468 pr_info("8/16 bit base and DMA mismatch (base=0x%x, dma=%d)\n",
469 base, dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 return -1;
471 }
472
473 cosa->dma = dma;
474 cosa->datareg = base;
475 cosa->statusreg = is_8bit(cosa)?base+1:base+2;
476 spin_lock_init(&cosa->lock);
477
478 if (!request_region(base, is_8bit(cosa)?2:4,"cosa"))
479 return -1;
480
481 if (cosa_reset_and_read_id(cosa, cosa->id_string) < 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000482 printk(KERN_DEBUG "probe at 0x%x failed.\n", base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 err = -1;
484 goto err_out;
485 }
486
487 /* Test the validity of identification string */
488 if (!strncmp(cosa->id_string, "SRP", 3))
489 cosa->type = "srp";
490 else if (!strncmp(cosa->id_string, "COSA", 4))
491 cosa->type = is_8bit(cosa)? "cosa8": "cosa16";
492 else {
493/* Print a warning only if we are not autoprobing */
494#ifndef COSA_ISA_AUTOPROBE
Joe Perches9cbe50d2011-06-26 19:01:29 +0000495 pr_info("valid signature not found at 0x%x\n", base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496#endif
497 err = -1;
498 goto err_out;
499 }
500 /* Update the name of the region now we know the type of card */
501 release_region(base, is_8bit(cosa)?2:4);
502 if (!request_region(base, is_8bit(cosa)?2:4, cosa->type)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000503 printk(KERN_DEBUG "changing name at 0x%x failed.\n", base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 return -1;
505 }
506
507 /* Now do IRQ autoprobe */
508 if (irq < 0) {
509 unsigned long irqs;
Joe Perches9cbe50d2011-06-26 19:01:29 +0000510/* pr_info("IRQ autoprobe\n"); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 irqs = probe_irq_on();
512 /*
513 * Enable interrupt on tx buffer empty (it sure is)
514 * really sure ?
515 * FIXME: When this code is not used as module, we should
516 * probably call udelay() instead of the interruptible sleep.
517 */
518 set_current_state(TASK_INTERRUPTIBLE);
519 cosa_putstatus(cosa, SR_TX_INT_ENA);
Nicholas Mc Guirefb79c062015-06-06 09:51:51 +0200520 schedule_timeout(msecs_to_jiffies(300));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 irq = probe_irq_off(irqs);
522 /* Disable all IRQs from the card */
523 cosa_putstatus(cosa, 0);
524 /* Empty the received data register */
525 cosa_getdata8(cosa);
526
527 if (irq < 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000528 pr_info("multiple interrupts obtained (%d, board at 0x%x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 irq, cosa->datareg);
530 err = -1;
531 goto err_out;
532 }
533 if (irq == 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000534 pr_info("no interrupt obtained (board at 0x%x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 cosa->datareg);
536 /* return -1; */
537 }
538 }
539
540 cosa->irq = irq;
541 cosa->num = nr_cards;
542 cosa->usage = 0;
543 cosa->nchannels = 2; /* FIXME: how to determine this? */
544
545 if (request_irq(cosa->irq, cosa_interrupt, 0, cosa->type, cosa)) {
546 err = -1;
547 goto err_out;
548 }
549 if (request_dma(cosa->dma, cosa->type)) {
550 err = -1;
551 goto err_out1;
552 }
553
554 cosa->bouncebuf = kmalloc(COSA_MTU, GFP_KERNEL|GFP_DMA);
555 if (!cosa->bouncebuf) {
556 err = -ENOMEM;
557 goto err_out2;
558 }
559 sprintf(cosa->name, "cosa%d", cosa->num);
560
561 /* Initialize the per-channel data */
Yoann Padioleaudd00cc42007-07-19 01:49:03 -0700562 cosa->chan = kcalloc(cosa->nchannels, sizeof(struct channel_data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (!cosa->chan) {
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200564 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 goto err_out3;
566 }
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200567
568 for (i = 0; i < cosa->nchannels; i++) {
569 struct channel_data *chan = &cosa->chan[i];
570
571 chan->cosa = cosa;
572 chan->num = i;
573 sprintf(chan->name, "cosa%dc%d", chan->cosa->num, i);
574
575 /* Initialize the chardev data structures */
576 mutex_init(&chan->rlock);
Thomas Gleixnerd1985502010-09-07 14:32:25 +0000577 sema_init(&chan->wsem, 1);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200578
579 /* Register the network interface */
580 if (!(chan->netdev = alloc_hdlcdev(chan))) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000581 pr_warn("%s: alloc_hdlcdev failed\n", chan->name);
Julia Lawalla3786a52015-04-05 14:06:28 +0200582 err = -ENOMEM;
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200583 goto err_hdlcdev;
584 }
585 dev_to_hdlc(chan->netdev)->attach = cosa_net_attach;
586 dev_to_hdlc(chan->netdev)->xmit = cosa_net_tx;
Krzysztof Hałasa991990a2009-01-08 22:52:11 +0100587 chan->netdev->netdev_ops = &cosa_ops;
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200588 chan->netdev->watchdog_timeo = TX_TIMEOUT;
589 chan->netdev->base_addr = chan->cosa->datareg;
590 chan->netdev->irq = chan->cosa->irq;
591 chan->netdev->dma = chan->cosa->dma;
Dan Carpentere6d00692015-08-13 00:08:01 +0300592 err = register_hdlc_device(chan->netdev);
593 if (err) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000594 netdev_warn(chan->netdev,
595 "register_hdlc_device() failed\n");
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200596 free_netdev(chan->netdev);
597 goto err_hdlcdev;
598 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 }
600
Joe Perches9cbe50d2011-06-26 19:01:29 +0000601 pr_info("cosa%d: %s (%s at 0x%x irq %d dma %d), %d channels\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 cosa->num, cosa->id_string, cosa->type,
603 cosa->datareg, cosa->irq, cosa->dma, cosa->nchannels);
604
605 return nr_cards++;
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200606
607err_hdlcdev:
608 while (i-- > 0) {
609 unregister_hdlc_device(cosa->chan[i].netdev);
610 free_netdev(cosa->chan[i].netdev);
611 }
612 kfree(cosa->chan);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613err_out3:
614 kfree(cosa->bouncebuf);
615err_out2:
616 free_dma(cosa->dma);
617err_out1:
618 free_irq(cosa->irq, cosa);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200619err_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 release_region(cosa->datareg,is_8bit(cosa)?2:4);
Joe Perches9cbe50d2011-06-26 19:01:29 +0000621 pr_notice("cosa%d: allocating resources failed\n", cosa->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 return err;
623}
624
625
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200626/*---------- network device ---------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200628static int cosa_net_attach(struct net_device *dev, unsigned short encoding,
629 unsigned short parity)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200631 if (encoding == ENCODING_NRZ && parity == PARITY_CRC16_PR1_CCITT)
632 return 0;
633 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634}
635
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200636static int cosa_net_open(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637{
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200638 struct channel_data *chan = dev_to_chan(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 int err;
640 unsigned long flags;
641
642 if (!(chan->cosa->firmware_status & COSA_FW_START)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000643 pr_notice("%s: start the firmware first (status %d)\n",
644 chan->cosa->name, chan->cosa->firmware_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 return -EPERM;
646 }
647 spin_lock_irqsave(&chan->cosa->lock, flags);
648 if (chan->usage != 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000649 pr_warn("%s: cosa_net_open called with usage count %d\n",
650 chan->name, chan->usage);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 spin_unlock_irqrestore(&chan->cosa->lock, flags);
652 return -EBUSY;
653 }
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200654 chan->setup_rx = cosa_net_setup_rx;
655 chan->tx_done = cosa_net_tx_done;
656 chan->rx_done = cosa_net_rx_done;
657 chan->usage = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 chan->cosa->usage++;
659 spin_unlock_irqrestore(&chan->cosa->lock, flags);
660
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200661 err = hdlc_open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 if (err) {
663 spin_lock_irqsave(&chan->cosa->lock, flags);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200664 chan->usage = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 chan->cosa->usage--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 spin_unlock_irqrestore(&chan->cosa->lock, flags);
667 return err;
668 }
669
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200670 netif_start_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 cosa_enable_rx(chan);
672 return 0;
673}
674
Stephen Hemmingerd71a6742009-08-31 19:50:47 +0000675static netdev_tx_t cosa_net_tx(struct sk_buff *skb,
676 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200678 struct channel_data *chan = dev_to_chan(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
680 netif_stop_queue(dev);
681
682 chan->tx_skb = skb;
683 cosa_start_tx(chan, skb->data, skb->len);
Stephen Hemmingerd71a6742009-08-31 19:50:47 +0000684 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685}
686
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200687static void cosa_net_timeout(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688{
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200689 struct channel_data *chan = dev_to_chan(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
691 if (test_bit(RXBIT, &chan->cosa->rxtx)) {
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200692 chan->netdev->stats.rx_errors++;
693 chan->netdev->stats.rx_missed_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 } else {
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200695 chan->netdev->stats.tx_errors++;
696 chan->netdev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 }
698 cosa_kick(chan->cosa);
699 if (chan->tx_skb) {
700 dev_kfree_skb(chan->tx_skb);
701 chan->tx_skb = NULL;
702 }
703 netif_wake_queue(dev);
704}
705
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200706static int cosa_net_close(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200708 struct channel_data *chan = dev_to_chan(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 unsigned long flags;
710
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200711 netif_stop_queue(dev);
712 hdlc_close(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 cosa_disable_rx(chan);
714 spin_lock_irqsave(&chan->cosa->lock, flags);
715 if (chan->rx_skb) {
716 kfree_skb(chan->rx_skb);
717 chan->rx_skb = NULL;
718 }
719 if (chan->tx_skb) {
720 kfree_skb(chan->tx_skb);
721 chan->tx_skb = NULL;
722 }
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200723 chan->usage = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 chan->cosa->usage--;
725 spin_unlock_irqrestore(&chan->cosa->lock, flags);
726 return 0;
727}
728
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200729static char *cosa_net_setup_rx(struct channel_data *chan, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
731 /*
732 * We can safely fall back to non-dma-able memory, because we have
733 * the cosa->bouncebuf pre-allocated.
734 */
Wei Yongjunfbbfb982009-02-25 00:22:41 +0000735 kfree_skb(chan->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 chan->rx_skb = dev_alloc_skb(size);
737 if (chan->rx_skb == NULL) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000738 pr_notice("%s: Memory squeeze, dropping packet\n", chan->name);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200739 chan->netdev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 return NULL;
741 }
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200742 chan->netdev->trans_start = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 return skb_put(chan->rx_skb, size);
744}
745
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200746static int cosa_net_rx_done(struct channel_data *chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747{
748 if (!chan->rx_skb) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000749 pr_warn("%s: rx_done with empty skb!\n", chan->name);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200750 chan->netdev->stats.rx_errors++;
751 chan->netdev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 return 0;
753 }
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200754 chan->rx_skb->protocol = hdlc_type_trans(chan->rx_skb, chan->netdev);
755 chan->rx_skb->dev = chan->netdev;
David S. Miller2f7826c2007-03-26 02:00:58 -0700756 skb_reset_mac_header(chan->rx_skb);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200757 chan->netdev->stats.rx_packets++;
758 chan->netdev->stats.rx_bytes += chan->cosa->rxsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 netif_rx(chan->rx_skb);
760 chan->rx_skb = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 return 0;
762}
763
764/* ARGSUSED */
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200765static int cosa_net_tx_done(struct channel_data *chan, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766{
767 if (!chan->tx_skb) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000768 pr_warn("%s: tx_done with empty skb!\n", chan->name);
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200769 chan->netdev->stats.tx_errors++;
770 chan->netdev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 return 1;
772 }
773 dev_kfree_skb_irq(chan->tx_skb);
774 chan->tx_skb = NULL;
Krzysztof Hałasaaca257532008-07-01 23:40:29 +0200775 chan->netdev->stats.tx_packets++;
776 chan->netdev->stats.tx_bytes += size;
777 netif_wake_queue(chan->netdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 return 1;
779}
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781/*---------- Character device ---------- */
782
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783static ssize_t cosa_read(struct file *file,
784 char __user *buf, size_t count, loff_t *ppos)
785{
786 DECLARE_WAITQUEUE(wait, current);
787 unsigned long flags;
788 struct channel_data *chan = file->private_data;
789 struct cosa_data *cosa = chan->cosa;
790 char *kbuf;
791
792 if (!(cosa->firmware_status & COSA_FW_START)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000793 pr_notice("%s: start the firmware first (status %d)\n",
794 cosa->name, cosa->firmware_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 return -EPERM;
796 }
Matthias Kaehlcke6387c4b2008-03-05 18:53:01 -0800797 if (mutex_lock_interruptible(&chan->rlock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 return -ERESTARTSYS;
799
Joe Perches1d5d1fd2013-02-03 17:28:12 +0000800 chan->rxdata = kmalloc(COSA_MTU, GFP_DMA|GFP_KERNEL);
801 if (chan->rxdata == NULL) {
Matthias Kaehlcke6387c4b2008-03-05 18:53:01 -0800802 mutex_unlock(&chan->rlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 return -ENOMEM;
804 }
805
806 chan->rx_status = 0;
807 cosa_enable_rx(chan);
808 spin_lock_irqsave(&cosa->lock, flags);
809 add_wait_queue(&chan->rxwaitq, &wait);
Rudy Matela640462c2009-12-09 11:35:40 -0300810 while (!chan->rx_status) {
Fabian Frederick2c450152015-02-20 19:12:56 +0100811 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 spin_unlock_irqrestore(&cosa->lock, flags);
813 schedule();
814 spin_lock_irqsave(&cosa->lock, flags);
815 if (signal_pending(current) && chan->rx_status == 0) {
816 chan->rx_status = 1;
817 remove_wait_queue(&chan->rxwaitq, &wait);
Fabian Frederick2c450152015-02-20 19:12:56 +0100818 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 spin_unlock_irqrestore(&cosa->lock, flags);
Matthias Kaehlcke6387c4b2008-03-05 18:53:01 -0800820 mutex_unlock(&chan->rlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 return -ERESTARTSYS;
822 }
823 }
824 remove_wait_queue(&chan->rxwaitq, &wait);
Fabian Frederick2c450152015-02-20 19:12:56 +0100825 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 kbuf = chan->rxdata;
827 count = chan->rxsize;
828 spin_unlock_irqrestore(&cosa->lock, flags);
Matthias Kaehlcke6387c4b2008-03-05 18:53:01 -0800829 mutex_unlock(&chan->rlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 if (copy_to_user(buf, kbuf, count)) {
832 kfree(kbuf);
833 return -EFAULT;
834 }
835 kfree(kbuf);
836 return count;
837}
838
839static char *chrdev_setup_rx(struct channel_data *chan, int size)
840{
841 /* Expect size <= COSA_MTU */
842 chan->rxsize = size;
843 return chan->rxdata;
844}
845
846static int chrdev_rx_done(struct channel_data *chan)
847{
848 if (chan->rx_status) { /* Reader has died */
849 kfree(chan->rxdata);
850 up(&chan->wsem);
851 }
852 chan->rx_status = 1;
853 wake_up_interruptible(&chan->rxwaitq);
854 return 1;
855}
856
857
858static ssize_t cosa_write(struct file *file,
859 const char __user *buf, size_t count, loff_t *ppos)
860{
861 DECLARE_WAITQUEUE(wait, current);
862 struct channel_data *chan = file->private_data;
863 struct cosa_data *cosa = chan->cosa;
864 unsigned long flags;
865 char *kbuf;
866
867 if (!(cosa->firmware_status & COSA_FW_START)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +0000868 pr_notice("%s: start the firmware first (status %d)\n",
869 cosa->name, cosa->firmware_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return -EPERM;
871 }
872 if (down_interruptible(&chan->wsem))
873 return -ERESTARTSYS;
874
875 if (count > COSA_MTU)
876 count = COSA_MTU;
877
878 /* Allocate the buffer */
Joe Perches1d5d1fd2013-02-03 17:28:12 +0000879 kbuf = kmalloc(count, GFP_KERNEL|GFP_DMA);
880 if (kbuf == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 up(&chan->wsem);
882 return -ENOMEM;
883 }
884 if (copy_from_user(kbuf, buf, count)) {
885 up(&chan->wsem);
886 kfree(kbuf);
887 return -EFAULT;
888 }
889 chan->tx_status=0;
890 cosa_start_tx(chan, kbuf, count);
891
892 spin_lock_irqsave(&cosa->lock, flags);
893 add_wait_queue(&chan->txwaitq, &wait);
Rudy Matela640462c2009-12-09 11:35:40 -0300894 while (!chan->tx_status) {
Fabian Frederick2c450152015-02-20 19:12:56 +0100895 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 spin_unlock_irqrestore(&cosa->lock, flags);
897 schedule();
898 spin_lock_irqsave(&cosa->lock, flags);
899 if (signal_pending(current) && chan->tx_status == 0) {
900 chan->tx_status = 1;
901 remove_wait_queue(&chan->txwaitq, &wait);
Fabian Frederick2c450152015-02-20 19:12:56 +0100902 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 chan->tx_status = 1;
904 spin_unlock_irqrestore(&cosa->lock, flags);
Dan Carpenter40be2612009-11-29 06:02:55 +0000905 up(&chan->wsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 return -ERESTARTSYS;
907 }
908 }
909 remove_wait_queue(&chan->txwaitq, &wait);
Fabian Frederick2c450152015-02-20 19:12:56 +0100910 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 up(&chan->wsem);
912 spin_unlock_irqrestore(&cosa->lock, flags);
913 kfree(kbuf);
914 return count;
915}
916
917static int chrdev_tx_done(struct channel_data *chan, int size)
918{
919 if (chan->tx_status) { /* Writer was interrupted */
920 kfree(chan->txbuf);
921 up(&chan->wsem);
922 }
923 chan->tx_status = 1;
924 wake_up_interruptible(&chan->txwaitq);
925 return 1;
926}
927
928static unsigned int cosa_poll(struct file *file, poll_table *poll)
929{
Joe Perches9cbe50d2011-06-26 19:01:29 +0000930 pr_info("cosa_poll is here\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 return 0;
932}
933
934static int cosa_open(struct inode *inode, struct file *file)
935{
936 struct cosa_data *cosa;
937 struct channel_data *chan;
938 unsigned long flags;
939 int n;
Jonathan Corbet09118102008-05-15 09:21:33 -0600940 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
Arnd Bergmann15fd0cd2010-07-11 11:18:57 +0000942 mutex_lock(&cosa_chardev_mutex);
Al Viro496ad9a2013-01-23 17:07:38 -0500943 if ((n=iminor(file_inode(file))>>CARD_MINOR_BITS)
Jonathan Corbet09118102008-05-15 09:21:33 -0600944 >= nr_cards) {
945 ret = -ENODEV;
946 goto out;
947 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 cosa = cosa_cards+n;
949
Al Viro496ad9a2013-01-23 17:07:38 -0500950 if ((n=iminor(file_inode(file))
Jonathan Corbet09118102008-05-15 09:21:33 -0600951 & ((1<<CARD_MINOR_BITS)-1)) >= cosa->nchannels) {
952 ret = -ENODEV;
953 goto out;
954 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 chan = cosa->chan + n;
956
957 file->private_data = chan;
958
959 spin_lock_irqsave(&cosa->lock, flags);
960
961 if (chan->usage < 0) { /* in netdev mode */
962 spin_unlock_irqrestore(&cosa->lock, flags);
Jonathan Corbet09118102008-05-15 09:21:33 -0600963 ret = -EBUSY;
964 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 }
966 cosa->usage++;
967 chan->usage++;
968
969 chan->tx_done = chrdev_tx_done;
970 chan->setup_rx = chrdev_setup_rx;
971 chan->rx_done = chrdev_rx_done;
972 spin_unlock_irqrestore(&cosa->lock, flags);
Jonathan Corbet09118102008-05-15 09:21:33 -0600973out:
Arnd Bergmann15fd0cd2010-07-11 11:18:57 +0000974 mutex_unlock(&cosa_chardev_mutex);
Jonathan Corbet09118102008-05-15 09:21:33 -0600975 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976}
977
978static int cosa_release(struct inode *inode, struct file *file)
979{
980 struct channel_data *channel = file->private_data;
981 struct cosa_data *cosa;
982 unsigned long flags;
983
984 cosa = channel->cosa;
985 spin_lock_irqsave(&cosa->lock, flags);
986 cosa->usage--;
987 channel->usage--;
988 spin_unlock_irqrestore(&cosa->lock, flags);
989 return 0;
990}
991
992#ifdef COSA_FASYNC_WORKING
993static struct fasync_struct *fasync[256] = { NULL, };
994
995/* To be done ... */
996static int cosa_fasync(struct inode *inode, struct file *file, int on)
997{
998 int port = iminor(inode);
Jonathan Corbet60aa4922009-02-01 14:52:56 -0700999
1000 return fasync_helper(inode, file, on, &fasync[port]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001}
1002#endif
1003
1004
1005/* ---------- Ioctls ---------- */
1006
1007/*
1008 * Ioctl subroutines can safely be made inline, because they are called
1009 * only from cosa_ioctl().
1010 */
1011static inline int cosa_reset(struct cosa_data *cosa)
1012{
1013 char idstring[COSA_MAX_ID_STRING];
1014 if (cosa->usage > 1)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001015 pr_info("cosa%d: WARNING: reset requested with cosa->usage > 1 (%d). Odd things may happen.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 cosa->num, cosa->usage);
1017 cosa->firmware_status &= ~(COSA_FW_RESET|COSA_FW_START);
1018 if (cosa_reset_and_read_id(cosa, idstring) < 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001019 pr_notice("cosa%d: reset failed\n", cosa->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 return -EIO;
1021 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001022 pr_info("cosa%d: resetting device: %s\n", cosa->num, idstring);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 cosa->firmware_status |= COSA_FW_RESET;
1024 return 0;
1025}
1026
1027/* High-level function to download data into COSA memory. Calls download() */
1028static inline int cosa_download(struct cosa_data *cosa, void __user *arg)
1029{
1030 struct cosa_download d;
1031 int i;
1032
1033 if (cosa->usage > 1)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001034 pr_info("%s: WARNING: download of microcode requested with cosa->usage > 1 (%d). Odd things may happen.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 cosa->name, cosa->usage);
1036 if (!(cosa->firmware_status & COSA_FW_RESET)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001037 pr_notice("%s: reset the card first (status %d)\n",
1038 cosa->name, cosa->firmware_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 return -EPERM;
1040 }
1041
1042 if (copy_from_user(&d, arg, sizeof(d)))
1043 return -EFAULT;
1044
1045 if (d.addr < 0 || d.addr > COSA_MAX_FIRMWARE_SIZE)
1046 return -EINVAL;
1047 if (d.len < 0 || d.len > COSA_MAX_FIRMWARE_SIZE)
1048 return -EINVAL;
1049
1050
1051 /* If something fails, force the user to reset the card */
1052 cosa->firmware_status &= ~(COSA_FW_RESET|COSA_FW_DOWNLOAD);
1053
1054 i = download(cosa, d.code, d.len, d.addr);
1055 if (i < 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001056 pr_notice("cosa%d: microcode download failed: %d\n",
1057 cosa->num, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 return -EIO;
1059 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001060 pr_info("cosa%d: downloading microcode - 0x%04x bytes at 0x%04x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 cosa->num, d.len, d.addr);
1062 cosa->firmware_status |= COSA_FW_RESET|COSA_FW_DOWNLOAD;
1063 return 0;
1064}
1065
1066/* High-level function to read COSA memory. Calls readmem() */
1067static inline int cosa_readmem(struct cosa_data *cosa, void __user *arg)
1068{
1069 struct cosa_download d;
1070 int i;
1071
1072 if (cosa->usage > 1)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001073 pr_info("cosa%d: WARNING: readmem requested with cosa->usage > 1 (%d). Odd things may happen.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 cosa->num, cosa->usage);
1075 if (!(cosa->firmware_status & COSA_FW_RESET)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001076 pr_notice("%s: reset the card first (status %d)\n",
1077 cosa->name, cosa->firmware_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 return -EPERM;
1079 }
1080
1081 if (copy_from_user(&d, arg, sizeof(d)))
1082 return -EFAULT;
1083
1084 /* If something fails, force the user to reset the card */
1085 cosa->firmware_status &= ~COSA_FW_RESET;
1086
1087 i = readmem(cosa, d.code, d.len, d.addr);
1088 if (i < 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001089 pr_notice("cosa%d: reading memory failed: %d\n", cosa->num, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 return -EIO;
1091 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001092 pr_info("cosa%d: reading card memory - 0x%04x bytes at 0x%04x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 cosa->num, d.len, d.addr);
1094 cosa->firmware_status |= COSA_FW_RESET;
1095 return 0;
1096}
1097
1098/* High-level function to start microcode. Calls startmicrocode(). */
1099static inline int cosa_start(struct cosa_data *cosa, int address)
1100{
1101 int i;
1102
1103 if (cosa->usage > 1)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001104 pr_info("cosa%d: WARNING: start microcode requested with cosa->usage > 1 (%d). Odd things may happen.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 cosa->num, cosa->usage);
1106
1107 if ((cosa->firmware_status & (COSA_FW_RESET|COSA_FW_DOWNLOAD))
1108 != (COSA_FW_RESET|COSA_FW_DOWNLOAD)) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001109 pr_notice("%s: download the microcode and/or reset the card first (status %d)\n",
1110 cosa->name, cosa->firmware_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 return -EPERM;
1112 }
1113 cosa->firmware_status &= ~COSA_FW_RESET;
1114 if ((i=startmicrocode(cosa, address)) < 0) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001115 pr_notice("cosa%d: start microcode at 0x%04x failed: %d\n",
1116 cosa->num, address, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 return -EIO;
1118 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001119 pr_info("cosa%d: starting microcode at 0x%04x\n", cosa->num, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 cosa->startaddr = address;
1121 cosa->firmware_status |= COSA_FW_START;
1122 return 0;
1123}
1124
1125/* Buffer of size at least COSA_MAX_ID_STRING is expected */
1126static inline int cosa_getidstr(struct cosa_data *cosa, char __user *string)
1127{
1128 int l = strlen(cosa->id_string)+1;
1129 if (copy_to_user(string, cosa->id_string, l))
1130 return -EFAULT;
1131 return l;
1132}
1133
1134/* Buffer of size at least COSA_MAX_ID_STRING is expected */
1135static inline int cosa_gettype(struct cosa_data *cosa, char __user *string)
1136{
1137 int l = strlen(cosa->type)+1;
1138 if (copy_to_user(string, cosa->type, l))
1139 return -EFAULT;
1140 return l;
1141}
1142
1143static int cosa_ioctl_common(struct cosa_data *cosa,
1144 struct channel_data *channel, unsigned int cmd, unsigned long arg)
1145{
1146 void __user *argp = (void __user *)arg;
Rudy Matela640462c2009-12-09 11:35:40 -03001147 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 case COSAIORSET: /* Reset the device */
1149 if (!capable(CAP_NET_ADMIN))
1150 return -EACCES;
1151 return cosa_reset(cosa);
1152 case COSAIOSTRT: /* Start the firmware */
1153 if (!capable(CAP_SYS_RAWIO))
1154 return -EACCES;
1155 return cosa_start(cosa, arg);
1156 case COSAIODOWNLD: /* Download the firmware */
1157 if (!capable(CAP_SYS_RAWIO))
1158 return -EACCES;
1159
1160 return cosa_download(cosa, argp);
1161 case COSAIORMEM:
1162 if (!capable(CAP_SYS_RAWIO))
1163 return -EACCES;
1164 return cosa_readmem(cosa, argp);
1165 case COSAIORTYPE:
1166 return cosa_gettype(cosa, argp);
1167 case COSAIORIDSTR:
1168 return cosa_getidstr(cosa, argp);
1169 case COSAIONRCARDS:
1170 return nr_cards;
1171 case COSAIONRCHANS:
1172 return cosa->nchannels;
1173 case COSAIOBMSET:
1174 if (!capable(CAP_SYS_RAWIO))
1175 return -EACCES;
1176 if (is_8bit(cosa))
1177 return -EINVAL;
1178 if (arg != COSA_BM_OFF && arg != COSA_BM_ON)
1179 return -EINVAL;
1180 cosa->busmaster = arg;
1181 return 0;
1182 case COSAIOBMGET:
1183 return cosa->busmaster;
1184 }
1185 return -ENOIOCTLCMD;
1186}
1187
Krzysztof Hałasaaca257532008-07-01 23:40:29 +02001188static int cosa_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189{
1190 int rv;
Krzysztof Hałasaaca257532008-07-01 23:40:29 +02001191 struct channel_data *chan = dev_to_chan(dev);
1192 rv = cosa_ioctl_common(chan->cosa, chan, cmd,
1193 (unsigned long)ifr->ifr_data);
1194 if (rv != -ENOIOCTLCMD)
1195 return rv;
1196 return hdlc_ioctl(dev, ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197}
1198
Alan Cox2395f0e2009-10-14 05:22:24 +00001199static long cosa_chardev_ioctl(struct file *file, unsigned int cmd,
1200 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201{
1202 struct channel_data *channel = file->private_data;
Alan Cox2395f0e2009-10-14 05:22:24 +00001203 struct cosa_data *cosa;
1204 long ret;
1205
Arnd Bergmann15fd0cd2010-07-11 11:18:57 +00001206 mutex_lock(&cosa_chardev_mutex);
Alan Cox2395f0e2009-10-14 05:22:24 +00001207 cosa = channel->cosa;
1208 ret = cosa_ioctl_common(cosa, channel, cmd, arg);
Arnd Bergmann15fd0cd2010-07-11 11:18:57 +00001209 mutex_unlock(&cosa_chardev_mutex);
Alan Cox2395f0e2009-10-14 05:22:24 +00001210 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211}
1212
1213
1214/*---------- HW layer interface ---------- */
1215
1216/*
1217 * The higher layer can bind itself to the HW layer by setting the callbacks
1218 * in the channel_data structure and by using these routines.
1219 */
1220static void cosa_enable_rx(struct channel_data *chan)
1221{
1222 struct cosa_data *cosa = chan->cosa;
1223
1224 if (!test_and_set_bit(chan->num, &cosa->rxbitmap))
1225 put_driver_status(cosa);
1226}
1227
1228static void cosa_disable_rx(struct channel_data *chan)
1229{
1230 struct cosa_data *cosa = chan->cosa;
1231
1232 if (test_and_clear_bit(chan->num, &cosa->rxbitmap))
1233 put_driver_status(cosa);
1234}
1235
1236/*
1237 * FIXME: This routine probably should check for cosa_start_tx() called when
1238 * the previous transmit is still unfinished. In this case the non-zero
1239 * return value should indicate to the caller that the queuing(sp?) up
1240 * the transmit has failed.
1241 */
1242static int cosa_start_tx(struct channel_data *chan, char *buf, int len)
1243{
1244 struct cosa_data *cosa = chan->cosa;
1245 unsigned long flags;
1246#ifdef DEBUG_DATA
1247 int i;
1248
Joe Perches9cbe50d2011-06-26 19:01:29 +00001249 pr_info("cosa%dc%d: starting tx(0x%x)",
1250 chan->cosa->num, chan->num, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 for (i=0; i<len; i++)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001252 pr_cont(" %02x", buf[i]&0xff);
1253 pr_cont("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254#endif
1255 spin_lock_irqsave(&cosa->lock, flags);
1256 chan->txbuf = buf;
1257 chan->txsize = len;
1258 if (len > COSA_MTU)
1259 chan->txsize = COSA_MTU;
1260 spin_unlock_irqrestore(&cosa->lock, flags);
1261
1262 /* Tell the firmware we are ready */
1263 set_bit(chan->num, &cosa->txbitmap);
1264 put_driver_status(cosa);
1265
1266 return 0;
1267}
1268
1269static void put_driver_status(struct cosa_data *cosa)
1270{
1271 unsigned long flags;
1272 int status;
1273
1274 spin_lock_irqsave(&cosa->lock, flags);
1275
1276 status = (cosa->rxbitmap ? DRIVER_RX_READY : 0)
1277 | (cosa->txbitmap ? DRIVER_TX_READY : 0)
1278 | (cosa->txbitmap? ~(cosa->txbitmap<<DRIVER_TXMAP_SHIFT)
1279 &DRIVER_TXMAP_MASK : 0);
1280 if (!cosa->rxtx) {
1281 if (cosa->rxbitmap|cosa->txbitmap) {
1282 if (!cosa->enabled) {
1283 cosa_putstatus(cosa, SR_RX_INT_ENA);
1284#ifdef DEBUG_IO
1285 debug_status_out(cosa, SR_RX_INT_ENA);
1286#endif
1287 cosa->enabled = 1;
1288 }
1289 } else if (cosa->enabled) {
1290 cosa->enabled = 0;
1291 cosa_putstatus(cosa, 0);
1292#ifdef DEBUG_IO
1293 debug_status_out(cosa, 0);
1294#endif
1295 }
1296 cosa_putdata8(cosa, status);
1297#ifdef DEBUG_IO
1298 debug_data_cmd(cosa, status);
1299#endif
1300 }
1301 spin_unlock_irqrestore(&cosa->lock, flags);
1302}
1303
1304static void put_driver_status_nolock(struct cosa_data *cosa)
1305{
1306 int status;
1307
1308 status = (cosa->rxbitmap ? DRIVER_RX_READY : 0)
1309 | (cosa->txbitmap ? DRIVER_TX_READY : 0)
1310 | (cosa->txbitmap? ~(cosa->txbitmap<<DRIVER_TXMAP_SHIFT)
1311 &DRIVER_TXMAP_MASK : 0);
1312
1313 if (cosa->rxbitmap|cosa->txbitmap) {
1314 cosa_putstatus(cosa, SR_RX_INT_ENA);
1315#ifdef DEBUG_IO
1316 debug_status_out(cosa, SR_RX_INT_ENA);
1317#endif
1318 cosa->enabled = 1;
1319 } else {
1320 cosa_putstatus(cosa, 0);
1321#ifdef DEBUG_IO
1322 debug_status_out(cosa, 0);
1323#endif
1324 cosa->enabled = 0;
1325 }
1326 cosa_putdata8(cosa, status);
1327#ifdef DEBUG_IO
1328 debug_data_cmd(cosa, status);
1329#endif
1330}
1331
1332/*
1333 * The "kickme" function: When the DMA times out, this is called to
1334 * clean up the driver status.
1335 * FIXME: Preliminary support, the interface is probably wrong.
1336 */
1337static void cosa_kick(struct cosa_data *cosa)
1338{
1339 unsigned long flags, flags1;
1340 char *s = "(probably) IRQ";
1341
1342 if (test_bit(RXBIT, &cosa->rxtx))
1343 s = "RX DMA";
1344 if (test_bit(TXBIT, &cosa->rxtx))
1345 s = "TX DMA";
1346
Joe Perches9cbe50d2011-06-26 19:01:29 +00001347 pr_info("%s: %s timeout - restarting\n", cosa->name, s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 spin_lock_irqsave(&cosa->lock, flags);
1349 cosa->rxtx = 0;
1350
1351 flags1 = claim_dma_lock();
1352 disable_dma(cosa->dma);
1353 clear_dma_ff(cosa->dma);
1354 release_dma_lock(flags1);
1355
1356 /* FIXME: Anything else? */
1357 udelay(100);
1358 cosa_putstatus(cosa, 0);
1359 udelay(100);
1360 (void) cosa_getdata8(cosa);
1361 udelay(100);
1362 cosa_putdata8(cosa, 0);
1363 udelay(100);
1364 put_driver_status_nolock(cosa);
1365 spin_unlock_irqrestore(&cosa->lock, flags);
1366}
1367
1368/*
1369 * Check if the whole buffer is DMA-able. It means it is below the 16M of
1370 * physical memory and doesn't span the 64k boundary. For now it seems
1371 * SKB's never do this, but we'll check this anyway.
1372 */
1373static int cosa_dma_able(struct channel_data *chan, char *buf, int len)
1374{
1375 static int count;
1376 unsigned long b = (unsigned long)buf;
1377 if (b+len >= MAX_DMA_ADDRESS)
1378 return 0;
1379 if ((b^ (b+len)) & 0x10000) {
1380 if (count++ < 5)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001381 pr_info("%s: packet spanning a 64k boundary\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 chan->name);
1383 return 0;
1384 }
1385 return 1;
1386}
1387
1388
1389/* ---------- The SRP/COSA ROM monitor functions ---------- */
1390
1391/*
1392 * Downloading SRP microcode: say "w" to SRP monitor, it answers by "w=",
1393 * drivers need to say 4-digit hex number meaning start address of the microcode
1394 * separated by a single space. Monitor replies by saying " =". Now driver
1395 * has to write 4-digit hex number meaning the last byte address ended
1396 * by a single space. Monitor has to reply with a space. Now the download
1397 * begins. After the download monitor replies with "\r\n." (CR LF dot).
1398 */
1399static int download(struct cosa_data *cosa, const char __user *microcode, int length, int address)
1400{
1401 int i;
1402
1403 if (put_wait_data(cosa, 'w') == -1) return -1;
1404 if ((i=get_wait_data(cosa)) != 'w') { printk("dnld: 0x%04x\n",i); return -2;}
1405 if (get_wait_data(cosa) != '=') return -3;
1406
1407 if (puthexnumber(cosa, address) < 0) return -4;
1408 if (put_wait_data(cosa, ' ') == -1) return -10;
1409 if (get_wait_data(cosa) != ' ') return -11;
1410 if (get_wait_data(cosa) != '=') return -12;
1411
1412 if (puthexnumber(cosa, address+length-1) < 0) return -13;
1413 if (put_wait_data(cosa, ' ') == -1) return -18;
1414 if (get_wait_data(cosa) != ' ') return -19;
1415
1416 while (length--) {
1417 char c;
1418#ifndef SRP_DOWNLOAD_AT_BOOT
1419 if (get_user(c, microcode))
1420 return -23; /* ??? */
1421#else
1422 c = *microcode;
1423#endif
1424 if (put_wait_data(cosa, c) == -1)
1425 return -20;
1426 microcode++;
1427 }
1428
1429 if (get_wait_data(cosa) != '\r') return -21;
1430 if (get_wait_data(cosa) != '\n') return -22;
1431 if (get_wait_data(cosa) != '.') return -23;
1432#if 0
1433 printk(KERN_DEBUG "cosa%d: download completed.\n", cosa->num);
1434#endif
1435 return 0;
1436}
1437
1438
1439/*
1440 * Starting microcode is done via the "g" command of the SRP monitor.
1441 * The chat should be the following: "g" "g=" "<addr><CR>"
1442 * "<CR><CR><LF><CR><LF>".
1443 */
1444static int startmicrocode(struct cosa_data *cosa, int address)
1445{
1446 if (put_wait_data(cosa, 'g') == -1) return -1;
1447 if (get_wait_data(cosa) != 'g') return -2;
1448 if (get_wait_data(cosa) != '=') return -3;
1449
1450 if (puthexnumber(cosa, address) < 0) return -4;
1451 if (put_wait_data(cosa, '\r') == -1) return -5;
1452
1453 if (get_wait_data(cosa) != '\r') return -6;
1454 if (get_wait_data(cosa) != '\r') return -7;
1455 if (get_wait_data(cosa) != '\n') return -8;
1456 if (get_wait_data(cosa) != '\r') return -9;
1457 if (get_wait_data(cosa) != '\n') return -10;
1458#if 0
1459 printk(KERN_DEBUG "cosa%d: microcode started\n", cosa->num);
1460#endif
1461 return 0;
1462}
1463
1464/*
1465 * Reading memory is done via the "r" command of the SRP monitor.
1466 * The chat is the following "r" "r=" "<addr> " " =" "<last_byte> " " "
1467 * Then driver can read the data and the conversation is finished
1468 * by SRP monitor sending "<CR><LF>." (dot at the end).
1469 *
1470 * This routine is not needed during the normal operation and serves
1471 * for debugging purposes only.
1472 */
1473static int readmem(struct cosa_data *cosa, char __user *microcode, int length, int address)
1474{
1475 if (put_wait_data(cosa, 'r') == -1) return -1;
1476 if ((get_wait_data(cosa)) != 'r') return -2;
1477 if ((get_wait_data(cosa)) != '=') return -3;
1478
1479 if (puthexnumber(cosa, address) < 0) return -4;
1480 if (put_wait_data(cosa, ' ') == -1) return -5;
1481 if (get_wait_data(cosa) != ' ') return -6;
1482 if (get_wait_data(cosa) != '=') return -7;
1483
1484 if (puthexnumber(cosa, address+length-1) < 0) return -8;
1485 if (put_wait_data(cosa, ' ') == -1) return -9;
1486 if (get_wait_data(cosa) != ' ') return -10;
1487
1488 while (length--) {
1489 char c;
1490 int i;
1491 if ((i=get_wait_data(cosa)) == -1) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001492 pr_info("0x%04x bytes remaining\n", length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 return -11;
1494 }
1495 c=i;
1496#if 1
1497 if (put_user(c, microcode))
1498 return -23; /* ??? */
1499#else
1500 *microcode = c;
1501#endif
1502 microcode++;
1503 }
1504
1505 if (get_wait_data(cosa) != '\r') return -21;
1506 if (get_wait_data(cosa) != '\n') return -22;
1507 if (get_wait_data(cosa) != '.') return -23;
1508#if 0
1509 printk(KERN_DEBUG "cosa%d: readmem completed.\n", cosa->num);
1510#endif
1511 return 0;
1512}
1513
1514/*
1515 * This function resets the device and reads the initial prompt
1516 * of the device's ROM monitor.
1517 */
1518static int cosa_reset_and_read_id(struct cosa_data *cosa, char *idstring)
1519{
1520 int i=0, id=0, prev=0, curr=0;
1521
1522 /* Reset the card ... */
1523 cosa_putstatus(cosa, 0);
1524 cosa_getdata8(cosa);
1525 cosa_putstatus(cosa, SR_RST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 msleep(500);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 /* Disable all IRQs from the card */
1528 cosa_putstatus(cosa, 0);
1529
1530 /*
1531 * Try to read the ID string. The card then prints out the
1532 * identification string ended by the "\n\x2e".
1533 *
1534 * The following loop is indexed through i (instead of id)
1535 * to avoid looping forever when for any reason
1536 * the port returns '\r', '\n' or '\x2e' permanently.
1537 */
1538 for (i=0; i<COSA_MAX_ID_STRING-1; i++, prev=curr) {
1539 if ((curr = get_wait_data(cosa)) == -1) {
1540 return -1;
1541 }
1542 curr &= 0xff;
1543 if (curr != '\r' && curr != '\n' && curr != 0x2e)
1544 idstring[id++] = curr;
1545 if (curr == 0x2e && prev == '\n')
1546 break;
1547 }
1548 /* Perhaps we should fail when i==COSA_MAX_ID_STRING-1 ? */
1549 idstring[id] = '\0';
1550 return id;
1551}
1552
1553
1554/* ---------- Auxiliary routines for COSA/SRP monitor ---------- */
1555
1556/*
1557 * This routine gets the data byte from the card waiting for the SR_RX_RDY
1558 * bit to be set in a loop. It should be used in the exceptional cases
1559 * only (for example when resetting the card or downloading the firmware.
1560 */
1561static int get_wait_data(struct cosa_data *cosa)
1562{
1563 int retries = 1000;
1564
1565 while (--retries) {
1566 /* read data and return them */
1567 if (cosa_getstatus(cosa) & SR_RX_RDY) {
1568 short r;
1569 r = cosa_getdata8(cosa);
1570#if 0
Joe Perches9cbe50d2011-06-26 19:01:29 +00001571 pr_info("get_wait_data returning after %d retries\n",
1572 999-retries);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573#endif
1574 return r;
1575 }
1576 /* sleep if not ready to read */
Nishanth Aravamudan3173c892005-09-11 02:09:55 -07001577 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001579 pr_info("timeout in get_wait_data (status 0x%x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 cosa_getstatus(cosa));
1581 return -1;
1582}
1583
1584/*
1585 * This routine puts the data byte to the card waiting for the SR_TX_RDY
1586 * bit to be set in a loop. It should be used in the exceptional cases
1587 * only (for example when resetting the card or downloading the firmware).
1588 */
1589static int put_wait_data(struct cosa_data *cosa, int data)
1590{
1591 int retries = 1000;
1592 while (--retries) {
1593 /* read data and return them */
1594 if (cosa_getstatus(cosa) & SR_TX_RDY) {
1595 cosa_putdata8(cosa, data);
1596#if 0
Joe Perches9cbe50d2011-06-26 19:01:29 +00001597 pr_info("Putdata: %d retries\n", 999-retries);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598#endif
1599 return 0;
1600 }
1601#if 0
1602 /* sleep if not ready to read */
Nishanth Aravamudan3173c892005-09-11 02:09:55 -07001603 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604#endif
1605 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001606 pr_info("cosa%d: timeout in put_wait_data (status 0x%x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 cosa->num, cosa_getstatus(cosa));
1608 return -1;
1609}
1610
1611/*
1612 * The following routine puts the hexadecimal number into the SRP monitor
1613 * and verifies the proper echo of the sent bytes. Returns 0 on success,
1614 * negative number on failure (-1,-3,-5,-7) means that put_wait_data() failed,
1615 * (-2,-4,-6,-8) means that reading echo failed.
1616 */
1617static int puthexnumber(struct cosa_data *cosa, int number)
1618{
1619 char temp[5];
1620 int i;
1621
1622 /* Well, I should probably replace this by something faster. */
1623 sprintf(temp, "%04X", number);
1624 for (i=0; i<4; i++) {
1625 if (put_wait_data(cosa, temp[i]) == -1) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001626 pr_notice("cosa%d: puthexnumber failed to write byte %d\n",
1627 cosa->num, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 return -1-2*i;
1629 }
1630 if (get_wait_data(cosa) != temp[i]) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001631 pr_notice("cosa%d: puthexhumber failed to read echo of byte %d\n",
1632 cosa->num, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 return -2-2*i;
1634 }
1635 }
1636 return 0;
1637}
1638
1639
1640/* ---------- Interrupt routines ---------- */
1641
1642/*
1643 * There are three types of interrupt:
1644 * At the beginning of transmit - this handled is in tx_interrupt(),
1645 * at the beginning of receive - it is in rx_interrupt() and
1646 * at the end of transmit/receive - it is the eot_interrupt() function.
1647 * These functions are multiplexed by cosa_interrupt() according to the
1648 * COSA status byte. I have moved the rx/tx/eot interrupt handling into
1649 * separate functions to make it more readable. These functions are inline,
1650 * so there should be no overhead of function call.
1651 *
1652 * In the COSA bus-master mode, we need to tell the card the address of a
1653 * buffer. Unfortunately, COSA may be too slow for us, so we must busy-wait.
1654 * It's time to use the bottom half :-(
1655 */
1656
1657/*
1658 * Transmit interrupt routine - called when COSA is willing to obtain
1659 * data from the OS. The most tricky part of the routine is selection
1660 * of channel we (OS) want to send packet for. For SRP we should probably
1661 * use the round-robin approach. The newer COSA firmwares have a simple
1662 * flow-control - in the status word has bits 2 and 3 set to 1 means that the
1663 * channel 0 or 1 doesn't want to receive data.
1664 *
1665 * It seems there is a bug in COSA firmware (need to trace it further):
1666 * When the driver status says that the kernel has no more data for transmit
1667 * (e.g. at the end of TX DMA) and then the kernel changes its mind
1668 * (e.g. new packet is queued to hard_start_xmit()), the card issues
1669 * the TX interrupt but does not mark the channel as ready-to-transmit.
1670 * The fix seems to be to push the packet to COSA despite its request.
1671 * We first try to obey the card's opinion, and then fall back to forced TX.
1672 */
1673static inline void tx_interrupt(struct cosa_data *cosa, int status)
1674{
1675 unsigned long flags, flags1;
1676#ifdef DEBUG_IRQS
Joe Perches9cbe50d2011-06-26 19:01:29 +00001677 pr_info("cosa%d: SR_DOWN_REQUEST status=0x%04x\n", cosa->num, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678#endif
1679 spin_lock_irqsave(&cosa->lock, flags);
1680 set_bit(TXBIT, &cosa->rxtx);
1681 if (!test_bit(IRQBIT, &cosa->rxtx)) {
1682 /* flow control, see the comment above */
1683 int i=0;
1684 if (!cosa->txbitmap) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001685 pr_warn("%s: No channel wants data in TX IRQ. Expect DMA timeout.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 cosa->name);
1687 put_driver_status_nolock(cosa);
1688 clear_bit(TXBIT, &cosa->rxtx);
1689 spin_unlock_irqrestore(&cosa->lock, flags);
1690 return;
1691 }
Rudy Matela640462c2009-12-09 11:35:40 -03001692 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 cosa->txchan++;
1694 i++;
1695 if (cosa->txchan >= cosa->nchannels)
1696 cosa->txchan = 0;
1697 if (!(cosa->txbitmap & (1<<cosa->txchan)))
1698 continue;
1699 if (~status & (1 << (cosa->txchan+DRIVER_TXMAP_SHIFT)))
1700 break;
1701 /* in second pass, accept first ready-to-TX channel */
1702 if (i > cosa->nchannels) {
1703 /* Can be safely ignored */
1704#ifdef DEBUG_IRQS
1705 printk(KERN_DEBUG "%s: Forcing TX "
1706 "to not-ready channel %d\n",
1707 cosa->name, cosa->txchan);
1708#endif
1709 break;
1710 }
1711 }
1712
1713 cosa->txsize = cosa->chan[cosa->txchan].txsize;
1714 if (cosa_dma_able(cosa->chan+cosa->txchan,
1715 cosa->chan[cosa->txchan].txbuf, cosa->txsize)) {
1716 cosa->txbuf = cosa->chan[cosa->txchan].txbuf;
1717 } else {
1718 memcpy(cosa->bouncebuf, cosa->chan[cosa->txchan].txbuf,
1719 cosa->txsize);
1720 cosa->txbuf = cosa->bouncebuf;
1721 }
1722 }
1723
1724 if (is_8bit(cosa)) {
1725 if (!test_bit(IRQBIT, &cosa->rxtx)) {
1726 cosa_putstatus(cosa, SR_TX_INT_ENA);
1727 cosa_putdata8(cosa, ((cosa->txchan << 5) & 0xe0)|
1728 ((cosa->txsize >> 8) & 0x1f));
1729#ifdef DEBUG_IO
1730 debug_status_out(cosa, SR_TX_INT_ENA);
1731 debug_data_out(cosa, ((cosa->txchan << 5) & 0xe0)|
1732 ((cosa->txsize >> 8) & 0x1f));
1733 debug_data_in(cosa, cosa_getdata8(cosa));
1734#else
1735 cosa_getdata8(cosa);
1736#endif
1737 set_bit(IRQBIT, &cosa->rxtx);
1738 spin_unlock_irqrestore(&cosa->lock, flags);
1739 return;
1740 } else {
1741 clear_bit(IRQBIT, &cosa->rxtx);
1742 cosa_putstatus(cosa, 0);
1743 cosa_putdata8(cosa, cosa->txsize&0xff);
1744#ifdef DEBUG_IO
1745 debug_status_out(cosa, 0);
1746 debug_data_out(cosa, cosa->txsize&0xff);
1747#endif
1748 }
1749 } else {
1750 cosa_putstatus(cosa, SR_TX_INT_ENA);
1751 cosa_putdata16(cosa, ((cosa->txchan<<13) & 0xe000)
1752 | (cosa->txsize & 0x1fff));
1753#ifdef DEBUG_IO
1754 debug_status_out(cosa, SR_TX_INT_ENA);
1755 debug_data_out(cosa, ((cosa->txchan<<13) & 0xe000)
1756 | (cosa->txsize & 0x1fff));
1757 debug_data_in(cosa, cosa_getdata8(cosa));
1758 debug_status_out(cosa, 0);
1759#else
1760 cosa_getdata8(cosa);
1761#endif
1762 cosa_putstatus(cosa, 0);
1763 }
1764
1765 if (cosa->busmaster) {
1766 unsigned long addr = virt_to_bus(cosa->txbuf);
1767 int count=0;
Joe Perches9cbe50d2011-06-26 19:01:29 +00001768 pr_info("busmaster IRQ\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 while (!(cosa_getstatus(cosa)&SR_TX_RDY)) {
1770 count++;
1771 udelay(10);
1772 if (count > 1000) break;
1773 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001774 pr_info("status %x\n", cosa_getstatus(cosa));
1775 pr_info("ready after %d loops\n", count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 cosa_putdata16(cosa, (addr >> 16)&0xffff);
1777
1778 count = 0;
1779 while (!(cosa_getstatus(cosa)&SR_TX_RDY)) {
1780 count++;
1781 if (count > 1000) break;
1782 udelay(10);
1783 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001784 pr_info("ready after %d loops\n", count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 cosa_putdata16(cosa, addr &0xffff);
1786 flags1 = claim_dma_lock();
1787 set_dma_mode(cosa->dma, DMA_MODE_CASCADE);
1788 enable_dma(cosa->dma);
1789 release_dma_lock(flags1);
1790 } else {
1791 /* start the DMA */
1792 flags1 = claim_dma_lock();
1793 disable_dma(cosa->dma);
1794 clear_dma_ff(cosa->dma);
1795 set_dma_mode(cosa->dma, DMA_MODE_WRITE);
1796 set_dma_addr(cosa->dma, virt_to_bus(cosa->txbuf));
1797 set_dma_count(cosa->dma, cosa->txsize);
1798 enable_dma(cosa->dma);
1799 release_dma_lock(flags1);
1800 }
1801 cosa_putstatus(cosa, SR_TX_DMA_ENA|SR_USR_INT_ENA);
1802#ifdef DEBUG_IO
1803 debug_status_out(cosa, SR_TX_DMA_ENA|SR_USR_INT_ENA);
1804#endif
1805 spin_unlock_irqrestore(&cosa->lock, flags);
1806}
1807
1808static inline void rx_interrupt(struct cosa_data *cosa, int status)
1809{
1810 unsigned long flags;
1811#ifdef DEBUG_IRQS
Joe Perches9cbe50d2011-06-26 19:01:29 +00001812 pr_info("cosa%d: SR_UP_REQUEST\n", cosa->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813#endif
1814
1815 spin_lock_irqsave(&cosa->lock, flags);
1816 set_bit(RXBIT, &cosa->rxtx);
1817
1818 if (is_8bit(cosa)) {
1819 if (!test_bit(IRQBIT, &cosa->rxtx)) {
1820 set_bit(IRQBIT, &cosa->rxtx);
1821 put_driver_status_nolock(cosa);
1822 cosa->rxsize = cosa_getdata8(cosa) <<8;
1823#ifdef DEBUG_IO
1824 debug_data_in(cosa, cosa->rxsize >> 8);
1825#endif
1826 spin_unlock_irqrestore(&cosa->lock, flags);
1827 return;
1828 } else {
1829 clear_bit(IRQBIT, &cosa->rxtx);
1830 cosa->rxsize |= cosa_getdata8(cosa) & 0xff;
1831#ifdef DEBUG_IO
1832 debug_data_in(cosa, cosa->rxsize & 0xff);
1833#endif
1834#if 0
Joe Perches9cbe50d2011-06-26 19:01:29 +00001835 pr_info("cosa%d: receive rxsize = (0x%04x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 cosa->num, cosa->rxsize);
1837#endif
1838 }
1839 } else {
1840 cosa->rxsize = cosa_getdata16(cosa);
1841#ifdef DEBUG_IO
1842 debug_data_in(cosa, cosa->rxsize);
1843#endif
1844#if 0
Joe Perches9cbe50d2011-06-26 19:01:29 +00001845 pr_info("cosa%d: receive rxsize = (0x%04x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 cosa->num, cosa->rxsize);
1847#endif
1848 }
1849 if (((cosa->rxsize & 0xe000) >> 13) >= cosa->nchannels) {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001850 pr_warn("%s: rx for unknown channel (0x%04x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 cosa->name, cosa->rxsize);
1852 spin_unlock_irqrestore(&cosa->lock, flags);
1853 goto reject;
1854 }
1855 cosa->rxchan = cosa->chan + ((cosa->rxsize & 0xe000) >> 13);
1856 cosa->rxsize &= 0x1fff;
1857 spin_unlock_irqrestore(&cosa->lock, flags);
1858
1859 cosa->rxbuf = NULL;
1860 if (cosa->rxchan->setup_rx)
1861 cosa->rxbuf = cosa->rxchan->setup_rx(cosa->rxchan, cosa->rxsize);
1862
1863 if (!cosa->rxbuf) {
1864reject: /* Reject the packet */
Joe Perches9cbe50d2011-06-26 19:01:29 +00001865 pr_info("cosa%d: rejecting packet on channel %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 cosa->num, cosa->rxchan->num);
1867 cosa->rxbuf = cosa->bouncebuf;
1868 }
1869
1870 /* start the DMA */
1871 flags = claim_dma_lock();
1872 disable_dma(cosa->dma);
1873 clear_dma_ff(cosa->dma);
1874 set_dma_mode(cosa->dma, DMA_MODE_READ);
1875 if (cosa_dma_able(cosa->rxchan, cosa->rxbuf, cosa->rxsize & 0x1fff)) {
1876 set_dma_addr(cosa->dma, virt_to_bus(cosa->rxbuf));
1877 } else {
1878 set_dma_addr(cosa->dma, virt_to_bus(cosa->bouncebuf));
1879 }
1880 set_dma_count(cosa->dma, (cosa->rxsize&0x1fff));
1881 enable_dma(cosa->dma);
1882 release_dma_lock(flags);
1883 spin_lock_irqsave(&cosa->lock, flags);
1884 cosa_putstatus(cosa, SR_RX_DMA_ENA|SR_USR_INT_ENA);
1885 if (!is_8bit(cosa) && (status & SR_TX_RDY))
1886 cosa_putdata8(cosa, DRIVER_RX_READY);
1887#ifdef DEBUG_IO
1888 debug_status_out(cosa, SR_RX_DMA_ENA|SR_USR_INT_ENA);
1889 if (!is_8bit(cosa) && (status & SR_TX_RDY))
1890 debug_data_cmd(cosa, DRIVER_RX_READY);
1891#endif
1892 spin_unlock_irqrestore(&cosa->lock, flags);
1893}
1894
1895static inline void eot_interrupt(struct cosa_data *cosa, int status)
1896{
1897 unsigned long flags, flags1;
1898 spin_lock_irqsave(&cosa->lock, flags);
1899 flags1 = claim_dma_lock();
1900 disable_dma(cosa->dma);
1901 clear_dma_ff(cosa->dma);
1902 release_dma_lock(flags1);
1903 if (test_bit(TXBIT, &cosa->rxtx)) {
1904 struct channel_data *chan = cosa->chan+cosa->txchan;
1905 if (chan->tx_done)
1906 if (chan->tx_done(chan, cosa->txsize))
1907 clear_bit(chan->num, &cosa->txbitmap);
1908 } else if (test_bit(RXBIT, &cosa->rxtx)) {
1909#ifdef DEBUG_DATA
1910 {
1911 int i;
Joe Perches9cbe50d2011-06-26 19:01:29 +00001912 pr_info("cosa%dc%d: done rx(0x%x)",
1913 cosa->num, cosa->rxchan->num, cosa->rxsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 for (i=0; i<cosa->rxsize; i++)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001915 pr_cont(" %02x", cosa->rxbuf[i]&0xff);
1916 pr_cont("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 }
1918#endif
1919 /* Packet for unknown channel? */
1920 if (cosa->rxbuf == cosa->bouncebuf)
1921 goto out;
1922 if (!cosa_dma_able(cosa->rxchan, cosa->rxbuf, cosa->rxsize))
1923 memcpy(cosa->rxbuf, cosa->bouncebuf, cosa->rxsize);
1924 if (cosa->rxchan->rx_done)
1925 if (cosa->rxchan->rx_done(cosa->rxchan))
1926 clear_bit(cosa->rxchan->num, &cosa->rxbitmap);
1927 } else {
Joe Perches9cbe50d2011-06-26 19:01:29 +00001928 pr_notice("cosa%d: unexpected EOT interrupt\n", cosa->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 }
1930 /*
1931 * Clear the RXBIT, TXBIT and IRQBIT (the latest should be
1932 * cleared anyway). We should do it as soon as possible
1933 * so that we can tell the COSA we are done and to give it a time
1934 * for recovery.
1935 */
1936out:
1937 cosa->rxtx = 0;
1938 put_driver_status_nolock(cosa);
1939 spin_unlock_irqrestore(&cosa->lock, flags);
1940}
1941
David Howells7d12e782006-10-05 14:55:46 +01001942static irqreturn_t cosa_interrupt(int irq, void *cosa_)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943{
1944 unsigned status;
1945 int count = 0;
1946 struct cosa_data *cosa = cosa_;
1947again:
1948 status = cosa_getstatus(cosa);
1949#ifdef DEBUG_IRQS
Joe Perches9cbe50d2011-06-26 19:01:29 +00001950 pr_info("cosa%d: got IRQ, status 0x%02x\n", cosa->num, status & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951#endif
1952#ifdef DEBUG_IO
1953 debug_status_in(cosa, status);
1954#endif
1955 switch (status & SR_CMD_FROM_SRP_MASK) {
1956 case SR_DOWN_REQUEST:
1957 tx_interrupt(cosa, status);
1958 break;
1959 case SR_UP_REQUEST:
1960 rx_interrupt(cosa, status);
1961 break;
1962 case SR_END_OF_TRANSFER:
1963 eot_interrupt(cosa, status);
1964 break;
1965 default:
1966 /* We may be too fast for SRP. Try to wait a bit more. */
1967 if (count++ < 100) {
1968 udelay(100);
1969 goto again;
1970 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00001971 pr_info("cosa%d: unknown status 0x%02x in IRQ after %d retries\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 cosa->num, status & 0xff, count);
1973 }
1974#ifdef DEBUG_IRQS
1975 if (count)
Joe Perches9cbe50d2011-06-26 19:01:29 +00001976 pr_info("%s: %d-times got unknown status in IRQ\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 cosa->name, count);
1978 else
Joe Perches9cbe50d2011-06-26 19:01:29 +00001979 pr_info("%s: returning from IRQ\n", cosa->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980#endif
1981 return IRQ_HANDLED;
1982}
1983
1984
1985/* ---------- I/O debugging routines ---------- */
1986/*
1987 * These routines can be used to monitor COSA/SRP I/O and to printk()
1988 * the data being transferred on the data and status I/O port in a
1989 * readable way.
1990 */
1991
1992#ifdef DEBUG_IO
1993static void debug_status_in(struct cosa_data *cosa, int status)
1994{
1995 char *s;
Rudy Matela640462c2009-12-09 11:35:40 -03001996 switch (status & SR_CMD_FROM_SRP_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 case SR_UP_REQUEST:
1998 s = "RX_REQ";
1999 break;
2000 case SR_DOWN_REQUEST:
2001 s = "TX_REQ";
2002 break;
2003 case SR_END_OF_TRANSFER:
2004 s = "ET_REQ";
2005 break;
2006 default:
2007 s = "NO_REQ";
2008 break;
2009 }
Joe Perches9cbe50d2011-06-26 19:01:29 +00002010 pr_info("%s: IO: status -> 0x%02x (%s%s%s%s)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 cosa->name,
2012 status,
Joe Perches9cbe50d2011-06-26 19:01:29 +00002013 status & SR_USR_RQ ? "USR_RQ|" : "",
2014 status & SR_TX_RDY ? "TX_RDY|" : "",
2015 status & SR_RX_RDY ? "RX_RDY|" : "",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 s);
2017}
2018
2019static void debug_status_out(struct cosa_data *cosa, int status)
2020{
Joe Perches9cbe50d2011-06-26 19:01:29 +00002021 pr_info("%s: IO: status <- 0x%02x (%s%s%s%s%s%s)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 cosa->name,
2023 status,
Joe Perches9cbe50d2011-06-26 19:01:29 +00002024 status & SR_RX_DMA_ENA ? "RXDMA|" : "!rxdma|",
2025 status & SR_TX_DMA_ENA ? "TXDMA|" : "!txdma|",
2026 status & SR_RST ? "RESET|" : "",
2027 status & SR_USR_INT_ENA ? "USRINT|" : "!usrint|",
2028 status & SR_TX_INT_ENA ? "TXINT|" : "!txint|",
2029 status & SR_RX_INT_ENA ? "RXINT" : "!rxint");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030}
2031
2032static void debug_data_in(struct cosa_data *cosa, int data)
2033{
Joe Perches9cbe50d2011-06-26 19:01:29 +00002034 pr_info("%s: IO: data -> 0x%04x\n", cosa->name, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035}
2036
2037static void debug_data_out(struct cosa_data *cosa, int data)
2038{
Joe Perches9cbe50d2011-06-26 19:01:29 +00002039 pr_info("%s: IO: data <- 0x%04x\n", cosa->name, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040}
2041
2042static void debug_data_cmd(struct cosa_data *cosa, int data)
2043{
Joe Perches9cbe50d2011-06-26 19:01:29 +00002044 pr_info("%s: IO: data <- 0x%04x (%s|%s)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 cosa->name, data,
2046 data & SR_RDY_RCV ? "RX_RDY" : "!rx_rdy",
2047 data & SR_RDY_SND ? "TX_RDY" : "!tx_rdy");
2048}
2049#endif
2050
2051/* EOF -- this file has not been truncated */