git.oblomov.eu Git - linux-2.6/blob - 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
  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/irq.h>
  33 #include <asm/io.h>
  34 #include <asm/dma.h>
  35 #include <asm/byteorder.h>
  36 #include <net/syncppp.h>
  37 #include "z85230.h"
  38
  39 static int dma;
  40
  41 struct sv11_device
  42 {
  43         void *if_ptr;   /* General purpose pointer (used by SPPP) */
  44         struct z8530_dev sync;
  45         struct ppp_device netdev;
  46 };
  47
  48 /*
  49  *      Network driver support routines
  50  */
  51
  52 /*
  53  *      Frame receive. Simple for our card as we do sync ppp 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=__constant_htons(ETH_P_WAN_PPP);
  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         c->netdevice->last_rx = jiffies;
  70 }
  71
  72 /*
  73  *      We've been placed in the UP state
  74  */
  75
  76 static int hostess_open(struct net_device *d)
  77 {
  78         struct sv11_device *sv11=d->priv;
  79         int err = -1;
  80
  81         /*
  82          *      Link layer up
  83          */
  84         switch(dma)
  85         {
  86                 case 0:
  87                         err=z8530_sync_open(d, &sv11->sync.chanA);
  88                         break;
  89                 case 1:
  90                         err=z8530_sync_dma_open(d, &sv11->sync.chanA);
  91                         break;
  92                 case 2:
  93                         err=z8530_sync_txdma_open(d, &sv11->sync.chanA);
  94                         break;
  95         }
  96
  97         if(err)
  98                 return err;
  99         /*
 100          *      Begin PPP
 101          */
 102         err=sppp_open(d);
 103         if(err)
 104         {
 105                 switch(dma)
 106                 {
 107                         case 0:
 108                                 z8530_sync_close(d, &sv11->sync.chanA);
 109                                 break;
 110                         case 1:
 111                                 z8530_sync_dma_close(d, &sv11->sync.chanA);
 112                                 break;
 113                         case 2:
 114                                 z8530_sync_txdma_close(d, &sv11->sync.chanA);
 115                                 break;
 116                 }
 117                 return err;
 118         }
 119         sv11->sync.chanA.rx_function=hostess_input;
 120
 121         /*
 122          *      Go go go
 123          */
 124
 125         netif_start_queue(d);
 126         return 0;
 127 }
 128
 129 static int hostess_close(struct net_device *d)
 130 {
 131         struct sv11_device *sv11=d->priv;
 132         /*
 133          *      Discard new frames
 134          */
 135         sv11->sync.chanA.rx_function=z8530_null_rx;
 136         /*
 137          *      PPP off
 138          */
 139         sppp_close(d);
 140         /*
 141          *      Link layer down
 142          */
 143         netif_stop_queue(d);
 144
 145         switch(dma)
 146         {
 147                 case 0:
 148                         z8530_sync_close(d, &sv11->sync.chanA);
 149                         break;
 150                 case 1:
 151                         z8530_sync_dma_close(d, &sv11->sync.chanA);
 152                         break;
 153                 case 2:
 154                         z8530_sync_txdma_close(d, &sv11->sync.chanA);
 155                         break;
 156         }
 157         return 0;
 158 }
 159
 160 static int hostess_ioctl(struct net_device *d, struct ifreq *ifr, int cmd)
 161 {
 162         /* struct sv11_device *sv11=d->priv;
 163            z8530_ioctl(d,&sv11->sync.chanA,ifr,cmd) */
 164         return sppp_do_ioctl(d, ifr,cmd);
 165 }
 166
 167 static struct net_device_stats *hostess_get_stats(struct net_device *d)
 168 {
 169         struct sv11_device *sv11=d->priv;
 170         if(sv11)
 171                 return z8530_get_stats(&sv11->sync.chanA);
 172         else
 173                 return NULL;
 174 }
 175
 176 /*
 177  *      Passed PPP frames, fire them downwind.
 178  */
 179
 180 static int hostess_queue_xmit(struct sk_buff *skb, struct net_device *d)
 181 {
 182         struct sv11_device *sv11=d->priv;
 183         return z8530_queue_xmit(&sv11->sync.chanA, skb);
 184 }
 185
 186 static int hostess_neigh_setup(struct neighbour *n)
 187 {
 188         if (n->nud_state == NUD_NONE) {
 189                 n->ops = &arp_broken_ops;
 190                 n->output = n->ops->output;
 191         }
 192         return 0;
 193 }
 194
 195 static int hostess_neigh_setup_dev(struct net_device *dev, struct neigh_parms *p)
 196 {
 197         if (p->tbl->family == AF_INET) {
 198                 p->neigh_setup = hostess_neigh_setup;
 199                 p->ucast_probes = 0;
 200                 p->mcast_probes = 0;
 201         }
 202         return 0;
 203 }
 204
 205 static void sv11_setup(struct net_device *dev)
 206 {
 207         dev->open = hostess_open;
 208         dev->stop = hostess_close;
 209         dev->hard_start_xmit = hostess_queue_xmit;
 210         dev->get_stats = hostess_get_stats;
 211         dev->do_ioctl = hostess_ioctl;
 212         dev->neigh_setup = hostess_neigh_setup_dev;
 213 }
 214
 215 /*
 216  *      Description block for a Comtrol Hostess SV11 card
 217  */
 218
 219 static struct sv11_device *sv11_init(int iobase, int irq)
 220 {
 221         struct z8530_dev *dev;
 222         struct sv11_device *sv;
 223
 224         /*
 225          *      Get the needed I/O space
 226          */
 227
 228         if(!request_region(iobase, 8, "Comtrol SV11"))
 229         {
 230                 printk(KERN_WARNING "hostess: I/O 0x%X already in use.\n", iobase);
 231                 return NULL;
 232         }
 233
 234         sv = kzalloc(sizeof(struct sv11_device), GFP_KERNEL);
 235         if(!sv)
 236                 goto fail3;
 237
 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, IRQF_DISABLED, "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