drivers/net/sdlamain.c

   1 /*****************************************************************************
   2 * sdlamain.c    WANPIPE(tm) Multiprotocol WAN Link Driver.  Main module.
   3 *
   4 * Author:       Gene Kozin      <genek@compuserve.com>
   5 *
   6 * Copyright:    (c) 1995-1997 Sangoma Technologies Inc.
   7 *
   8 *               This program is free software; you can redistribute it and/or
   9 *               modify it under the terms of the GNU General Public License
  10 *               as published by the Free Software Foundation; either version
  11 *               2 of the License, or (at your option) any later version.
  12 * ============================================================================
  13 * Jan 02, 1997  Gene Kozin      Initial version.
  14 *****************************************************************************/
  15
  16 #if     !defined(__KERNEL__) || !defined(MODULE)
  17 #error  This code MUST be compiled as a kernel module!
  18 #endif
  19
  20 #include <linux/config.h>       /* OS configuration options */
  21 #include <linux/stddef.h>       /* offsetof(), etc. */
  22 #include <linux/errno.h>        /* return codes */
  23 #include <linux/string.h>       /* inline memset(), etc. */
  24 #include <linux/malloc.h>       /* kmalloc(), kfree() */
  25 #include <linux/kernel.h>       /* printk(), and other useful stuff */
  26 #include <linux/module.h>       /* support for loadable modules */
  27 #include <linux/ioport.h>       /* request_region(), release_region() */
  28 #include <linux/tqueue.h>       /* for kernel task queues */
  29 #include <linux/router.h>       /* WAN router definitions */
  30 #include <linux/wanpipe.h>      /* WANPIPE common user API definitions */
  31 #include <asm/segment.h>        /* kernel <-> user copy */
  32
  33 /****** Defines & Macros ****************************************************/
  34
  35 #ifdef  _DEBUG_
  36 #define STATIC
  37 #else
  38 #define STATIC          static
  39 #endif
  40
  41 #define DRV_VERSION     3               /* version number */
  42 #define DRV_RELEASE     0               /* release (minor version) number */
  43 #define MAX_CARDS       8               /* max number of adapters */
  44
  45 #ifndef CONFIG_WANPIPE_CARDS            /* configurable option */
  46 #define CONFIG_WANPIPE_CARDS 1
  47 #endif
  48
  49 #define CMD_OK          0               /* normal firmware return code */
  50 #define CMD_TIMEOUT     0xFF            /* firmware command timed out */
  51 #define MAX_CMD_RETRY   10              /* max number of firmware retries */
  52
  53 /****** Function Prototypes *************************************************/
  54
  55 /* Module entry points */
  56 int init_module (void);
  57 void cleanup_module (void);
  58
  59 /* WAN link driver entry points */
  60 static int setup    (wan_device_t* wandev, wandev_conf_t* conf);
  61 static int shutdown (wan_device_t* wandev);
  62 static int ioctl    (wan_device_t* wandev, unsigned cmd, unsigned long arg);
  63
  64 /* IOCTL hanlers */
  65 static int ioctl_dump   (sdla_t* card, sdla_dump_t* u_dump);
  66 static int ioctl_exec   (sdla_t* card, sdla_exec_t* u_exec);
  67
  68 /* Miscellaneous functions */
  69 STATIC void sdla_isr    (int irq, void* dev_id, struct pt_regs *regs);
  70 STATIC void sdla_poll   (void* data);
  71
  72 /****** Global Data **********************************************************
  73  * Note: All data must be explicitly initialized!!!
  74  */
  75
  76 /* private data */
  77 static char drvname[]   = "wanpipe";
  78 static char fullname[]  = "WANPIPE(tm) Multiprotocol Driver";
  79 static char copyright[] = "(c) 1995-1996 Sangoma Technologies Inc.";
  80 static int ncards = CONFIG_WANPIPE_CARDS;
  81 static int active = 0;                  /* number of active cards */
  82 static sdla_t* card_array = NULL;       /* adapter data space */
  83
  84 /* Task queue element for creating a 'thread' */
  85 static struct tq_struct sdla_tq =
  86 {
  87         NULL,           /* .next */
  88         0,              /* .sync */
  89         &sdla_poll,     /* .routine */
  90         NULL            /* .data */
  91 };
  92
  93 /******* Kernel Loadable Module Entry Points ********************************/
  94
  95 /*============================================================================
  96  * Module 'insert' entry point.
  97  * o print announcement
  98  * o allocate adapter data space
  99  * o initialize static data
 100  * o register all cards with WAN router
 101  * o calibrate SDLA shared memory access delay.
 102  *
 103  * Return:      0       Ok
 104  *              < 0     error.
 105  * Context:     process
 106  */
 107 int init_module (void)
 108 {
 109         int cnt, err = 0;
 110
 111         printk(KERN_INFO "%s v%u.%u %s\n",
 112                 fullname, DRV_VERSION, DRV_RELEASE, copyright)
 113         ;
 114
 115         /* Verify number of cards and allocate adapter data space */
 116         ncards = min(ncards, MAX_CARDS);
 117         ncards = max(ncards, 1);
 118         card_array = kmalloc(sizeof(sdla_t) * ncards, GFP_KERNEL);
 119         if (card_array == NULL)
 120                 return -ENOMEM
 121         ;
 122         memset(card_array, 0, sizeof(sdla_t) * ncards);
 123
 124         /* Register adapters with WAN router */
 125         for (cnt = 0; cnt < ncards; ++cnt)
 126         {
 127                 sdla_t* card = &card_array[cnt];
 128                 wan_device_t* wandev = &card->wandev;
 129
 130                 sprintf(card->devname, "%s%d", drvname, cnt + 1);
 131                 wandev->magic    = ROUTER_MAGIC;
 132                 wandev->name     = card->devname;
 133                 wandev->private  = card;
 134                 wandev->setup    = &setup;
 135                 wandev->shutdown = &shutdown;
 136                 wandev->ioctl    = &ioctl;
 137                 err = register_wandev(wandev);
 138                 if (err)
 139                 {
 140                         printk(KERN_ERR
 141                                 "%s: %s registration failed with error %d!\n",
 142                                 drvname, card->devname, err)
 143                         ;
 144                         break;
 145                 }
 146         }
 147         if (cnt) ncards = cnt;  /* adjust actual number of cards */
 148         else kfree(card_array);
 149         return err;
 150 }
 151
 152 /*============================================================================
 153  * Module 'remove' entry point.
 154  * o unregister all adapters from the WAN router
 155  * o release all remaining system resources
 156  */
 157 void cleanup_module (void)
 158 {
 159         int i;
 160
 161         for (i = 0; i < ncards; ++i)
 162         {
 163                 sdla_t* card = &card_array[i];
 164                 unregister_wandev(card->devname);
 165         }
 166         kfree(card_array);
 167 }
 168
 169 /******* WAN Device Driver Entry Points *************************************/
 170
 171 /*============================================================================
 172  * Setup/confugure WAN link driver.
 173  * o check adapter state
 174  * o make sure firmware is present in configuration
 175  * o make sure I/O port and IRQ are specified
 176  * o make sure I/O region is available
 177  * o allocate interrupt vector
 178  * o setup SDLA hardware
 179  * o call appropriate routine to perform protocol-specific initialization
 180  * o mark I/O region as used
 181  * o if this is the first active card, then schedule background task
 182  *
 183  * This function is called when router handles ROUTER_SETUP IOCTL. The
 184  * configuration structure is in kernel memory (including extended data, if
 185  * any).
 186  */
 187 static int setup (wan_device_t* wandev, wandev_conf_t* conf)
 188 {
 189         sdla_t* card;
 190         int err = 0;
 191         int irq;
 192
 193         /* Sanity checks */
 194         if ((wandev == NULL) || (wandev->private == NULL) || (conf == NULL))
 195                 return -EFAULT
 196         ;
 197         card = wandev->private;
 198         if (wandev->state != WAN_UNCONFIGURED)
 199                 return -EBUSY           /* already configured */
 200         ;
 201         if (!conf->data_size || (conf->data == NULL))
 202         {
 203                 printk(KERN_ERR
 204                         "%s: firmware not found in configuration data!\n",
 205                         wandev->name)
 206                 ;
 207                 return -EINVAL;
 208         }
 209         if (conf->ioport <= 0)
 210         {
 211                 printk(KERN_ERR
 212                         "%s: can't configure without I/O port address!\n",
 213                         wandev->name)
 214                 ;
 215                 return -EINVAL;
 216         }
 217         if (conf->irq <= 0)
 218         {
 219                 printk(KERN_ERR "%s: can't configure without IRQ!\n",
 220                         wandev->name)
 221                 ;
 222                 return -EINVAL;
 223         }
 224
 225         /* Make sure I/O port region is available */
 226         if (check_region(conf->ioport, SDLA_MAXIORANGE))
 227         {
 228                 printk(KERN_ERR "%s: I/O region 0x%X - 0x%X is in use!\n",
 229                         wandev->name, conf->ioport,
 230                         conf->ioport + SDLA_MAXIORANGE)
 231                 ;
 232                 return -EINVAL;
 233         }
 234
 235         /* Allocate IRQ */
 236         irq = (conf->irq == 2) ? 9 : conf->irq; /* IRQ2 -> IRQ9 */
 237         if (request_irq(irq, sdla_isr, 0, wandev->name, card))
 238         {
 239                 printk(KERN_ERR "%s: can't reserve IRQ %d!\n",
 240                         wandev->name, irq)
 241                 ;
 242                 return -EINVAL;
 243         }
 244
 245         /* Configure hardware, load firmware, etc. */
 246         memset(&card->hw, 0, sizeof(sdlahw_t));
 247         card->hw.port    = conf->ioport;
 248         card->hw.irq     = (conf->irq == 9) ? 2 : conf->irq;
 249         card->hw.dpmbase = conf->maddr;
 250         card->hw.dpmsize = SDLA_WINDOWSIZE;
 251         card->hw.type    = conf->hw_opt[0];
 252         card->hw.pclk    = conf->hw_opt[1];
 253         err = sdla_setup(&card->hw, conf->data, conf->data_size);
 254         if (err)
 255         {
 256                 free_irq(irq, card);
 257                 return err;
 258         }
 259
 260         /* Intialize WAN device data space */
 261         wandev->irq       = irq;
 262         wandev->dma       = 0;
 263         wandev->ioport    = card->hw.port;
 264         wandev->maddr     = card->hw.dpmbase;
 265         wandev->msize     = card->hw.dpmsize;
 266         wandev->hw_opt[0] = card->hw.type;
 267         wandev->hw_opt[1] = card->hw.pclk;
 268         wandev->hw_opt[2] = card->hw.memory;
 269         wandev->hw_opt[3] = card->hw.fwid;
 270
 271         /* Protocol-specific initialization */
 272         switch (card->hw.fwid)
 273         {
 274 #ifdef  CONFIG_WANPIPE_X25
 275         case SFID_X25_502:
 276         case SFID_X25_508:
 277                 err = wpx_init(card, conf);
 278                 break;
 279 #endif
 280
 281 #ifdef  CONFIG_WANPIPE_FR
 282         case SFID_FR502:
 283         case SFID_FR508:
 284                 err = wpf_init(card, conf);
 285                 break;
 286 #endif
 287
 288 #ifdef  CONFIG_WANPIPE_PPP
 289         case SFID_PPP502:
 290         case SFID_PPP508:
 291                 err = wpp_init(card, conf);
 292                 break;
 293 #endif
 294
 295         default:
 296                 printk(KERN_ERR "%s: this firmware is not supported!\n",
 297                         wandev->name)
 298                 ;
 299                 err = -EINVAL;
 300         }
 301         if (err)
 302         {
 303                 sdla_down(&card->hw);
 304                 free_irq(irq, card);
 305                 return err;
 306         }
 307         /* Reserve I/O region and schedule background task */
 308         request_region(card->hw.port, card->hw.io_range, wandev->name);
 309         if (++active == 1)
 310                 queue_task(&sdla_tq, &tq_scheduler)
 311         ;
 312         wandev->critical = 0;
 313         return 0;
 314 }
 315
 316 /*============================================================================
 317  * Shut down WAN link driver.
 318  * o shut down adapter hardware
 319  * o release system resources.
 320  *
 321  * This function is called by the router when device is being unregistered or
 322  * when it handles ROUTER_DOWN IOCTL.
 323  */
 324 static int shutdown (wan_device_t* wandev)
 325 {
 326         sdla_t* card;
 327
 328         /* sanity checks */
 329         if ((wandev == NULL) || (wandev->private == NULL))
 330                 return -EFAULT
 331         ;
 332         if (wandev->state == WAN_UNCONFIGURED)
 333                 return 0
 334         ;
 335         if (test_and_set_bit(0, (void*)&wandev->critical))
 336                 return -EAGAIN
 337         ;
 338         card = wandev->private;
 339         wandev->state = WAN_UNCONFIGURED;
 340         if (--active == 0) schedule();  /* stop background thread */
 341         sdla_down(&card->hw);
 342         free_irq(wandev->irq, card);
 343         release_region(card->hw.port, card->hw.io_range);
 344         wandev->critical = 0;
 345         return 0;
 346 }
 347
 348 /*============================================================================
 349  * Driver I/O control.
 350  * o verify arguments
 351  * o perform requested action
 352  *
 353  * This function is called when router handles one of the reserved user
 354  * IOCTLs.  Note that 'arg' stil points to user address space.
 355  */
 356 static int ioctl (wan_device_t* wandev, unsigned cmd, unsigned long arg)
 357 {
 358         int err;
 359
 360         /* sanity checks */
 361         if ((wandev == NULL) || (wandev->private == NULL))
 362                 return -EFAULT
 363         ;
 364         if (wandev->state == WAN_UNCONFIGURED)
 365                 return -ENODEV
 366         ;
 367         if (test_and_set_bit(0, (void*)&wandev->critical))
 368                 return -EAGAIN
 369         ;
 370         switch (cmd)
 371         {
 372         case WANPIPE_DUMP:
 373                 err = ioctl_dump(wandev->private, (void*)arg);
 374                 break;
 375
 376         case WANPIPE_EXEC:
 377                 err = ioctl_exec(wandev->private, (void*)arg);
 378                 break;
 379
 380         default:
 381                 err = -EINVAL;
 382         }
 383         wandev->critical = 0;
 384         return err;
 385 }
 386
 387 /****** Driver IOCTL Hanlers ************************************************/
 388
 389 /*============================================================================
 390  * Dump adpater memory to user buffer.
 391  * o verify request structure
 392  * o copy request structure to kernel data space
 393  * o verify length/offset
 394  * o verify user buffer
 395  * o copy adapter memory image to user buffer
 396  *
 397  * Note: when dumping memory, this routine switches curent dual-port memory
 398  *       vector, so care must be taken to avoid racing conditions.
 399  */
 400 static int ioctl_dump (sdla_t* card, sdla_dump_t* u_dump)
 401 {
 402         sdla_dump_t dump;
 403         unsigned winsize;
 404         unsigned long oldvec;   /* DPM window vector */
 405         int err = 0;
 406
 407         if ((u_dump == NULL) ||
 408             verify_area(VERIFY_READ, u_dump, sizeof(sdla_dump_t)))
 409                 return -EFAULT
 410         ;
 411         memcpy_fromfs((void*)&dump, (void*)u_dump, sizeof(sdla_dump_t));
 412         if ((dump.magic != WANPIPE_MAGIC) ||
 413             (dump.offset + dump.length > card->hw.memory))
 414                 return -EINVAL
 415         ;
 416         if ((dump.ptr == NULL) ||
 417             verify_area(VERIFY_WRITE, dump.ptr, dump.length))
 418                 return -EFAULT
 419         ;
 420
 421         winsize = card->hw.dpmsize;
 422         cli();                          /* >>> critical section start <<< */
 423         oldvec = card->hw.vector;
 424         while (dump.length)
 425         {
 426                 unsigned pos = dump.offset % winsize;   /* current offset */
 427                 unsigned long vec = dump.offset - pos;  /* current vector */
 428                 unsigned len = (dump.length > (winsize - pos)) ?
 429                         (winsize - pos) : dump.length
 430                 ;
 431                 if (sdla_mapmem(&card->hw, vec) != 0)   /* relocate window */
 432                 {
 433                         err = -EIO;
 434                         break;
 435                 }
 436                 memcpy_tofs((void*)(dump.ptr),
 437                         (void*)(card->hw.dpmbase + pos), len)
 438                 ;
 439                 dump.length     -= len;
 440                 dump.offset     += len;
 441                 (char*)dump.ptr += len;
 442         }
 443         sdla_mapmem(&card->hw, oldvec); /* restore DPM window position */
 444         sti();                          /* >>> critical section end <<< */
 445         return err;
 446 }
 447
 448 /*============================================================================
 449  * Execute adapter firmware command.
 450  * o verify request structure
 451  * o copy request structure to kernel data space
 452  * o call protocol-specific 'exec' function
 453  */
 454 static int ioctl_exec (sdla_t* card, sdla_exec_t* u_exec)
 455 {
 456         sdla_exec_t exec;
 457
 458         if (card->exec == NULL)
 459                 return -ENODEV
 460         ;
 461         if ((u_exec == NULL) ||
 462             verify_area(VERIFY_READ, u_exec, sizeof(sdla_exec_t)))
 463                 return -EFAULT
 464         ;
 465         memcpy_fromfs((void*)&exec, (void*)u_exec, sizeof(sdla_exec_t));
 466         if ((exec.magic != WANPIPE_MAGIC) || (exec.cmd == NULL))
 467                 return -EINVAL
 468         ;
 469         return card->exec(card, exec.cmd, exec.data);
 470 }
 471
 472 /******* Miscellaneous ******************************************************/
 473
 474 /*============================================================================
 475  * SDLA Interrupt Service Routine.
 476  * o acknowledge SDLA hardware interrupt.
 477  * o call protocol-specific interrupt service routine, if any.
 478  */
 479 STATIC void sdla_isr (int irq, void* dev_id, struct pt_regs *regs)
 480 {
 481 #define card    ((sdla_t*)dev_id)
 482
 483         if (!card || (card->wandev.state == WAN_UNCONFIGURED))
 484                 return
 485         ;
 486         if (card->in_isr)
 487         {
 488                 printk(KERN_WARNING "%s: interrupt re-entrancy on IRQ %d!\n",
 489                         card->devname, card->wandev.irq)
 490                 ;
 491                 return;
 492         }
 493         card->in_isr = 1;
 494         sdla_intack(&card->hw);
 495         if (card->isr) card->isr(card);
 496         card->in_isr = 0;
 497
 498 #undef  card
 499 }
 500
 501 /*============================================================================
 502  * SDLA polling routine.
 503  * This routine simulates kernel thread to perform various housekeeping job.
 504  *
 505  * o for each configured device call its poll() routine
 506  * o if there is at least one active card, then reschedule itself once again
 507  */
 508 STATIC void sdla_poll (void* data)
 509 {
 510         int i;
 511
 512         for (i = 0; i < ncards; ++i)
 513         {
 514                 sdla_t* card = &card_array[i];
 515
 516                 if ((card->wandev.state != WAN_UNCONFIGURED) && card->poll &&
 517                     !test_and_set_bit(0, (void*)&card->wandev.critical))
 518                 {
 519                         card->poll(card);
 520                         card->wandev.critical = 0;
 521                 }
 522         }
 523         if (active) queue_task(&sdla_tq, &tq_scheduler);
 524 }
 525
 526 /*============================================================================
 527  * This routine is called by the protocol-specific modules when network
 528  * interface is being open.  The only reason we need this, is because we
 529  * have to call MOD_INC_USE_COUNT, but cannot include 'module.h' where it's
 530  * defined more than once into the same kernel module.
 531  */
 532 void wanpipe_open (sdla_t* card)
 533 {
 534         ++card->open_cnt;
 535         MOD_INC_USE_COUNT;
 536 }
 537
 538 /*============================================================================
 539  * This routine is called by the protocol-specific modules when network
 540  * interface is being closed.  The only reason we need this, is because we
 541  * have to call MOD_DEC_USE_COUNT, but cannot include 'module.h' where it's
 542  * defined more than once into the same kernel module.
 543  */
 544 void wanpipe_close (sdla_t* card)
 545 {
 546         --card->open_cnt;
 547         MOD_DEC_USE_COUNT;
 548 }
 549
 550 /*============================================================================
 551  * Set WAN device state.
 552  */
 553 void wanpipe_set_state (sdla_t* card, int state)
 554 {
 555         unsigned long flags;
 556
 557         save_flags(flags);
 558         cli();
 559         if (card->wandev.state != state)
 560         {
 561                 switch (state)
 562                 {
 563                 case WAN_CONNECTED:
 564                         printk (KERN_INFO "%s: link connected!\n",
 565                                 card->devname)
 566                         ;
 567                         break;
 568
 569                 case WAN_CONNECTING:
 570                         printk (KERN_INFO "%s: link connecting...\n",
 571                                 card->devname)
 572                         ;
 573                         break;
 574
 575                 case WAN_DISCONNECTED:
 576                         printk (KERN_INFO "%s: link disconnected!\n",
 577                                 card->devname)
 578                         ;
 579                         break;
 580                 }
 581                 card->wandev.state = state;
 582         }
 583         card->state_tick = jiffies;
 584         restore_flags(flags);
 585 }
 586
 587 /****** End *****************************************************************/