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
21 #include <linux/module.h>
22 #include <linux/kernel.h>
23 #include <linux/mm.h>
24 #include <linux/net.h>
25 #include <linux/skbuff.h>
26 #include <linux/netdevice.h>
27 #include <linux/if_arp.h>
28 #include <linux/delay.h>
29 #include <linux/ioport.h>
30 #include <net/arp.h>
31
32 #include <asm/io.h>
33 #include <asm/dma.h>
34 #include <asm/byteorder.h>
35 #include <net/syncppp.h>
36 #include "z85230.h"
37
38 static int dma;
39
40 struct sv11_device
41 {
42 void *if_ptr; /* General purpose pointer (used by SPPP) */
43 struct z8530_dev sync;
44 struct ppp_device netdev;
45 };
46
47 /*
48 * Network driver support routines
49 */
50
51 /*
52 * Frame receive. Simple for our card as we do sync ppp and there
53 * is no funny garbage involved
54 */
55
56 static void hostess_input(struct z8530_channel *c, struct sk_buff *skb)
57 {
58 /* Drop the CRC - it's not a good idea to try and negotiate it ;) */
59 skb_trim(skb, skb->len-2);
60 skb->protocol=__constant_htons(ETH_P_WAN_PPP);
61 skb->mac.raw=skb->data;
62 skb->dev=c->netdevice;
63 /*
64 * Send it to the PPP layer. We don't have time to process
65 * it right now.
66 */
67 netif_rx(skb);
68 c->netdevice->last_rx = jiffies;
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 sv11_device *sv11=d->priv;
78 int err = -1;
79
80 /*
81 * Link layer up
82 */
83 switch(dma)
84 {
85 case 0:
86 err=z8530_sync_open(d, &sv11->sync.chanA);
87 break;
88 case 1:
89 err=z8530_sync_dma_open(d, &sv11->sync.chanA);
90 break;
91 case 2:
92 err=z8530_sync_txdma_open(d, &sv11->sync.chanA);
93 break;
94 }
95
96 if(err)
97 return err;
98 /*
99 * Begin PPP
100 */
101 err=sppp_open(d);
102 if(err)
103 {
104 switch(dma)
105 {
106 case 0:
107 z8530_sync_close(d, &sv11->sync.chanA);
108 break;
109 case 1:
110 z8530_sync_dma_close(d, &sv11->sync.chanA);
111 break;
112 case 2:
113 z8530_sync_txdma_close(d, &sv11->sync.chanA);
114 break;
115 }
116 return err;
117 }
118 sv11->sync.chanA.rx_function=hostess_input;
119
120 /*
121 * Go go go
122 */
123
124 netif_start_queue(d);
125 return 0;
126 }
127
128 static int hostess_close(struct net_device *d)
129 {
130 struct sv11_device *sv11=d->priv;
131 /*
132 * Discard new frames
133 */
134 sv11->sync.chanA.rx_function=z8530_null_rx;
135 /*
136 * PPP off
137 */
138 sppp_close(d);
139 /*
140 * Link layer down
141 */
142 netif_stop_queue(d);
143
144 switch(dma)
145 {
146 case 0:
147 z8530_sync_close(d, &sv11->sync.chanA);
148 break;
149 case 1:
150 z8530_sync_dma_close(d, &sv11->sync.chanA);
151 break;
152 case 2:
153 z8530_sync_txdma_close(d, &sv11->sync.chanA);
154 break;
155 }
156 return 0;
157 }
158
159 static int hostess_ioctl(struct net_device *d, struct ifreq *ifr, int cmd)
160 {
161 /* struct sv11_device *sv11=d->priv;
162 z8530_ioctl(d,&sv11->sync.chanA,ifr,cmd) */
163 return sppp_do_ioctl(d, ifr,cmd);
164 }
165
166 static struct net_device_stats *hostess_get_stats(struct net_device *d)
167 {
168 struct sv11_device *sv11=d->priv;
169 if(sv11)
170 return z8530_get_stats(&sv11->sync.chanA);
171 else
172 return NULL;
173 }
174
175 /*
176 * Passed PPP frames, fire them downwind.
177 */
178
179 static int hostess_queue_xmit(struct sk_buff *skb, struct net_device *d)
180 {
181 struct sv11_device *sv11=d->priv;
182 return z8530_queue_xmit(&sv11->sync.chanA, skb);
183 }
184
185 static int hostess_neigh_setup(struct neighbour *n)
186 {
187 if (n->nud_state == NUD_NONE) {
188 n->ops = &arp_broken_ops;
189 n->output = n->ops->output;
190 }
191 return 0;
192 }
193
194 static int hostess_neigh_setup_dev(struct net_device *dev, struct neigh_parms *p)
195 {
196 if (p->tbl->family == AF_INET) {
197 p->neigh_setup = hostess_neigh_setup;
198 p->ucast_probes = 0;
199 p->mcast_probes = 0;
200 }
201 return 0;
202 }
203
204 static void sv11_setup(struct net_device *dev)
205 {
206 dev->open = hostess_open;
207 dev->stop = hostess_close;
208 dev->hard_start_xmit = hostess_queue_xmit;
209 dev->get_stats = hostess_get_stats;
210 dev->do_ioctl = hostess_ioctl;
211 dev->neigh_setup = hostess_neigh_setup_dev;
212 }
213
214 /*
215 * Description block for a Comtrol Hostess SV11 card
216 */
217
218 static struct sv11_device *sv11_init(int iobase, int irq)
219 {
220 struct z8530_dev *dev;
221 struct sv11_device *sv;
222
223 /*
224 * Get the needed I/O space
225 */
226
227 if(!request_region(iobase, 8, "Comtrol SV11"))
228 {
229 printk(KERN_WARNING "hostess: I/O 0x%X already in use.\n", iobase);
230 return NULL;
231 }
232
233 sv=(struct sv11_device *)kmalloc(sizeof(struct sv11_device), GFP_KERNEL);
234 if(!sv)
235 goto fail3;
236
237 memset(sv, 0, sizeof(*sv));
238 sv->if_ptr=&sv->netdev;
239
240 sv->netdev.dev = alloc_netdev(0, "hdlc%d", sv11_setup);
241 if(!sv->netdev.dev)
242 goto fail2;
243
244 SET_MODULE_OWNER(sv->netdev.dev);
245
246 dev=&sv->sync;
247
248 /*
249 * Stuff in the I/O addressing
250 */
251
252 dev->active = 0;
253
254 dev->chanA.ctrlio=iobase+1;
255 dev->chanA.dataio=iobase+3;
256 dev->chanB.ctrlio=-1;
257 dev->chanB.dataio=-1;
258 dev->chanA.irqs=&z8530_nop;
259 dev->chanB.irqs=&z8530_nop;
260
261 outb(0, iobase+4); /* DMA off */
262
263 /* We want a fast IRQ for this device. Actually we'd like an even faster
264 IRQ ;) - This is one driver RtLinux is made for */
265
266 if(request_irq(irq, &z8530_interrupt, SA_INTERRUPT, "Hostess SV11", dev)<0)
267 {
268 printk(KERN_WARNING "hostess: IRQ %d already in use.\n", irq);
269 goto fail1;
270 }
271
272 dev->irq=irq;
273 dev->chanA.private=sv;
274 dev->chanA.netdevice=sv->netdev.dev;
275 dev->chanA.dev=dev;
276 dev->chanB.dev=dev;
277
278 if(dma)
279 {
280 /*
281 * You can have DMA off or 1 and 3 thats the lot
282 * on the Comtrol.
283 */
284 dev->chanA.txdma=3;
285 dev->chanA.rxdma=1;
286 outb(0x03|0x08, iobase+4); /* DMA on */
287 if(request_dma(dev->chanA.txdma, "Hostess SV/11 (TX)")!=0)
288 goto fail;
289
290 if(dma==1)
291 {
292 if(request_dma(dev->chanA.rxdma, "Hostess SV/11 (RX)")!=0)
293 goto dmafail;
294 }
295 }
296
297 /* Kill our private IRQ line the hostess can end up chattering
298 until the configuration is set */
299 disable_irq(irq);
300
301 /*
302 * Begin normal initialise
303 */
304
305 if(z8530_init(dev)!=0)
306 {
307 printk(KERN_ERR "Z8530 series device not found.\n");
308 enable_irq(irq);
309 goto dmafail2;
310 }
311 z8530_channel_load(&dev->chanB, z8530_dead_port);
312 if(dev->type==Z85C30)
313 z8530_channel_load(&dev->chanA, z8530_hdlc_kilostream);
314 else
315 z8530_channel_load(&dev->chanA, z8530_hdlc_kilostream_85230);
316
317 enable_irq(irq);
318
319
320 /*
321 * Now we can take the IRQ
322 */
323 if(dev_alloc_name(dev->chanA.netdevice,"hdlc%d")>=0)
324 {
325 struct net_device *d=dev->chanA.netdevice;
326
327 /*
328 * Initialise the PPP components
329 */
330 sppp_attach(&sv->netdev);
331
332 /*
333 * Local fields
334 */
335
336 d->base_addr = iobase;
337 d->irq = irq;
338 d->priv = sv;
339
340 if(register_netdev(d))
341 {
342 printk(KERN_ERR "%s: unable to register device.\n",
343 d->name);
344 sppp_detach(d);
345 goto dmafail2;
346 }
347
348 z8530_describe(dev, "I/O", iobase);
349 dev->active=1;
350 return sv;
351 }
352 dmafail2:
353 if(dma==1)
354 free_dma(dev->chanA.rxdma);
355 dmafail:
356 if(dma)
357 free_dma(dev->chanA.txdma);
358 fail:
359 free_irq(irq, dev);
360 fail1:
361 free_netdev(sv->netdev.dev);
362 fail2:
363 kfree(sv);
364 fail3:
365 release_region(iobase,8);
366 return NULL;
367 }
368
369 static void sv11_shutdown(struct sv11_device *dev)
370 {
371 sppp_detach(dev->netdev.dev);
372 unregister_netdev(dev->netdev.dev);
373 z8530_shutdown(&dev->sync);
374 free_irq(dev->sync.irq, dev);
375 if(dma)
376 {
377 if(dma==1)
378 free_dma(dev->sync.chanA.rxdma);
379 free_dma(dev->sync.chanA.txdma);
380 }
381 release_region(dev->sync.chanA.ctrlio-1, 8);
382 free_netdev(dev->netdev.dev);
383 kfree(dev);
384 }
385
386 #ifdef MODULE
387
388 static int io=0x200;
389 static int irq=9;
390
391 module_param(io, int, 0);
392 MODULE_PARM_DESC(io, "The I/O base of the Comtrol Hostess SV11 card");
393 module_param(dma, int, 0);
394 MODULE_PARM_DESC(dma, "Set this to 1 to use DMA1/DMA3 for TX/RX");
395 module_param(irq, int, 0);
396 MODULE_PARM_DESC(irq, "The interrupt line setting for the Comtrol Hostess SV11 card");
397
398 MODULE_AUTHOR("Alan Cox");
399 MODULE_LICENSE("GPL");
400 MODULE_DESCRIPTION("Modular driver for the Comtrol Hostess SV11");
401
402 static struct sv11_device *sv11_unit;
403
404 int init_module(void)
405 {
406 printk(KERN_INFO "SV-11 Z85230 Synchronous Driver v 0.03.\n");
407 printk(KERN_INFO "(c) Copyright 2001, Red Hat Inc.\n");
408 if((sv11_unit=sv11_init(io,irq))==NULL)
409 return -ENODEV;
410 return 0;
411 }
412
413 void cleanup_module(void)
414 {
415 if(sv11_unit)
416 sv11_shutdown(sv11_unit);
417 }
418
419 #endif
420
421
|
This page was automatically generated by the
LXR engine.
|