drivers/net/wan/sdla.c

   1 /*
   2  * SDLA         An implementation of a driver for the Sangoma S502/S508 series
   3  *              multi-protocol PC interface card.  Initial offering is with
   4  *              the DLCI driver, providing Frame Relay support for linux.
   5  *
   6  *              Global definitions for the Frame relay interface.
   7  *
   8  * Version:     @(#)sdla.c   0.30       12 Sep 1996
   9  *
  10  * Credits:     Sangoma Technologies, for the use of 2 cards for an extended
  11  *                      period of time.
  12  *              David Mandelstam <dm@sangoma.com> for getting me started on
  13  *                      this project, and incentive to complete it.
  14  *              Gene Kozen <74604.152@compuserve.com> for providing me with
  15  *                      important information about the cards.
  16  *
  17  * Author:      Mike McLagan <mike.mclagan@linux.org>
  18  *
  19  * Changes:
  20  *              0.15    Mike McLagan    Improved error handling, packet dropping
  21  *              0.20    Mike McLagan    New transmit/receive flags for config
  22  *                                      If in FR mode, don't accept packets from
  23  *                                      non DLCI devices.
  24  *              0.25    Mike McLagan    Fixed problem with rejecting packets
  25  *                                      from non DLCI devices.
  26  *              0.30    Mike McLagan    Fixed kernel panic when used with modified
  27  *                                      ifconfig
  28  *
  29  *              This program is free software; you can redistribute it and/or
  30  *              modify it under the terms of the GNU General Public License
  31  *              as published by the Free Software Foundation; either version
  32  *              2 of the License, or (at your option) any later version.
  33  */
  34
  35 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  36
  37 #include <linux/module.h>
  38 #include <linux/kernel.h>
  39 #include <linux/types.h>
  40 #include <linux/fcntl.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/ptrace.h>
  43 #include <linux/ioport.h>
  44 #include <linux/in.h>
  45 #include <linux/slab.h>
  46 #include <linux/string.h>
  47 #include <linux/timer.h>
  48 #include <linux/errno.h>
  49 #include <linux/init.h>
  50 #include <linux/netdevice.h>
  51 #include <linux/skbuff.h>
  52 #include <linux/if_arp.h>
  53 #include <linux/if_frad.h>
  54 #include <linux/sdla.h>
  55 #include <linux/bitops.h>
  56
  57 #include <asm/system.h>
  58 #include <asm/io.h>
  59 #include <asm/dma.h>
  60 #include <asm/uaccess.h>
  61
  62 static const char* version = "SDLA driver v0.30, 12 Sep 1996, mike.mclagan@linux.org";
  63
  64 static unsigned int valid_port[] = { 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390};
  65
  66 static unsigned int valid_mem[] = {
  67                                     0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000,
  68                                     0xB0000, 0xB2000, 0xB4000, 0xB6000, 0xB8000, 0xBA000, 0xBC000, 0xBE000,
  69                                     0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
  70                                     0xD0000, 0xD2000, 0xD4000, 0xD6000, 0xD8000, 0xDA000, 0xDC000, 0xDE000,
  71                                     0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000, 0xEE000};
  72
  73 static DEFINE_SPINLOCK(sdla_lock);
  74
  75 /*********************************************************
  76  *
  77  * these are the core routines that access the card itself
  78  *
  79  *********************************************************/
  80
  81 #define SDLA_WINDOW(dev,addr) outb((((addr) >> 13) & 0x1F), (dev)->base_addr + SDLA_REG_Z80_WINDOW)
  82
  83 static void __sdla_read(struct net_device *dev, int addr, void *buf, short len)
  84 {
  85         char          *temp;
  86         const void    *base;
  87         int           offset, bytes;
  88
  89         temp = buf;
  90         while(len)
  91         {
  92                 offset = addr & SDLA_ADDR_MASK;
  93                 bytes = offset + len > SDLA_WINDOW_SIZE ? SDLA_WINDOW_SIZE - offset : len;
  94                 base = (const void *) (dev->mem_start + offset);
  95
  96                 SDLA_WINDOW(dev, addr);
  97                 memcpy(temp, base, bytes);
  98
  99                 addr += bytes;
 100                 temp += bytes;
 101                 len  -= bytes;
 102         }
 103 }
 104
 105 static void sdla_read(struct net_device *dev, int addr, void *buf, short len)
 106 {
 107         unsigned long flags;
 108         spin_lock_irqsave(&sdla_lock, flags);
 109         __sdla_read(dev, addr, buf, len);
 110         spin_unlock_irqrestore(&sdla_lock, flags);
 111 }
 112
 113 static void __sdla_write(struct net_device *dev, int addr,
 114                          const void *buf, short len)
 115 {
 116         const char    *temp;
 117         void          *base;
 118         int           offset, bytes;
 119
 120         temp = buf;
 121         while(len)
 122         {
 123                 offset = addr & SDLA_ADDR_MASK;
 124                 bytes = offset + len > SDLA_WINDOW_SIZE ? SDLA_WINDOW_SIZE - offset : len;
 125                 base = (void *) (dev->mem_start + offset);
 126
 127                 SDLA_WINDOW(dev, addr);
 128                 memcpy(base, temp, bytes);
 129
 130                 addr += bytes;
 131                 temp += bytes;
 132                 len  -= bytes;
 133         }
 134 }
 135
 136 static void sdla_write(struct net_device *dev, int addr,
 137                        const void *buf, short len)
 138 {
 139         unsigned long flags;
 140
 141         spin_lock_irqsave(&sdla_lock, flags);
 142         __sdla_write(dev, addr, buf, len);
 143         spin_unlock_irqrestore(&sdla_lock, flags);
 144 }
 145
 146
 147 static void sdla_clear(struct net_device *dev)
 148 {
 149         unsigned long flags;
 150         char          *base;
 151         int           len, addr, bytes;
 152
 153         len = 65536;
 154         addr = 0;
 155         bytes = SDLA_WINDOW_SIZE;
 156         base = (void *) dev->mem_start;
 157
 158         spin_lock_irqsave(&sdla_lock, flags);
 159         while(len)
 160         {
 161                 SDLA_WINDOW(dev, addr);
 162                 memset(base, 0, bytes);
 163
 164                 addr += bytes;
 165                 len  -= bytes;
 166         }
 167         spin_unlock_irqrestore(&sdla_lock, flags);
 168
 169 }
 170
 171 static char sdla_byte(struct net_device *dev, int addr)
 172 {
 173         unsigned long flags;
 174         char          byte, *temp;
 175
 176         temp = (void *) (dev->mem_start + (addr & SDLA_ADDR_MASK));
 177
 178         spin_lock_irqsave(&sdla_lock, flags);
 179         SDLA_WINDOW(dev, addr);
 180         byte = *temp;
 181         spin_unlock_irqrestore(&sdla_lock, flags);
 182
 183         return byte;
 184 }
 185
 186 static void sdla_stop(struct net_device *dev)
 187 {
 188         struct frad_local *flp;
 189
 190         flp = netdev_priv(dev);
 191         switch(flp->type)
 192         {
 193                 case SDLA_S502A:
 194                         outb(SDLA_S502A_HALT, dev->base_addr + SDLA_REG_CONTROL);
 195                         flp->state = SDLA_HALT;
 196                         break;
 197                 case SDLA_S502E:
 198                         outb(SDLA_HALT, dev->base_addr + SDLA_REG_Z80_CONTROL);
 199                         outb(SDLA_S502E_ENABLE, dev->base_addr + SDLA_REG_CONTROL);
 200                         flp->state = SDLA_S502E_ENABLE;
 201                         break;
 202                 case SDLA_S507:
 203                         flp->state &= ~SDLA_CPUEN;
 204                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 205                         break;
 206                 case SDLA_S508:
 207                         flp->state &= ~SDLA_CPUEN;
 208                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 209                         break;
 210         }
 211 }
 212
 213 static void sdla_start(struct net_device *dev)
 214 {
 215         struct frad_local *flp;
 216
 217         flp = netdev_priv(dev);
 218         switch(flp->type)
 219         {
 220                 case SDLA_S502A:
 221                         outb(SDLA_S502A_NMI, dev->base_addr + SDLA_REG_CONTROL);
 222                         outb(SDLA_S502A_START, dev->base_addr + SDLA_REG_CONTROL);
 223                         flp->state = SDLA_S502A_START;
 224                         break;
 225                 case SDLA_S502E:
 226                         outb(SDLA_S502E_CPUEN, dev->base_addr + SDLA_REG_Z80_CONTROL);
 227                         outb(0x00, dev->base_addr + SDLA_REG_CONTROL);
 228                         flp->state = 0;
 229                         break;
 230                 case SDLA_S507:
 231                         flp->state |= SDLA_CPUEN;
 232                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 233                         break;
 234                 case SDLA_S508:
 235                         flp->state |= SDLA_CPUEN;
 236                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 237                         break;
 238         }
 239 }
 240
 241 /****************************************************
 242  *
 243  * this is used for the S502A/E cards to determine
 244  * the speed of the onboard CPU.  Calibration is
 245  * necessary for the Frame Relay code uploaded
 246  * later.  Incorrect results cause timing problems
 247  * with link checks & status messages
 248  *
 249  ***************************************************/
 250
 251 static int sdla_z80_poll(struct net_device *dev, int z80_addr, int jiffs, char resp1, char resp2)
 252 {
 253         unsigned long start, done, now;
 254         char          resp, *temp;
 255
 256         start = now = jiffies;
 257         done = jiffies + jiffs;
 258
 259         temp = (void *)dev->mem_start;
 260         temp += z80_addr & SDLA_ADDR_MASK;
 261
 262         resp = ~resp1;
 263         while (time_before(jiffies, done) && (resp != resp1) && (!resp2 || (resp != resp2)))
 264         {
 265                 if (jiffies != now)
 266                 {
 267                         SDLA_WINDOW(dev, z80_addr);
 268                         now = jiffies;
 269                         resp = *temp;
 270                 }
 271         }
 272         return time_before(jiffies, done) ? jiffies - start : -1;
 273 }
 274
 275 /* constants for Z80 CPU speed */
 276 #define Z80_READY               '1'     /* Z80 is ready to begin */
 277 #define LOADER_READY            '2'     /* driver is ready to begin */
 278 #define Z80_SCC_OK              '3'     /* SCC is on board */
 279 #define Z80_SCC_BAD             '4'     /* SCC was not found */
 280
 281 static int sdla_cpuspeed(struct net_device *dev, struct ifreq *ifr)
 282 {
 283         int  jiffs;
 284         char data;
 285
 286         sdla_start(dev);
 287         if (sdla_z80_poll(dev, 0, 3*HZ, Z80_READY, 0) < 0)
 288                 return -EIO;
 289
 290         data = LOADER_READY;
 291         sdla_write(dev, 0, &data, 1);
 292
 293         if ((jiffs = sdla_z80_poll(dev, 0, 8*HZ, Z80_SCC_OK, Z80_SCC_BAD)) < 0)
 294                 return -EIO;
 295
 296         sdla_stop(dev);
 297         sdla_read(dev, 0, &data, 1);
 298
 299         if (data == Z80_SCC_BAD)
 300         {
 301                 printk("%s: SCC bad\n", dev->name);
 302                 return -EIO;
 303         }
 304
 305         if (data != Z80_SCC_OK)
 306                 return -EINVAL;
 307
 308         if (jiffs < 165)
 309                 ifr->ifr_mtu = SDLA_CPU_16M;
 310         else if (jiffs < 220)
 311                 ifr->ifr_mtu = SDLA_CPU_10M;
 312         else if (jiffs < 258)
 313                 ifr->ifr_mtu = SDLA_CPU_8M;
 314         else if (jiffs < 357)
 315                 ifr->ifr_mtu = SDLA_CPU_7M;
 316         else if (jiffs < 467)
 317                 ifr->ifr_mtu = SDLA_CPU_5M;
 318         else
 319                 ifr->ifr_mtu = SDLA_CPU_3M;
 320
 321         return 0;
 322 }
 323
 324 /************************************************
 325  *
 326  *  Direct interaction with the Frame Relay code
 327  *  starts here.
 328  *
 329  ************************************************/
 330
 331 struct _dlci_stat
 332 {
 333         short dlci;
 334         char  flags;
 335 } __packed;
 336
 337 struct _frad_stat
 338 {
 339         char    flags;
 340         struct _dlci_stat dlcis[SDLA_MAX_DLCI];
 341 };
 342
 343 static void sdla_errors(struct net_device *dev, int cmd, int dlci, int ret, int len, void *data)
 344 {
 345         struct _dlci_stat *pstatus;
 346         short             *pdlci;
 347         int               i;
 348         char              *state, line[30];
 349
 350         switch (ret)
 351         {
 352                 case SDLA_RET_MODEM:
 353                         state = data;
 354                         if (*state & SDLA_MODEM_DCD_LOW)
 355                                 netdev_info(dev, "Modem DCD unexpectedly low!\n");
 356                         if (*state & SDLA_MODEM_CTS_LOW)
 357                                 netdev_info(dev, "Modem CTS unexpectedly low!\n");
 358                         /* I should probably do something about this! */
 359                         break;
 360
 361                 case SDLA_RET_CHANNEL_OFF:
 362                         netdev_info(dev, "Channel became inoperative!\n");
 363                         /* same here */
 364                         break;
 365
 366                 case SDLA_RET_CHANNEL_ON:
 367                         netdev_info(dev, "Channel became operative!\n");
 368                         /* same here */
 369                         break;
 370
 371                 case SDLA_RET_DLCI_STATUS:
 372                         netdev_info(dev, "Status change reported by Access Node\n");
 373                         len /= sizeof(struct _dlci_stat);
 374                         for(pstatus = data, i=0;i < len;i++,pstatus++)
 375                         {
 376                                 if (pstatus->flags & SDLA_DLCI_NEW)
 377                                         state = "new";
 378                                 else if (pstatus->flags & SDLA_DLCI_DELETED)
 379                                         state = "deleted";
 380                                 else if (pstatus->flags & SDLA_DLCI_ACTIVE)
 381                                         state = "active";
 382                                 else
 383                                 {
 384                                         sprintf(line, "unknown status: %02X", pstatus->flags);
 385                                         state = line;
 386                                 }
 387                                 netdev_info(dev, "DLCI %i: %s\n",
 388                                             pstatus->dlci, state);
 389                                 /* same here */
 390                         }
 391                         break;
 392
 393                 case SDLA_RET_DLCI_UNKNOWN:
 394                         netdev_info(dev, "Received unknown DLCIs:");
 395                         len /= sizeof(short);
 396                         for(pdlci = data,i=0;i < len;i++,pdlci++)
 397                                 pr_cont(" %i", *pdlci);
 398                         pr_cont("\n");
 399                         break;
 400
 401                 case SDLA_RET_TIMEOUT:
 402                         netdev_err(dev, "Command timed out!\n");
 403                         break;
 404
 405                 case SDLA_RET_BUF_OVERSIZE:
 406                         netdev_info(dev, "Bc/CIR overflow, acceptable size is %i\n",
 407                                     len);
 408                         break;
 409
 410                 case SDLA_RET_BUF_TOO_BIG:
 411                         netdev_info(dev, "Buffer size over specified max of %i\n",
 412                                     len);
 413                         break;
 414
 415                 case SDLA_RET_CHANNEL_INACTIVE:
 416                 case SDLA_RET_DLCI_INACTIVE:
 417                 case SDLA_RET_CIR_OVERFLOW:
 418                 case SDLA_RET_NO_BUFS:
 419                         if (cmd == SDLA_INFORMATION_WRITE)
 420                                 break;
 421
 422                 default:
 423                         netdev_dbg(dev, "Cmd 0x%02X generated return code 0x%02X\n",
 424                                    cmd, ret);
 425                         /* Further processing could be done here */
 426                         break;
 427         }
 428 }
 429
 430 static int sdla_cmd(struct net_device *dev, int cmd, short dlci, short flags,
 431                         void *inbuf, short inlen, void *outbuf, short *outlen)
 432 {
 433         static struct _frad_stat status;
 434         struct frad_local        *flp;
 435         struct sdla_cmd          *cmd_buf;
 436         unsigned long            pflags;
 437         unsigned long            jiffs;
 438         int                      ret, waiting, len;
 439         long                     window;
 440
 441         flp = netdev_priv(dev);
 442         window = flp->type == SDLA_S508 ? SDLA_508_CMD_BUF : SDLA_502_CMD_BUF;
 443         cmd_buf = (struct sdla_cmd *)(dev->mem_start + (window & SDLA_ADDR_MASK));
 444         ret = 0;
 445         len = 0;
 446         jiffs = jiffies + HZ;  /* 1 second is plenty */
 447
 448         spin_lock_irqsave(&sdla_lock, pflags);
 449         SDLA_WINDOW(dev, window);
 450         cmd_buf->cmd = cmd;
 451         cmd_buf->dlci = dlci;
 452         cmd_buf->flags = flags;
 453
 454         if (inbuf)
 455                 memcpy(cmd_buf->data, inbuf, inlen);
 456
 457         cmd_buf->length = inlen;
 458
 459         cmd_buf->opp_flag = 1;
 460         spin_unlock_irqrestore(&sdla_lock, pflags);
 461
 462         waiting = 1;
 463         len = 0;
 464         while (waiting && time_before_eq(jiffies, jiffs))
 465         {
 466                 if (waiting++ % 3)
 467                 {
 468                         spin_lock_irqsave(&sdla_lock, pflags);
 469                         SDLA_WINDOW(dev, window);
 470                         waiting = ((volatile int)(cmd_buf->opp_flag));
 471                         spin_unlock_irqrestore(&sdla_lock, pflags);
 472                 }
 473         }
 474
 475         if (!waiting)
 476         {
 477
 478                 spin_lock_irqsave(&sdla_lock, pflags);
 479                 SDLA_WINDOW(dev, window);
 480                 ret = cmd_buf->retval;
 481                 len = cmd_buf->length;
 482                 if (outbuf && outlen)
 483                 {
 484                         *outlen = *outlen >= len ? len : *outlen;
 485
 486                         if (*outlen)
 487                                 memcpy(outbuf, cmd_buf->data, *outlen);
 488                 }
 489
 490                 /* This is a local copy that's used for error handling */
 491                 if (ret)
 492                         memcpy(&status, cmd_buf->data, len > sizeof(status) ? sizeof(status) : len);
 493
 494                 spin_unlock_irqrestore(&sdla_lock, pflags);
 495         }
 496         else
 497                 ret = SDLA_RET_TIMEOUT;
 498
 499         if (ret != SDLA_RET_OK)
 500                 sdla_errors(dev, cmd, dlci, ret, len, &status);
 501
 502         return ret;
 503 }
 504
 505 /***********************************************
 506  *
 507  * these functions are called by the DLCI driver
 508  *
 509  ***********************************************/
 510
 511 static int sdla_reconfig(struct net_device *dev);
 512
 513 static int sdla_activate(struct net_device *slave, struct net_device *master)
 514 {
 515         struct frad_local *flp;
 516         int i;
 517
 518         flp = netdev_priv(slave);
 519
 520         for(i=0;i<CONFIG_DLCI_MAX;i++)
 521                 if (flp->master[i] == master)
 522                         break;
 523
 524         if (i == CONFIG_DLCI_MAX)
 525                 return -ENODEV;
 526
 527         flp->dlci[i] = abs(flp->dlci[i]);
 528
 529         if (netif_running(slave) && (flp->config.station == FRAD_STATION_NODE))
 530                 sdla_cmd(slave, SDLA_ACTIVATE_DLCI, 0, 0, &flp->dlci[i], sizeof(short), NULL, NULL);
 531
 532         return 0;
 533 }
 534
 535 static int sdla_deactivate(struct net_device *slave, struct net_device *master)
 536 {
 537         struct frad_local *flp;
 538         int               i;
 539
 540         flp = netdev_priv(slave);
 541
 542         for(i=0;i<CONFIG_DLCI_MAX;i++)
 543                 if (flp->master[i] == master)
 544                         break;
 545
 546         if (i == CONFIG_DLCI_MAX)
 547                 return -ENODEV;
 548
 549         flp->dlci[i] = -abs(flp->dlci[i]);
 550
 551         if (netif_running(slave) && (flp->config.station == FRAD_STATION_NODE))
 552                 sdla_cmd(slave, SDLA_DEACTIVATE_DLCI, 0, 0, &flp->dlci[i], sizeof(short), NULL, NULL);
 553
 554         return 0;
 555 }
 556
 557 static int sdla_assoc(struct net_device *slave, struct net_device *master)
 558 {
 559         struct frad_local *flp;
 560         int               i;
 561
 562         if (master->type != ARPHRD_DLCI)
 563                 return -EINVAL;
 564
 565         flp = netdev_priv(slave);
 566
 567         for(i=0;i<CONFIG_DLCI_MAX;i++)
 568         {
 569                 if (!flp->master[i])
 570                         break;
 571                 if (abs(flp->dlci[i]) == *(short *)(master->dev_addr))
 572                         return -EADDRINUSE;
 573         }
 574
 575         if (i == CONFIG_DLCI_MAX)
 576                 return -EMLINK;  /* #### Alan: Comments on this ?? */
 577
 578
 579         flp->master[i] = master;
 580         flp->dlci[i] = -*(short *)(master->dev_addr);
 581         master->mtu = slave->mtu;
 582
 583         if (netif_running(slave)) {
 584                 if (flp->config.station == FRAD_STATION_CPE)
 585                         sdla_reconfig(slave);
 586                 else
 587                         sdla_cmd(slave, SDLA_ADD_DLCI, 0, 0, master->dev_addr, sizeof(short), NULL, NULL);
 588         }
 589
 590         return 0;
 591 }
 592
 593 static int sdla_deassoc(struct net_device *slave, struct net_device *master)
 594 {
 595         struct frad_local *flp;
 596         int               i;
 597
 598         flp = netdev_priv(slave);
 599
 600         for(i=0;i<CONFIG_DLCI_MAX;i++)
 601                 if (flp->master[i] == master)
 602                         break;
 603
 604         if (i == CONFIG_DLCI_MAX)
 605                 return -ENODEV;
 606
 607         flp->master[i] = NULL;
 608         flp->dlci[i] = 0;
 609
 610
 611         if (netif_running(slave)) {
 612                 if (flp->config.station == FRAD_STATION_CPE)
 613                         sdla_reconfig(slave);
 614                 else
 615                         sdla_cmd(slave, SDLA_DELETE_DLCI, 0, 0, master->dev_addr, sizeof(short), NULL, NULL);
 616         }
 617
 618         return 0;
 619 }
 620
 621 static int sdla_dlci_conf(struct net_device *slave, struct net_device *master, int get)
 622 {
 623         struct frad_local *flp;
 624         struct dlci_local *dlp;
 625         int               i;
 626         short             len, ret;
 627
 628         flp = netdev_priv(slave);
 629
 630         for(i=0;i<CONFIG_DLCI_MAX;i++)
 631                 if (flp->master[i] == master)
 632                         break;
 633
 634         if (i == CONFIG_DLCI_MAX)
 635                 return -ENODEV;
 636
 637         dlp = netdev_priv(master);
 638
 639         ret = SDLA_RET_OK;
 640         len = sizeof(struct dlci_conf);
 641         if (netif_running(slave)) {
 642                 if (get)
 643                         ret = sdla_cmd(slave, SDLA_READ_DLCI_CONFIGURATION, abs(flp->dlci[i]), 0,
 644                                     NULL, 0, &dlp->config, &len);
 645                 else
 646                         ret = sdla_cmd(slave, SDLA_SET_DLCI_CONFIGURATION, abs(flp->dlci[i]), 0,
 647                                     &dlp->config, sizeof(struct dlci_conf) - 4 * sizeof(short), NULL, NULL);
 648         }
 649
 650         return ret == SDLA_RET_OK ? 0 : -EIO;
 651 }
 652
 653 /**************************
 654  *
 655  * now for the Linux driver
 656  *
 657  **************************/
 658
 659 /* NOTE: the DLCI driver deals with freeing the SKB!! */
 660 static netdev_tx_t sdla_transmit(struct sk_buff *skb,
 661                                  struct net_device *dev)
 662 {
 663         struct frad_local *flp;
 664         int               ret, addr, accept, i;
 665         short             size;
 666         unsigned long     flags;
 667         struct buf_entry  *pbuf;
 668
 669         flp = netdev_priv(dev);
 670         ret = 0;
 671         accept = 1;
 672
 673         netif_stop_queue(dev);
 674
 675         /*
 676          * stupid GateD insists on setting up the multicast router thru us
 677          * and we're ill equipped to handle a non Frame Relay packet at this
 678          * time!
 679          */
 680
 681         accept = 1;
 682         switch (dev->type)
 683         {
 684                 case ARPHRD_FRAD:
 685                         if (skb->dev->type != ARPHRD_DLCI)
 686                         {
 687                                 netdev_warn(dev, "Non DLCI device, type %i, tried to send on FRAD module\n",
 688                                             skb->dev->type);
 689                                 accept = 0;
 690                         }
 691                         break;
 692                 default:
 693                         netdev_warn(dev, "unknown firmware type 0x%04X\n",
 694                                     dev->type);
 695                         accept = 0;
 696                         break;
 697         }
 698         if (accept)
 699         {
 700                 /* this is frame specific, but till there's a PPP module, it's the default */
 701                 switch (flp->type)
 702                 {
 703                         case SDLA_S502A:
 704                         case SDLA_S502E:
 705                                 ret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, skb->data, skb->len, NULL, NULL);
 706                                 break;
 707                                 case SDLA_S508:
 708                                 size = sizeof(addr);
 709                                 ret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, NULL, skb->len, &addr, &size);
 710                                 if (ret == SDLA_RET_OK)
 711                                 {
 712
 713                                         spin_lock_irqsave(&sdla_lock, flags);
 714                                         SDLA_WINDOW(dev, addr);
 715                                         pbuf = (void *)(((int) dev->mem_start) + (addr & SDLA_ADDR_MASK));
 716                                         __sdla_write(dev, pbuf->buf_addr, skb->data, skb->len);
 717                                         SDLA_WINDOW(dev, addr);
 718                                         pbuf->opp_flag = 1;
 719                                         spin_unlock_irqrestore(&sdla_lock, flags);
 720                                 }
 721                                 break;
 722                 }
 723
 724                 switch (ret)
 725                 {
 726                         case SDLA_RET_OK:
 727                                 dev->stats.tx_packets++;
 728                                 break;
 729
 730                         case SDLA_RET_CIR_OVERFLOW:
 731                         case SDLA_RET_BUF_OVERSIZE:
 732                         case SDLA_RET_NO_BUFS:
 733                                 dev->stats.tx_dropped++;
 734                                 break;
 735
 736                         default:
 737                                 dev->stats.tx_errors++;
 738                                 break;
 739                 }
 740         }
 741         netif_wake_queue(dev);
 742         for(i=0;i<CONFIG_DLCI_MAX;i++)
 743         {
 744                 if(flp->master[i]!=NULL)
 745                         netif_wake_queue(flp->master[i]);
 746         }
 747
 748         dev_kfree_skb(skb);
 749         return NETDEV_TX_OK;
 750 }
 751
 752 static void sdla_receive(struct net_device *dev)
 753 {
 754         struct net_device         *master;
 755         struct frad_local *flp;
 756         struct dlci_local *dlp;
 757         struct sk_buff   *skb;
 758
 759         struct sdla_cmd *cmd;
 760         struct buf_info *pbufi;
 761         struct buf_entry  *pbuf;
 762
 763         unsigned long     flags;
 764         int               i=0, received, success, addr, buf_base, buf_top;
 765         short             dlci, len, len2, split;
 766
 767         flp = netdev_priv(dev);
 768         success = 1;
 769         received = addr = buf_top = buf_base = 0;
 770         len = dlci = 0;
 771         skb = NULL;
 772         master = NULL;
 773         cmd = NULL;
 774         pbufi = NULL;
 775         pbuf = NULL;
 776
 777         spin_lock_irqsave(&sdla_lock, flags);
 778
 779         switch (flp->type)
 780         {
 781                 case SDLA_S502A:
 782                 case SDLA_S502E:
 783                         cmd = (void *) (dev->mem_start + (SDLA_502_RCV_BUF & SDLA_ADDR_MASK));
 784                         SDLA_WINDOW(dev, SDLA_502_RCV_BUF);
 785                         success = cmd->opp_flag;
 786                         if (!success)
 787                                 break;
 788
 789                         dlci = cmd->dlci;
 790                         len = cmd->length;
 791                         break;
 792
 793                 case SDLA_S508:
 794                         pbufi = (void *) (dev->mem_start + (SDLA_508_RXBUF_INFO & SDLA_ADDR_MASK));
 795                         SDLA_WINDOW(dev, SDLA_508_RXBUF_INFO);
 796                         pbuf = (void *) (dev->mem_start + ((pbufi->rse_base + flp->buffer * sizeof(struct buf_entry)) & SDLA_ADDR_MASK));
 797                         success = pbuf->opp_flag;
 798                         if (!success)
 799                                 break;
 800
 801                         buf_top = pbufi->buf_top;
 802                         buf_base = pbufi->buf_base;
 803                         dlci = pbuf->dlci;
 804                         len = pbuf->length;
 805                         addr = pbuf->buf_addr;
 806                         break;
 807         }
 808
 809         /* common code, find the DLCI and get the SKB */
 810         if (success)
 811         {
 812                 for (i=0;i<CONFIG_DLCI_MAX;i++)
 813                         if (flp->dlci[i] == dlci)
 814                                 break;
 815
 816                 if (i == CONFIG_DLCI_MAX)
 817                 {
 818                         netdev_notice(dev, "Received packet from invalid DLCI %i, ignoring\n",
 819                                       dlci);
 820                         dev->stats.rx_errors++;
 821                         success = 0;
 822                 }
 823         }
 824
 825         if (success)
 826         {
 827                 master = flp->master[i];
 828                 skb = dev_alloc_skb(len + sizeof(struct frhdr));
 829                 if (skb == NULL)
 830                 {
 831                         netdev_notice(dev, "Memory squeeze, dropping packet\n");
 832                         dev->stats.rx_dropped++;
 833                         success = 0;
 834                 }
 835                 else
 836                         skb_reserve(skb, sizeof(struct frhdr));
 837         }
 838
 839         /* pick up the data */
 840         switch (flp->type)
 841         {
 842                 case SDLA_S502A:
 843                 case SDLA_S502E:
 844                         if (success)
 845                                 __sdla_read(dev, SDLA_502_RCV_BUF + SDLA_502_DATA_OFS, skb_put(skb,len), len);
 846
 847                         SDLA_WINDOW(dev, SDLA_502_RCV_BUF);
 848                         cmd->opp_flag = 0;
 849                         break;
 850
 851                 case SDLA_S508:
 852                         if (success)
 853                         {
 854                                 /* is this buffer split off the end of the internal ring buffer */
 855                                 split = addr + len > buf_top + 1 ? len - (buf_top - addr + 1) : 0;
 856                                 len2 = len - split;
 857
 858                                 __sdla_read(dev, addr, skb_put(skb, len2), len2);
 859                                 if (split)
 860                                         __sdla_read(dev, buf_base, skb_put(skb, split), split);
 861                         }
 862
 863                         /* increment the buffer we're looking at */
 864                         SDLA_WINDOW(dev, SDLA_508_RXBUF_INFO);
 865                         flp->buffer = (flp->buffer + 1) % pbufi->rse_num;
 866                         pbuf->opp_flag = 0;
 867                         break;
 868         }
 869
 870         if (success)
 871         {
 872                 dev->stats.rx_packets++;
 873                 dlp = netdev_priv(master);
 874                 (*dlp->receive)(skb, master);
 875         }
 876
 877         spin_unlock_irqrestore(&sdla_lock, flags);
 878 }
 879
 880 static irqreturn_t sdla_isr(int dummy, void *dev_id)
 881 {
 882         struct net_device     *dev;
 883         struct frad_local *flp;
 884         char              byte;
 885
 886         dev = dev_id;
 887
 888         flp = netdev_priv(dev);
 889
 890         if (!flp->initialized)
 891         {
 892                 netdev_warn(dev, "irq %d for uninitialized device\n", dev->irq);
 893                 return IRQ_NONE;
 894         }
 895
 896         byte = sdla_byte(dev, flp->type == SDLA_S508 ? SDLA_508_IRQ_INTERFACE : SDLA_502_IRQ_INTERFACE);
 897         switch (byte)
 898         {
 899                 case SDLA_INTR_RX:
 900                         sdla_receive(dev);
 901                         break;
 902
 903                 /* the command will get an error return, which is processed above */
 904                 case SDLA_INTR_MODEM:
 905                 case SDLA_INTR_STATUS:
 906                         sdla_cmd(dev, SDLA_READ_DLC_STATUS, 0, 0, NULL, 0, NULL, NULL);
 907                         break;
 908
 909                 case SDLA_INTR_TX:
 910                 case SDLA_INTR_COMPLETE:
 911                 case SDLA_INTR_TIMER:
 912                         netdev_warn(dev, "invalid irq flag 0x%02X\n", byte);
 913                         break;
 914         }
 915
 916         /* the S502E requires a manual acknowledgement of the interrupt */
 917         if (flp->type == SDLA_S502E)
 918         {
 919                 flp->state &= ~SDLA_S502E_INTACK;
 920                 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 921                 flp->state |= SDLA_S502E_INTACK;
 922                 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 923         }
 924
 925         /* this clears the byte, informing the Z80 we're done */
 926         byte = 0;
 927         sdla_write(dev, flp->type == SDLA_S508 ? SDLA_508_IRQ_INTERFACE : SDLA_502_IRQ_INTERFACE, &byte, sizeof(byte));
 928         return IRQ_HANDLED;
 929 }
 930
 931 static void sdla_poll(unsigned long device)
 932 {
 933         struct net_device         *dev;
 934         struct frad_local *flp;
 935
 936         dev = (struct net_device *) device;
 937         flp = netdev_priv(dev);
 938
 939         if (sdla_byte(dev, SDLA_502_RCV_BUF))
 940                 sdla_receive(dev);
 941
 942         flp->timer.expires = 1;
 943         add_timer(&flp->timer);
 944 }
 945
 946 static int sdla_close(struct net_device *dev)
 947 {
 948         struct frad_local *flp;
 949         struct intr_info  intr;
 950         int               len, i;
 951         short             dlcis[CONFIG_DLCI_MAX];
 952
 953         flp = netdev_priv(dev);
 954
 955         len = 0;
 956         for(i=0;i<CONFIG_DLCI_MAX;i++)
 957                 if (flp->dlci[i])
 958                         dlcis[len++] = abs(flp->dlci[i]);
 959         len *= 2;
 960
 961         if (flp->config.station == FRAD_STATION_NODE)
 962         {
 963                 for(i=0;i<CONFIG_DLCI_MAX;i++)
 964                         if (flp->dlci[i] > 0)
 965                                 sdla_cmd(dev, SDLA_DEACTIVATE_DLCI, 0, 0, dlcis, len, NULL, NULL);
 966                 sdla_cmd(dev, SDLA_DELETE_DLCI, 0, 0, &flp->dlci[i], sizeof(flp->dlci[i]), NULL, NULL);
 967         }
 968
 969         memset(&intr, 0, sizeof(intr));
 970         /* let's start up the reception */
 971         switch(flp->type)
 972         {
 973                 case SDLA_S502A:
 974                         del_timer(&flp->timer);
 975                         break;
 976
 977                 case SDLA_S502E:
 978                         sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(char) + sizeof(short), NULL, NULL);
 979                         flp->state &= ~SDLA_S502E_INTACK;
 980                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 981                         break;
 982
 983                 case SDLA_S507:
 984                         break;
 985
 986                 case SDLA_S508:
 987                         sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(struct intr_info), NULL, NULL);
 988                         flp->state &= ~SDLA_S508_INTEN;
 989                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
 990                         break;
 991         }
 992
 993         sdla_cmd(dev, SDLA_DISABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
 994
 995         netif_stop_queue(dev);
 996
 997         return 0;
 998 }
 999
