Merge branch 'linux-next' of git://git.infradead.org/~dedekind/ubi-2.6
[linux-2.6] / drivers / net / wan / hostess_sv11.c
1 /*
2  *      Comtrol SV11 card driver
3  *
4  *      This is a slightly odd Z85230 synchronous driver. All you need to
5  *      know basically is
6  *
7  *      Its a genuine Z85230
8  *
9  *      It supports DMA using two DMA channels in SYNC mode. The driver doesn't
10  *      use these facilities
11  *      
12  *      The control port is at io+1, the data at io+3 and turning off the DMA
13  *      is done by writing 0 to io+4
14  *
15  *      The hardware does the bus handling to avoid the need for delays between
16  *      touching control registers.
17  *
18  *      Port B isnt wired (why - beats me)
19  *
20  *      Generic HDLC port Copyright (C) 2008 Krzysztof Halasa <khc@pm.waw.pl>
21  */
22
23 #include <linux/module.h>
24 #include <linux/kernel.h>
25 #include <linux/mm.h>
26 #include <linux/net.h>
27 #include <linux/skbuff.h>
28 #include <linux/netdevice.h>
29 #include <linux/if_arp.h>
30 #include <linux/delay.h>
31 #include <linux/hdlc.h>
32 #include <linux/ioport.h>
33 #include <net/arp.h>
34
35 #include <asm/irq.h>
36 #include <asm/io.h>
37 #include <asm/dma.h>
38 #include <asm/byteorder.h>
39 #include "z85230.h"
40
41 static int dma;
42
43 /*
44  *      Network driver support routines
45  */
46
47 static inline struct z8530_dev* dev_to_sv(struct net_device *dev)
48 {
49         return (struct z8530_dev *)dev_to_hdlc(dev)->priv;
50 }
51
52 /*
53  *      Frame receive. Simple for our card as we do HDLC and there
54  *      is no funny garbage involved
55  */
56
57 static void hostess_input(struct z8530_channel *c, struct sk_buff *skb)
58 {
59         /* Drop the CRC - it's not a good idea to try and negotiate it ;) */
60         skb_trim(skb, skb->len - 2);
61         skb->protocol = hdlc_type_trans(skb, c->netdevice);
62         skb_reset_mac_header(skb);
63         skb->dev = c->netdevice;
64         /*
65          *      Send it to the PPP layer. We don't have time to process
66          *      it right now.
67          */
68         netif_rx(skb);
69 }
70
71 /*
72  *      We've been placed in the UP state
73  */
74
75 static int hostess_open(struct net_device *d)
76 {
77         struct z8530_dev *sv11 = dev_to_sv(d);
78         int err = -1;
79
80         /*
81          *      Link layer up
82          */
83         switch (dma) {
84                 case 0:
85                         err = z8530_sync_open(d, &sv11->chanA);
86                         break;
87                 case 1:
88                         err = z8530_sync_dma_open(d, &sv11->chanA);
89                         break;
90                 case 2:
91                         err = z8530_sync_txdma_open(d, &sv11->chanA);
92                         break;
93         }
94
95         if (err)
96                 return err;
97
98         err = hdlc_open(d);
99         if (err) {
100                 switch (dma) {
101                         case 0:
102                                 z8530_sync_close(d, &sv11->chanA);
103                                 break;
104                         case 1:
105                                 z8530_sync_dma_close(d, &sv11->chanA);
106                                 break;
107                         case 2:
108                                 z8530_sync_txdma_close(d, &sv11->chanA);
109                                 break;
110                 }
111                 return err;
112         }
113         sv11->chanA.rx_function = hostess_input;
114
115         /*
116          *      Go go go
117          */
118
119         netif_start_queue(d);
120         return 0;
121 }
122
123 static int hostess_close(struct net_device *d)
124 {
125         struct z8530_dev *sv11 = dev_to_sv(d);
126         /*
127          *      Discard new frames
128          */
129         sv11->chanA.rx_function = z8530_null_rx;
130
131         hdlc_close(d);
132         netif_stop_queue(d);
133
134         switch (dma) {
135                 case 0:
136                         z8530_sync_close(d, &sv11->chanA);
137                         break;
138                 case 1:
139                         z8530_sync_dma_close(d, &sv11->chanA);
140                         break;
141                 case 2:
142                         z8530_sync_txdma_close(d, &sv11->chanA);
143                         break;
144         }
145         return 0;
146 }
147
148 static int hostess_ioctl(struct net_device *d, struct ifreq *ifr, int cmd)
149 {
150         /* struct z8530_dev *sv11=dev_to_sv(d);
151            z8530_ioctl(d,&sv11->chanA,ifr,cmd) */
152         return hdlc_ioctl(d, ifr, cmd);
153 }
154
155 /*
156  *      Passed network frames, fire them downwind.
157  */
158
159 static int hostess_queue_xmit(struct sk_buff *skb, struct net_device *d)
160 {
161         return z8530_queue_xmit(&dev_to_sv(d)->chanA, skb);
162 }
163
164 static int hostess_attach(struct net_device *dev, unsigned short encoding,
165                           unsigned short parity)
166 {
167         if (encoding == ENCODING_NRZ && parity == PARITY_CRC16_PR1_CCITT)
168                 return 0;
169         return -EINVAL;
170 }
171
172 /*
173  *      Description block for a Comtrol Hostess SV11 card
174  */
175
176 static struct z8530_dev *sv11_init(int iobase, int irq)
177 {
178         struct z8530_dev *sv;
179         struct net_device *netdev;
180         /*
181          *      Get the needed I/O space
182          */
183
184         if (!request_region(iobase, 8, "Comtrol SV11")) {
185                 printk(KERN_WARNING "hostess: I/O 0x%X already in use.\n",
186                        iobase);
187                 return NULL;
188         }
189
190         sv = kzalloc(sizeof(struct z8530_dev), GFP_KERNEL);
191         if (!sv)
192                 goto err_kzalloc;
193
194         /*
195          *      Stuff in the I/O addressing
196          */
197
198         sv->active = 0;
199
200         sv->chanA.ctrlio = iobase + 1;
201         sv->chanA.dataio = iobase + 3;
202         sv->chanB.ctrlio = -1;
203         sv->chanB.dataio = -1;
204         sv->chanA.irqs = &z8530_nop;
205         sv->chanB.irqs = &z8530_nop;
206
207         outb(0, iobase + 4);            /* DMA off */
208
209         /* We want a fast IRQ for this device. Actually we'd like an even faster
210            IRQ ;) - This is one driver RtLinux is made for */
211
212         if (request_irq(irq, &z8530_interrupt, IRQF_DISABLED,
213                         "Hostess SV11", sv) < 0) {
214                 printk(KERN_WARNING "hostess: IRQ %d already in use.\n", irq);
215                 goto err_irq;
216         }
217
218         sv->irq = irq;
219         sv->chanA.private = sv;
220         sv->chanA.dev = sv;
221         sv->chanB.dev = sv;
222
223         if (dma) {
224                 /*
225                  *      You can have DMA off or 1 and 3 thats the lot
226                  *      on the Comtrol.
227                  */
228                 sv->chanA.txdma = 3;
229                 sv->chanA.rxdma = 1;
230                 outb(0x03 | 0x08, iobase + 4);          /* DMA on */
231                 if (request_dma(sv->chanA.txdma, "Hostess SV/11 (TX)"))
232                         goto err_txdma;
233
234                 if (dma == 1)
235                         if (request_dma(sv->chanA.rxdma, "Hostess SV/11 (RX)"))
236                                 goto err_rxdma;
237         }
238
239         /* Kill our private IRQ line the hostess can end up chattering
240            until the configuration is set */
241         disable_irq(irq);
242
243         /*
244          *      Begin normal initialise
245          */
246
247         if (z8530_init(sv)) {
248                 printk(KERN_ERR "Z8530 series device not found.\n");
249                 enable_irq(irq);
250                 goto free_dma;
251         }
252         z8530_channel_load(&sv->chanB, z8530_dead_port);
253         if (sv->type == Z85C30)
254                 z8530_channel_load(&sv->chanA, z8530_hdlc_kilostream);
255         else
256                 z8530_channel_load(&sv->chanA, z8530_hdlc_kilostream_85230);
257
258         enable_irq(irq);
259
260         /*
261          *      Now we can take the IRQ
262          */
263
264         sv->chanA.netdevice = netdev = alloc_hdlcdev(sv);
265         if (!netdev)
266                 goto free_dma;
267
268         dev_to_hdlc(netdev)->attach = hostess_attach;
269         dev_to_hdlc(netdev)->xmit = hostess_queue_xmit;
270         netdev->open = hostess_open;
271         netdev->stop = hostess_close;
272         netdev->do_ioctl = hostess_ioctl;
273         netdev->base_addr = iobase;
274         netdev->irq = irq;
275
276         if (register_hdlc_device(netdev)) {
277                 printk(KERN_ERR "hostess: unable to register HDLC device.\n");
278                 free_netdev(netdev);
279                 goto free_dma;
280         }
281
282         z8530_describe(sv, "I/O", iobase);
283         sv->active = 1;
284         return sv;
285
286 free_dma:
287         if (dma == 1)
288                 free_dma(sv->chanA.rxdma);
289 err_rxdma:
290         if (dma)
291                 free_dma(sv->chanA.txdma);
292 err_txdma:
293         free_irq(irq, sv);
294 err_irq:
295         kfree(sv);
296 err_kzalloc:
297         release_region(iobase, 8);
298         return NULL;
299 }
300
301 static void sv11_shutdown(struct z8530_dev *dev)
302 {
303         unregister_hdlc_device(dev->chanA.netdevice);
304         z8530_shutdown(dev);
305         free_irq(dev->irq, dev);
306         if (dma) {
307                 if (dma == 1)
308                         free_dma(dev->chanA.rxdma);
309                 free_dma(dev->chanA.txdma);
310         }
311         release_region(dev->chanA.ctrlio - 1, 8);
312         free_netdev(dev->chanA.netdevice);
313         kfree(dev);
314 }
315
316 static int io = 0x200;
317 static int irq = 9;
318
319 module_param(io, int, 0);
320 MODULE_PARM_DESC(io, "The I/O base of the Comtrol Hostess SV11 card");
321 module_param(dma, int, 0);
322 MODULE_PARM_DESC(dma, "Set this to 1 to use DMA1/DMA3 for TX/RX");
323 module_param(irq, int, 0);
324 MODULE_PARM_DESC(irq, "The interrupt line setting for the Comtrol Hostess SV11 card");
325
326 MODULE_AUTHOR("Alan Cox");
327 MODULE_LICENSE("GPL");
328 MODULE_DESCRIPTION("Modular driver for the Comtrol Hostess SV11");
329
330 static struct z8530_dev *sv11_unit;
331
332 int init_module(void)
333 {
334         if ((sv11_unit = sv11_init(io, irq)) == NULL)
335                 return -ENODEV;
336         return 0;
337 }
338
339 void cleanup_module(void)
340 {
341         if (sv11_unit)
342                 sv11_shutdown(sv11_unit);
343 }