1000 struct conf_data {
1001         struct frad_conf config;
1002         short            dlci[CONFIG_DLCI_MAX];
1003 };
1004
1005 static int sdla_open(struct net_device *dev)
1006 {
1007         struct frad_local *flp;
1008         struct dlci_local *dlp;
1009         struct conf_data  data;
1010         struct intr_info  intr;
1011         int               len, i;
1012         char              byte;
1013
1014         flp = netdev_priv(dev);
1015
1016         if (!flp->initialized)
1017                 return -EPERM;
1018
1019         if (!flp->configured)
1020                 return -EPERM;
1021
1022         /* time to send in the configuration */
1023         len = 0;
1024         for(i=0;i<CONFIG_DLCI_MAX;i++)
1025                 if (flp->dlci[i])
1026                         data.dlci[len++] = abs(flp->dlci[i]);
1027         len *= 2;
1028
1029         memcpy(&data.config, &flp->config, sizeof(struct frad_conf));
1030         len += sizeof(struct frad_conf);
1031
1032         sdla_cmd(dev, SDLA_DISABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
1033         sdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, 0, 0, &data, len, NULL, NULL);
1034
1035         if (flp->type == SDLA_S508)
1036                 flp->buffer = 0;
1037
1038         sdla_cmd(dev, SDLA_ENABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
1039
1040         /* let's start up the reception */
1041         memset(&intr, 0, sizeof(intr));
1042         switch(flp->type)
1043         {
1044                 case SDLA_S502A:
1045                         flp->timer.expires = 1;
1046                         add_timer(&flp->timer);
1047                         break;
1048
1049                 case SDLA_S502E:
1050                         flp->state |= SDLA_S502E_ENABLE;
1051                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
1052                         flp->state |= SDLA_S502E_INTACK;
1053                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
1054                         byte = 0;
1055                         sdla_write(dev, SDLA_502_IRQ_INTERFACE, &byte, sizeof(byte));
1056                         intr.flags = SDLA_INTR_RX | SDLA_INTR_STATUS | SDLA_INTR_MODEM;
1057                         sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(char) + sizeof(short), NULL, NULL);
1058                         break;
1059
1060                 case SDLA_S507:
1061                         break;
1062
1063                 case SDLA_S508:
1064                         flp->state |= SDLA_S508_INTEN;
1065                         outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
1066                         byte = 0;
1067                         sdla_write(dev, SDLA_508_IRQ_INTERFACE, &byte, sizeof(byte));
1068                         intr.flags = SDLA_INTR_RX | SDLA_INTR_STATUS | SDLA_INTR_MODEM;
1069                         intr.irq = dev->irq;
1070                         sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(struct intr_info), NULL, NULL);
1071                         break;
1072         }
1073
1074         if (flp->config.station == FRAD_STATION_CPE)
1075         {
1076                 byte = SDLA_ICS_STATUS_ENQ;
1077                 sdla_cmd(dev, SDLA_ISSUE_IN_CHANNEL_SIGNAL, 0, 0, &byte, sizeof(byte), NULL, NULL);
1078         }
1079         else
1080         {
1081                 sdla_cmd(dev, SDLA_ADD_DLCI, 0, 0, data.dlci, len - sizeof(struct frad_conf), NULL, NULL);
1082                 for(i=0;i<CONFIG_DLCI_MAX;i++)
1083                         if (flp->dlci[i] > 0)
1084                                 sdla_cmd(dev, SDLA_ACTIVATE_DLCI, 0, 0, &flp->dlci[i], 2*sizeof(flp->dlci[i]), NULL, NULL);
1085         }
1086
1087         /* configure any specific DLCI settings */
1088         for(i=0;i<CONFIG_DLCI_MAX;i++)
1089                 if (flp->dlci[i])
1090                 {
1091                         dlp = netdev_priv(flp->master[i]);
1092                         if (dlp->configured)
1093                                 sdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, abs(flp->dlci[i]), 0, &dlp->config, sizeof(struct dlci_conf), NULL, NULL);
1094                 }
1095
1096         netif_start_queue(dev);
1097
1098         return 0;
1099 }
1100
1101 static int sdla_config(struct net_device *dev, struct frad_conf __user *conf, int get)
1102 {
1103         struct frad_local *flp;
1104         struct conf_data  data;
1105         int               i;
1106         short             size;
1107
1108         if (dev->type == 0xFFFF)
1109                 return -EUNATCH;
1110
1111         flp = netdev_priv(dev);
1112
1113         if (!get)
1114         {
1115                 if (netif_running(dev))
1116                         return -EBUSY;
1117
1118                 if(copy_from_user(&data.config, conf, sizeof(struct frad_conf)))
1119                         return -EFAULT;
1120
1121                 if (data.config.station & ~FRAD_STATION_NODE)
1122                         return -EINVAL;
1123
1124                 if (data.config.flags & ~FRAD_VALID_FLAGS)
1125                         return -EINVAL;
1126
1127                 if ((data.config.kbaud < 0) ||
1128                          ((data.config.kbaud > 128) && (flp->type != SDLA_S508)))
1129                         return -EINVAL;
1130
1131                 if (data.config.clocking & ~(FRAD_CLOCK_INT | SDLA_S508_PORT_RS232))
1132                         return -EINVAL;
1133
1134                 if ((data.config.mtu < 0) || (data.config.mtu > SDLA_MAX_MTU))
1135                         return -EINVAL;
1136
1137                 if ((data.config.T391 < 5) || (data.config.T391 > 30))
1138                         return -EINVAL;
1139
1140                 if ((data.config.T392 < 5) || (data.config.T392 > 30))
1141                         return -EINVAL;
1142
1143                 if ((data.config.N391 < 1) || (data.config.N391 > 255))
1144                         return -EINVAL;
1145
1146                 if ((data.config.N392 < 1) || (data.config.N392 > 10))
1147                         return -EINVAL;
1148
1149                 if ((data.config.N393 < 1) || (data.config.N393 > 10))
1150                         return -EINVAL;
1151
1152                 memcpy(&flp->config, &data.config, sizeof(struct frad_conf));
1153                 flp->config.flags |= SDLA_DIRECT_RECV;
1154
1155                 if (flp->type == SDLA_S508)
1156                         flp->config.flags |= SDLA_TX70_RX30;
1157
1158                 if (dev->mtu != flp->config.mtu)
1159                 {
1160                         /* this is required to change the MTU */
1161                         dev->mtu = flp->config.mtu;
1162                         for(i=0;i<CONFIG_DLCI_MAX;i++)
1163                                 if (flp->master[i])
1164                                         flp->master[i]->mtu = flp->config.mtu;
1165                 }
1166
1167                 flp->config.mtu += sizeof(struct frhdr);
1168
1169                 /* off to the races! */
1170                 if (!flp->configured)
1171                         sdla_start(dev);
1172
1173                 flp->configured = 1;
1174         }
1175         else
1176         {
1177                 /* no sense reading if the CPU isn't started */
1178                 if (netif_running(dev))
1179                 {
1180                         size = sizeof(data);
1181                         if (sdla_cmd(dev, SDLA_READ_DLCI_CONFIGURATION, 0, 0, NULL, 0, &data, &size) != SDLA_RET_OK)
1182                                 return -EIO;
1183                 }
1184                 else
1185                         if (flp->configured)
1186                                 memcpy(&data.config, &flp->config, sizeof(struct frad_conf));
1187                         else
1188                                 memset(&data.config, 0, sizeof(struct frad_conf));
1189
1190                 memcpy(&flp->config, &data.config, sizeof(struct frad_conf));
1191                 data.config.flags &= FRAD_VALID_FLAGS;
1192                 data.config.mtu -= data.config.mtu > sizeof(struct frhdr) ? sizeof(struct frhdr) : data.config.mtu;
1193                 return copy_to_user(conf, &data.config, sizeof(struct frad_conf))?-EFAULT:0;
1194         }
1195
1196         return 0;
1197 }
1198
1199 static int sdla_xfer(struct net_device *dev, struct sdla_mem __user *info, int read)
1200 {
1201         struct sdla_mem mem;
1202         char    *temp;
1203
1204         if(copy_from_user(&mem, info, sizeof(mem)))
1205                 return -EFAULT;
1206
1207         if (read)
1208         {
1209                 temp = kzalloc(mem.len, GFP_KERNEL);
1210                 if (!temp)
1211                         return -ENOMEM;
1212                 sdla_read(dev, mem.addr, temp, mem.len);
1213                 if(copy_to_user(mem.data, temp, mem.len))
1214                 {
1215                         kfree(temp);
1216                         return -EFAULT;
1217                 }
1218                 kfree(temp);
1219         }
1220         else
1221         {
1222                 temp = memdup_user(mem.data, mem.len);
1223                 if (IS_ERR(temp))
1224                         return PTR_ERR(temp);
1225                 sdla_write(dev, mem.addr, temp, mem.len);
1226                 kfree(temp);
1227         }
1228         return 0;
1229 }
1230
1231 static int sdla_reconfig(struct net_device *dev)
1232 {
1233         struct frad_local *flp;
1234         struct conf_data  data;
1235         int               i, len;
1236
1237         flp = netdev_priv(dev);
1238
1239         len = 0;
1240         for(i=0;i<CONFIG_DLCI_MAX;i++)
1241                 if (flp->dlci[i])
1242                         data.dlci[len++] = flp->dlci[i];
1243         len *= 2;
1244
1245         memcpy(&data, &flp->config, sizeof(struct frad_conf));
1246         len += sizeof(struct frad_conf);
1247
1248         sdla_cmd(dev, SDLA_DISABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
1249         sdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, 0, 0, &data, len, NULL, NULL);
1250         sdla_cmd(dev, SDLA_ENABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
1251
1252         return 0;
1253 }
1254
1255 static int sdla_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1256 {
1257         struct frad_local *flp;
1258
1259         if(!capable(CAP_NET_ADMIN))
1260                 return -EPERM;
1261
1262         flp = netdev_priv(dev);
1263
1264         if (!flp->initialized)
1265                 return -EINVAL;
1266
1267         switch (cmd)
1268         {
1269                 case FRAD_GET_CONF:
1270                 case FRAD_SET_CONF:
1271                         return sdla_config(dev, ifr->ifr_data, cmd == FRAD_GET_CONF);
1272
1273                 case SDLA_IDENTIFY:
1274                         ifr->ifr_flags = flp->type;
1275                         break;
1276
1277                 case SDLA_CPUSPEED:
1278                         return sdla_cpuspeed(dev, ifr);
1279
1280 /* ==========================================================
1281 NOTE:  This is rather a useless action right now, as the
1282        current driver does not support protocols other than
1283        FR.  However, Sangoma has modules for a number of
1284        other protocols in the works.
1285 ============================================================*/
1286                 case SDLA_PROTOCOL:
1287                         if (flp->configured)
1288                                 return -EALREADY;
1289
1290                         switch (ifr->ifr_flags)
1291                         {
1292                                 case ARPHRD_FRAD:
1293                                         dev->type = ifr->ifr_flags;
1294                                         break;
1295                                 default:
1296                                         return -ENOPROTOOPT;
1297                         }
1298                         break;
1299
1300                 case SDLA_CLEARMEM:
1301                         sdla_clear(dev);
1302                         break;
1303
1304                 case SDLA_WRITEMEM:
1305                 case SDLA_READMEM:
1306                         if(!capable(CAP_SYS_RAWIO))
1307                                 return -EPERM;
1308                         return sdla_xfer(dev, ifr->ifr_data, cmd == SDLA_READMEM);
1309
1310                 case SDLA_START:
1311                         sdla_start(dev);
1312                         break;
1313
1314                 case SDLA_STOP:
1315                         sdla_stop(dev);
1316                         break;
1317
1318                 default:
1319                         return -EOPNOTSUPP;
1320         }
1321         return 0;
1322 }
1323
1324 static int sdla_change_mtu(struct net_device *dev, int new_mtu)
1325 {
1326         struct frad_local *flp;
1327
1328         flp = netdev_priv(dev);
1329
1330         if (netif_running(dev))
1331                 return -EBUSY;
1332
1333         /* for now, you can't change the MTU! */
1334         return -EOPNOTSUPP;
1335 }
1336
1337 static int sdla_set_config(struct net_device *dev, struct ifmap *map)
1338 {
1339         struct frad_local *flp;
1340         int               i;
1341         char              byte;
1342         unsigned base;
1343         int err = -EINVAL;
1344
1345         flp = netdev_priv(dev);
1346
1347         if (flp->initialized)
1348                 return -EINVAL;
1349
1350         for(i=0; i < ARRAY_SIZE(valid_port); i++)
1351                 if (valid_port[i] == map->base_addr)
1352                         break;
1353
1354         if (i == ARRAY_SIZE(valid_port))
1355                 return -EINVAL;
1356
1357         if (!request_region(map->base_addr, SDLA_IO_EXTENTS, dev->name)){
1358                 pr_warn("io-port 0x%04lx in use\n", dev->base_addr);
1359                 return -EINVAL;
1360         }
1361         base = map->base_addr;
1362
1363         /* test for card types, S502A, S502E, S507, S508                 */
1364         /* these tests shut down the card completely, so clear the state */
1365         flp->type = SDLA_UNKNOWN;
1366         flp->state = 0;
1367
1368         for(i=1;i<SDLA_IO_EXTENTS;i++)
1369                 if (inb(base + i) != 0xFF)
1370                         break;
1371
1372         if (i == SDLA_IO_EXTENTS) {
1373                 outb(SDLA_HALT, base + SDLA_REG_Z80_CONTROL);
1374                 if ((inb(base + SDLA_S502_STS) & 0x0F) == 0x08) {
1375                         outb(SDLA_S502E_INTACK, base + SDLA_REG_CONTROL);
1376                         if ((inb(base + SDLA_S502_STS) & 0x0F) == 0x0C) {
1377                                 outb(SDLA_HALT, base + SDLA_REG_CONTROL);
1378                                 flp->type = SDLA_S502E;
1379                                 goto got_type;
1380                         }
1381                 }
1382         }
1383
1384         for(byte=inb(base),i=0;i<SDLA_IO_EXTENTS;i++)
1385                 if (inb(base + i) != byte)
1386                         break;
1387
1388         if (i == SDLA_IO_EXTENTS) {
1389                 outb(SDLA_HALT, base + SDLA_REG_CONTROL);
1390                 if ((inb(base + SDLA_S502_STS) & 0x7E) == 0x30) {
1391                         outb(SDLA_S507_ENABLE, base + SDLA_REG_CONTROL);
1392                         if ((inb(base + SDLA_S502_STS) & 0x7E) == 0x32) {
1393                                 outb(SDLA_HALT, base + SDLA_REG_CONTROL);
1394                                 flp->type = SDLA_S507;
1395                                 goto got_type;
1396                         }
1397                 }
1398         }
1399
1400         outb(SDLA_HALT, base + SDLA_REG_CONTROL);
1401         if ((inb(base + SDLA_S508_STS) & 0x3F) == 0x00) {
1402                 outb(SDLA_S508_INTEN, base + SDLA_REG_CONTROL);
1403                 if ((inb(base + SDLA_S508_STS) & 0x3F) == 0x10) {
1404                         outb(SDLA_HALT, base + SDLA_REG_CONTROL);
1405                         flp->type = SDLA_S508;
1406                         goto got_type;
1407                 }
1408         }
1409
1410         outb(SDLA_S502A_HALT, base + SDLA_REG_CONTROL);
1411         if (inb(base + SDLA_S502_STS) == 0x40) {
1412                 outb(SDLA_S502A_START, base + SDLA_REG_CONTROL);
1413                 if (inb(base + SDLA_S502_STS) == 0x40) {
1414                         outb(SDLA_S502A_INTEN, base + SDLA_REG_CONTROL);
1415                         if (inb(base + SDLA_S502_STS) == 0x44) {
1416                                 outb(SDLA_S502A_START, base + SDLA_REG_CONTROL);
1417                                 flp->type = SDLA_S502A;
1418                                 goto got_type;
1419                         }
1420                 }
1421         }
1422
1423         netdev_notice(dev, "Unknown card type\n");
1424         err = -ENODEV;
1425         goto fail;
1426
1427 got_type:
1428         switch(base) {
1429                 case 0x270:
1430                 case 0x280:
1431                 case 0x380:
1432                 case 0x390:
1433                         if (flp->type != SDLA_S508 && flp->type != SDLA_S507)
1434                                 goto fail;
1435         }
1436
1437         switch (map->irq) {
1438                 case 2:
1439                         if (flp->type != SDLA_S502E)
1440                                 goto fail;
1441                         break;
1442
1443                 case 10:
1444                 case 11:
1445                 case 12:
1446                 case 15:
1447                 case 4:
1448                         if (flp->type != SDLA_S508 && flp->type != SDLA_S507)
1449                                 goto fail;
1450                         break;
1451                 case 3:
1452                 case 5:
1453                 case 7:
1454                         if (flp->type == SDLA_S502A)
1455                                 goto fail;
1456                         break;
1457
1458                 default:
1459                         goto fail;
1460         }
1461
1462         err = -EAGAIN;
1463         if (request_irq(dev->irq, sdla_isr, 0, dev->name, dev))
1464                 goto fail;
1465
1466         if (flp->type == SDLA_S507) {
1467                 switch(dev->irq) {
1468                         case 3:
1469                                 flp->state = SDLA_S507_IRQ3;
1470                                 break;
1471                         case 4:
1472                                 flp->state = SDLA_S507_IRQ4;
1473                                 break;
1474                         case 5:
1475                                 flp->state = SDLA_S507_IRQ5;
1476                                 break;
1477                         case 7:
1478                                 flp->state = SDLA_S507_IRQ7;
1479                                 break;
1480                         case 10:
1481                                 flp->state = SDLA_S507_IRQ10;
1482                                 break;
1483                         case 11:
1484                                 flp->state = SDLA_S507_IRQ11;
1485                                 break;
1486                         case 12:
1487                                 flp->state = SDLA_S507_IRQ12;
1488                                 break;
1489                         case 15:
1490                                 flp->state = SDLA_S507_IRQ15;
1491                                 break;
1492                 }
1493         }
1494
1495         for(i=0; i < ARRAY_SIZE(valid_mem); i++)
1496                 if (valid_mem[i] == map->mem_start)
1497                         break;
1498
1499         err = -EINVAL;
1500         if (i == ARRAY_SIZE(valid_mem))
1501                 goto fail2;
1502
1503         if (flp->type == SDLA_S502A && (map->mem_start & 0xF000) >> 12 == 0x0E)
1504                 goto fail2;
1505
1506         if (flp->type != SDLA_S507 && map->mem_start >> 16 == 0x0B)
1507                 goto fail2;
1508
1509         if (flp->type == SDLA_S507 && map->mem_start >> 16 == 0x0D)
1510                 goto fail2;
1511
1512         byte = flp->type != SDLA_S508 ? SDLA_8K_WINDOW : 0;
1513         byte |= (map->mem_start & 0xF000) >> (12 + (flp->type == SDLA_S508 ? 1 : 0));
1514         switch(flp->type) {
1515                 case SDLA_S502A:
1516                 case SDLA_S502E:
1517                         switch (map->mem_start >> 16) {
1518                                 case 0x0A:
1519                                         byte |= SDLA_S502_SEG_A;
1520                                         break;
1521                                 case 0x0C:
1522                                         byte |= SDLA_S502_SEG_C;
1523                                         break;
1524                                 case 0x0D:
1525                                         byte |= SDLA_S502_SEG_D;
1526                                         break;
1527                                 case 0x0E:
1528                                         byte |= SDLA_S502_SEG_E;
1529                                         break;
1530                         }
1531                         break;
1532                 case SDLA_S507:
1533                         switch (map->mem_start >> 16) {
1534                                 case 0x0A:
1535                                         byte |= SDLA_S507_SEG_A;
1536                                         break;
1537                                 case 0x0B:
1538                                         byte |= SDLA_S507_SEG_B;
1539                                         break;
1540                                 case 0x0C:
1541                                         byte |= SDLA_S507_SEG_C;
1542                                         break;
1543                                 case 0x0E:
1544                                         byte |= SDLA_S507_SEG_E;
1545                                         break;
1546                         }
1547                         break;
1548                 case SDLA_S508:
1549                         switch (map->mem_start >> 16) {
1550                                 case 0x0A:
1551                                         byte |= SDLA_S508_SEG_A;
1552                                         break;
1553                                 case 0x0C:
1554                                         byte |= SDLA_S508_SEG_C;
1555                                         break;
1556                                 case 0x0D:
1557                                         byte |= SDLA_S508_SEG_D;
1558                                         break;
1559                                 case 0x0E:
1560                                         byte |= SDLA_S508_SEG_E;
1561                                         break;
1562                         }
1563                         break;
1564         }
1565
1566         /* set the memory bits, and enable access */
1567         outb(byte, base + SDLA_REG_PC_WINDOW);
1568
1569         switch(flp->type)
1570         {
1571                 case SDLA_S502E:
1572                         flp->state = SDLA_S502E_ENABLE;
1573                         break;
1574                 case SDLA_S507:
1575                         flp->state |= SDLA_MEMEN;
1576                         break;
1577                 case SDLA_S508:
1578                         flp->state = SDLA_MEMEN;
1579                         break;
1580         }
1581         outb(flp->state, base + SDLA_REG_CONTROL);
1582
1583         dev->irq = map->irq;
1584         dev->base_addr = base;
1585         dev->mem_start = map->mem_start;
1586         dev->mem_end = dev->mem_start + 0x2000;
1587         flp->initialized = 1;
1588         return 0;
1589
1590 fail2:
1591         free_irq(map->irq, dev);
1592 fail:
1593         release_region(base, SDLA_IO_EXTENTS);
1594         return err;
1595 }
1596
1597 static const struct net_device_ops sdla_netdev_ops = {
1598         .ndo_open       = sdla_open,
1599         .ndo_stop       = sdla_close,
1600         .ndo_do_ioctl   = sdla_ioctl,
1601         .ndo_set_config = sdla_set_config,
1602         .ndo_start_xmit = sdla_transmit,
1603         .ndo_change_mtu = sdla_change_mtu,
1604 };
1605
1606 static void setup_sdla(struct net_device *dev)
1607 {
1608         struct frad_local *flp = netdev_priv(dev);
1609
1610         netdev_boot_setup_check(dev);
1611
1612         dev->netdev_ops         = &sdla_netdev_ops;
1613         dev->flags              = 0;
1614         dev->type               = 0xFFFF;
1615         dev->hard_header_len    = 0;
1616         dev->addr_len           = 0;
1617         dev->mtu                = SDLA_MAX_MTU;
1618
1619         flp->activate           = sdla_activate;
1620         flp->deactivate         = sdla_deactivate;
1621         flp->assoc              = sdla_assoc;
1622         flp->deassoc            = sdla_deassoc;
1623         flp->dlci_conf          = sdla_dlci_conf;
1624
1625         init_timer(&flp->timer);
1626         flp->timer.expires      = 1;
1627         flp->timer.data         = (unsigned long) dev;
1628         flp->timer.function     = sdla_poll;
1629 }
1630
1631 static struct net_device *sdla;
1632
1633 static int __init init_sdla(void)
1634 {
1635         int err;
1636
1637         printk("%s.\n", version);
1638
1639         sdla = alloc_netdev(sizeof(struct frad_local), "sdla0", setup_sdla);
1640         if (!sdla)
1641                 return -ENOMEM;
1642
1643         err = register_netdev(sdla);
1644         if (err)
1645                 free_netdev(sdla);
1646
1647         return err;
1648 }
1649
1650 static void __exit exit_sdla(void)
1651 {
1652         struct frad_local *flp = netdev_priv(sdla);
1653
1654         unregister_netdev(sdla);
1655         if (flp->initialized) {
1656                 free_irq(sdla->irq, sdla);
1657                 release_region(sdla->base_addr, SDLA_IO_EXTENTS);
1658         }
1659         del_timer_sync(&flp->timer);
1660         free_netdev(sdla);
1661 }
1662
1663 MODULE_LICENSE("GPL");
1664
1665 module_init(init_sdla);
1666 module_exit(exit_sdla);