drivers/staging/dgap/dgap_driver.c

   1 /*
   2  * Copyright 2003 Digi International (www.digi.com)
   3  *      Scott H Kilau <Scott_Kilau at digi dot com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
  12  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13  * PURPOSE.  See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  *
  20  *      NOTE TO LINUX KERNEL HACKERS:  DO NOT REFORMAT THIS CODE!
  21  *
  22  *      This is shared code between Digi's CVS archive and the
  23  *      Linux Kernel sources.
  24  *      Changing the source just for reformatting needlessly breaks
  25  *      our CVS diff history.
  26  *
  27  *      Send any bug fixes/changes to:  Eng.Linux at digi dot com.
  28  *      Thank you.
  29  *
  30  * $Id: dgap_driver.c,v 1.3 2011/06/21 10:35:16 markh Exp $
  31  */
  32
  33
  34 #include <linux/kernel.h>
  35 #include <linux/module.h>
  36 #include <linux/pci.h>
  37 #include <linux/delay.h>        /* For udelay */
  38 #include <linux/slab.h>
  39 #include <asm/uaccess.h>        /* For copy_from_user/copy_to_user */
  40 #include <linux/sched.h>
  41
  42 #include "dgap_driver.h"
  43 #include "dgap_pci.h"
  44 #include "dgap_fep5.h"
  45 #include "dgap_tty.h"
  46 #include "dgap_conf.h"
  47 #include "dgap_parse.h"
  48 #include "dgap_trace.h"
  49 #include "dgap_sysfs.h"
  50
  51 MODULE_LICENSE("GPL");
  52 MODULE_AUTHOR("Digi International, http://www.digi.com");
  53 MODULE_DESCRIPTION("Driver for the Digi International EPCA PCI based product line");
  54 MODULE_SUPPORTED_DEVICE("dgap");
  55
  56 /*
  57  * insmod command line overrideable parameters
  58  *
  59  * NOTE: we use a set of macros to create the variables, which allows
  60  * us to specify the variable type, name, initial value, and description.
  61  */
  62 PARM_INT(debug,         0x00,           0644,   "Driver debugging level");
  63 PARM_INT(rawreadok,     1,              0644,   "Bypass flip buffers on input");
  64 PARM_INT(trcbuf_size,   0x100000,       0644,   "Debugging trace buffer size.");
  65
  66
  67 /**************************************************************************
  68  *
  69  * protos for this file
  70  *
  71  */
  72
  73 static int              dgap_start(void);
  74 static void             dgap_init_globals(void);
  75 static int              dgap_found_board(struct pci_dev *pdev, int id);
  76 static void             dgap_cleanup_board(struct board_t *brd);
  77 static void             dgap_poll_handler(ulong dummy);
  78 static int              dgap_init_pci(void);
  79 static int              dgap_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
  80 static void             dgap_remove_one(struct pci_dev *dev);
  81 static int              dgap_probe1(struct pci_dev *pdev, int card_type);
  82 static void             dgap_mbuf(struct board_t *brd, const char *fmt, ...);
  83 static int              dgap_do_remap(struct board_t *brd);
  84 static irqreturn_t      dgap_intr(int irq, void *voidbrd);
  85
  86 /* Driver load/unload functions */
  87 int                     dgap_init_module(void);
  88 void                    dgap_cleanup_module(void);
  89
  90 module_init(dgap_init_module);
  91 module_exit(dgap_cleanup_module);
  92
  93
  94 /*
  95  * File operations permitted on Control/Management major.
  96  */
  97 static struct file_operations DgapBoardFops =
  98 {
  99         .owner          =       THIS_MODULE,
 100 };
 101
 102
 103 /*
 104  * Globals
 105  */
 106 uint                    dgap_NumBoards;
 107 struct board_t          *dgap_Board[MAXBOARDS];
 108 DEFINE_SPINLOCK(dgap_global_lock);
 109 ulong                   dgap_poll_counter;
 110 char                    *dgap_config_buf;
 111 int                     dgap_driver_state = DRIVER_INITIALIZED;
 112 DEFINE_SPINLOCK(dgap_dl_lock);
 113 wait_queue_head_t       dgap_dl_wait;
 114 int                     dgap_dl_action;
 115 int                     dgap_poll_tick = 20;    /* Poll interval - 20 ms */
 116
 117 /*
 118  * Static vars.
 119  */
 120 static int              dgap_Major_Control_Registered = FALSE;
 121 static uint             dgap_driver_start = FALSE;
 122
 123 static struct class *   dgap_class;
 124
 125 /*
 126  * Poller stuff
 127  */
 128 static                  DEFINE_SPINLOCK(dgap_poll_lock);        /* Poll scheduling lock */
 129 static ulong            dgap_poll_time;                         /* Time of next poll */
 130 static uint             dgap_poll_stop;                         /* Used to tell poller to stop */
 131 static struct timer_list dgap_poll_timer;
 132
 133
 134 static struct pci_device_id dgap_pci_tbl[] = {
 135         {       DIGI_VID, PCI_DEVICE_XEM_DID,   PCI_ANY_ID, PCI_ANY_ID, 0, 0,   0 },
 136         {       DIGI_VID, PCI_DEVICE_CX_DID,    PCI_ANY_ID, PCI_ANY_ID, 0, 0,   1 },
 137         {       DIGI_VID, PCI_DEVICE_CX_IBM_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,  2 },
 138         {       DIGI_VID, PCI_DEVICE_EPCJ_DID,  PCI_ANY_ID, PCI_ANY_ID, 0, 0,   3 },
 139         {       DIGI_VID, PCI_DEVICE_920_2_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   4 },
 140         {       DIGI_VID, PCI_DEVICE_920_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   5 },
 141         {       DIGI_VID, PCI_DEVICE_920_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   6 },
 142         {       DIGI_VID, PCI_DEVICE_XR_DID,    PCI_ANY_ID, PCI_ANY_ID, 0, 0,   7 },
 143         {       DIGI_VID, PCI_DEVICE_XRJ_DID,   PCI_ANY_ID, PCI_ANY_ID, 0, 0,   8 },
 144         {       DIGI_VID, PCI_DEVICE_XR_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,  9 },
 145         {       DIGI_VID, PCI_DEVICE_XR_IBM_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,  10 },
 146         {       DIGI_VID, PCI_DEVICE_XR_SAIP_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
 147         {       DIGI_VID, PCI_DEVICE_XR_BULL_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
 148         {       DIGI_VID, PCI_DEVICE_920_8_HP_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 13 },
 149         {       DIGI_VID, PCI_DEVICE_XEM_HP_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,  14 },
 150         {0,}                                    /* 0 terminated list. */
 151 };
 152 MODULE_DEVICE_TABLE(pci, dgap_pci_tbl);
 153
 154
 155 /*
 156  * A generic list of Product names, PCI Vendor ID, and PCI Device ID.
 157  */
 158 struct board_id {
 159         uint config_type;
 160         uchar *name;
 161         uint maxports;
 162         uint dpatype;
 163 };
 164
 165 static struct board_id dgap_Ids[] =
 166 {
 167         {       PPCM,           PCI_DEVICE_XEM_NAME,    64,     (T_PCXM | T_PCLITE | T_PCIBUS)  },
 168         {       PCX,            PCI_DEVICE_CX_NAME,     128,    (T_CX | T_PCIBUS)               },
 169         {       PCX,            PCI_DEVICE_CX_IBM_NAME, 128,    (T_CX | T_PCIBUS)               },
 170         {       PEPC,           PCI_DEVICE_EPCJ_NAME,   224,    (T_EPC  | T_PCIBUS)             },
 171         {       APORT2_920P,    PCI_DEVICE_920_2_NAME,  2,      (T_PCXR | T_PCLITE | T_PCIBUS)  },
 172         {       APORT4_920P,    PCI_DEVICE_920_4_NAME,  4,      (T_PCXR | T_PCLITE | T_PCIBUS)  },
 173         {       APORT8_920P,    PCI_DEVICE_920_8_NAME,  8,      (T_PCXR | T_PCLITE | T_PCIBUS)  },
 174         {       PAPORT8,        PCI_DEVICE_XR_NAME,     8,      (T_PCXR | T_PCLITE | T_PCIBUS)  },
 175         {       PAPORT8,        PCI_DEVICE_XRJ_NAME,    8,      (T_PCXR | T_PCLITE | T_PCIBUS)  },
 176         {       PAPORT8,        PCI_DEVICE_XR_422_NAME, 8,      (T_PCXR | T_PCLITE | T_PCIBUS)  },
 177         {       PAPORT8,        PCI_DEVICE_XR_IBM_NAME, 8,      (T_PCXR | T_PCLITE | T_PCIBUS)  },
 178         {       PAPORT8,        PCI_DEVICE_XR_SAIP_NAME, 8,     (T_PCXR | T_PCLITE | T_PCIBUS)  },
 179         {       PAPORT8,        PCI_DEVICE_XR_BULL_NAME, 8,     (T_PCXR | T_PCLITE | T_PCIBUS)  },
 180         {       APORT8_920P,    PCI_DEVICE_920_8_HP_NAME, 8,    (T_PCXR | T_PCLITE | T_PCIBUS)  },
 181         {       PPCM,           PCI_DEVICE_XEM_HP_NAME, 64,     (T_PCXM | T_PCLITE | T_PCIBUS)  },
 182         {0,}                                            /* 0 terminated list. */
 183 };
 184
 185 static struct pci_driver dgap_driver = {
 186         .name           = "dgap",
 187         .probe          = dgap_init_one,
 188         .id_table       = dgap_pci_tbl,
 189         .remove         = dgap_remove_one,
 190 };
 191
 192
 193 char *dgap_state_text[] = {
 194         "Board Failed",
 195         "Configuration for board not found.\n\t\t\tRun mpi to configure board.",
 196         "Board Found",
 197         "Need Reset",
 198         "Finished Reset",
 199         "Need Config",
 200         "Finished Config",
 201         "Need Device Creation",
 202         "Requested Device Creation",
 203         "Finished Device Creation",
 204         "Need BIOS Load",
 205         "Requested BIOS",
 206         "Doing BIOS Load",
 207         "Finished BIOS Load",
 208         "Need FEP Load",
 209         "Requested FEP",
 210         "Doing FEP Load",
 211         "Finished FEP Load",
 212         "Requested PROC creation",
 213         "Finished PROC creation",
 214         "Board READY",
 215 };
 216
 217 char *dgap_driver_state_text[] = {
 218         "Driver Initialized",
 219         "Driver needs configuration load.",
 220         "Driver requested configuration from download daemon.",
 221         "Driver Ready."
 222 };
 223
 224
 225
 226 /************************************************************************
 227  *
 228  * Driver load/unload functions
 229  *
 230  ************************************************************************/
 231
 232 /*
 233  * init_module()
 234  *
 235  * Module load.  This is where it all starts.
 236  */
 237 int dgap_init_module(void)
 238 {
 239         int rc = 0;
 240
 241         APR(("%s, Digi International Part Number %s\n", DG_NAME, DG_PART));
 242
 243         /*
 244          * Initialize global stuff
 245          */
 246         rc = dgap_start();
 247
 248         if (rc < 0) {
 249                 return(rc);
 250         }
 251
 252         /*
 253          * Find and configure all the cards
 254          */
 255         rc = dgap_init_pci();
 256
 257         /*
 258          * If something went wrong in the scan, bail out of driver.
 259          */
 260         if (rc < 0) {
 261                 /* Only unregister the pci driver if it was actually registered. */
 262                 if (dgap_NumBoards)
 263                         pci_unregister_driver(&dgap_driver);
 264                 else
 265                         printk("WARNING: dgap driver load failed.  No DGAP boards found.\n");
 266
 267                 dgap_cleanup_module();
 268         }
 269         else {
 270                 dgap_create_driver_sysfiles(&dgap_driver);
 271         }
 272
 273         DPR_INIT(("Finished init_module. Returning %d\n", rc));
 274         return (rc);
 275 }
 276
 277
 278 /*
 279  * Start of driver.
 280  */
 281 static int dgap_start(void)
 282 {
 283         int rc = 0;
 284         unsigned long flags;
 285
 286         if (dgap_driver_start == FALSE) {
 287
 288                 dgap_driver_start = TRUE;
 289
 290                 /* make sure that the globals are init'd before we do anything else */
 291                 dgap_init_globals();
 292
 293                 dgap_NumBoards = 0;
 294
 295                 APR(("For the tools package or updated drivers please visit http://www.digi.com\n"));
 296
 297                 /*
 298                  * Register our base character device into the kernel.
 299                  * This allows the download daemon to connect to the downld device
 300                  * before any of the boards are init'ed.
 301                  */
 302                 if (!dgap_Major_Control_Registered) {
 303                         /*
 304                          * Register management/dpa devices
 305                          */
 306                         rc = register_chrdev(DIGI_DGAP_MAJOR, "dgap", &DgapBoardFops);
 307                         if (rc < 0) {
 308                                 APR(("Can't register dgap driver device (%d)\n", rc));
 309                                 return (rc);
 310                         }
 311
 312                         dgap_class = class_create(THIS_MODULE, "dgap_mgmt");
 313                         device_create(dgap_class, NULL,
 314                                 MKDEV(DIGI_DGAP_MAJOR, 0),
 315                                 NULL, "dgap_mgmt");
 316                         device_create(dgap_class, NULL,
 317                                 MKDEV(DIGI_DGAP_MAJOR, 1),
 318                                 NULL, "dgap_downld");
 319                         dgap_Major_Control_Registered = TRUE;
 320                 }
 321
 322                 /*
 323                  * Init any global tty stuff.
 324                  */
 325                 rc = dgap_tty_preinit();
 326
 327                 if (rc < 0) {
 328                         APR(("tty preinit - not enough memory (%d)\n", rc));
 329                         return(rc);
 330                 }
 331
 332                 /* Start the poller */
 333                 DGAP_LOCK(dgap_poll_lock, flags);
 334                 init_timer(&dgap_poll_timer);
 335                 dgap_poll_timer.function = dgap_poll_handler;
 336                 dgap_poll_timer.data = 0;
 337                 dgap_poll_time = jiffies + dgap_jiffies_from_ms(dgap_poll_tick);
 338                 dgap_poll_timer.expires = dgap_poll_time;
 339                 DGAP_UNLOCK(dgap_poll_lock, flags);
 340
 341                 add_timer(&dgap_poll_timer);
 342
 343                 dgap_driver_state = DRIVER_NEED_CONFIG_LOAD;
 344         }
 345
 346         return (rc);
 347 }
 348
 349
 350 /*
 351  * Register pci driver, and return how many boards we have.
 352  */
 353 static int dgap_init_pci(void)
 354 {
 355         return pci_register_driver(&dgap_driver);
 356 }
 357
 358
 359 /* returns count (>= 0), or negative on error */
 360 static int dgap_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 361 {
 362         int rc;
 363
 364         /* wake up and enable device */
 365         rc = pci_enable_device(pdev);
 366
 367         if (rc < 0) {
 368                 rc = -EIO;
 369         } else {
 370                 rc = dgap_probe1(pdev, ent->driver_data);
 371                 if (rc == 0) {
 372                         dgap_NumBoards++;
 373                         DPR_INIT(("Incrementing numboards to %d\n", dgap_NumBoards));
 374                 }
 375         }
 376         return rc;
 377 }
 378
 379
 380 static int dgap_probe1(struct pci_dev *pdev, int card_type)
 381 {
 382         return dgap_found_board(pdev, card_type);
 383 }
 384
 385
 386 static void dgap_remove_one(struct pci_dev *dev)
 387 {
 388         /* Do Nothing */
 389 }
 390
 391
 392 /*
 393  * dgap_cleanup_module()
 394  *
 395  * Module unload.  This is where it all ends.
 396  */
 397 void dgap_cleanup_module(void)
 398 {
 399         int i;
 400         ulong lock_flags;
 401
 402         DGAP_LOCK(dgap_poll_lock, lock_flags);
 403         dgap_poll_stop = 1;
 404         DGAP_UNLOCK(dgap_poll_lock, lock_flags);
 405
 406         /* Turn off poller right away. */
 407         del_timer_sync( &dgap_poll_timer);
 408
 409         dgap_remove_driver_sysfiles(&dgap_driver);
 410
 411
 412         if (dgap_Major_Control_Registered) {
 413                 device_destroy(dgap_class, MKDEV(DIGI_DGAP_MAJOR, 0));
 414                 device_destroy(dgap_class, MKDEV(DIGI_DGAP_MAJOR, 1));
 415                 class_destroy(dgap_class);
 416                 unregister_chrdev(DIGI_DGAP_MAJOR, "dgap");
 417         }
 418
 419         if (dgap_config_buf)
 420                 kfree(dgap_config_buf);
 421
 422         for (i = 0; i < dgap_NumBoards; ++i) {
 423                 dgap_remove_ports_sysfiles(dgap_Board[i]);
 424                 dgap_tty_uninit(dgap_Board[i]);
 425                 dgap_cleanup_board(dgap_Board[i]);
 426         }
 427
 428         dgap_tty_post_uninit();
 429
 430 #if defined(DGAP_TRACER)
 431         /* last thing, make sure we release the tracebuffer */
 432         dgap_tracer_free();
 433 #endif
 434         if (dgap_NumBoards)
 435                 pci_unregister_driver(&dgap_driver);
 436 }
 437
 438
 439 /*
 440  * dgap_cleanup_board()
 441  *
 442  * Free all the memory associated with a board
 443  */
 444 static void dgap_cleanup_board(struct board_t *brd)
 445 {
 446         int i = 0;
 447
 448         if(!brd || brd->magic != DGAP_BOARD_MAGIC)
 449                 return;
 450
 451         if (brd->intr_used && brd->irq)
 452                 free_irq(brd->irq, brd);
 453
 454         tasklet_kill(&brd->helper_tasklet);
 455
 456         if (brd->re_map_port) {
 457                 release_mem_region(brd->membase + 0x200000, 0x200000);
 458                 iounmap(brd->re_map_port);
 459                 brd->re_map_port = NULL;
 460         }
 461
 462         if (brd->re_map_membase) {
 463                 release_mem_region(brd->membase, 0x200000);
 464                 iounmap(brd->re_map_membase);
 465                 brd->re_map_membase = NULL;
 466         }
 467
 468         if (brd->msgbuf_head) {
 469                 unsigned long flags;
 470
 471                 DGAP_LOCK(dgap_global_lock, flags);
 472                 brd->msgbuf = NULL;
 473                 printk("%s", brd->msgbuf_head);
 474                 kfree(brd->msgbuf_head);
 475                 brd->msgbuf_head = NULL;
 476                 DGAP_UNLOCK(dgap_global_lock, flags);
 477         }
 478
 479         /* Free all allocated channels structs */
 480         for (i = 0; i < MAXPORTS ; i++) {
 481                 if (brd->channels[i]) {
 482                         kfree(brd->channels[i]);
 483                         brd->channels[i] = NULL;
 484                 }
 485         }
 486
 487         if (brd->flipbuf)
 488                 kfree(brd->flipbuf);
 489         if (brd->flipflagbuf)
 490                 kfree(brd->flipflagbuf);
 491
 492         dgap_Board[brd->boardnum] = NULL;
 493
 494         kfree(brd);
 495 }
 496
 497
 498 /*
 499  * dgap_found_board()
 500  *
 501  * A board has been found, init it.
 502  */
 503 static int dgap_found_board(struct pci_dev *pdev, int id)
 504 {
 505         struct board_t *brd;
 506         unsigned int pci_irq;
 507         int i = 0;
 508         unsigned long flags;
 509
 510         /* get the board structure and prep it */
 511         brd = dgap_Board[dgap_NumBoards] =
 512         (struct board_t *) dgap_driver_kzmalloc(sizeof(struct board_t), GFP_KERNEL);
 513         if (!brd) {
 514                 APR(("memory allocation for board structure failed\n"));
 515                 return(-ENOMEM);
 516         }
 517
 518         /* make a temporary message buffer for the boot messages */
 519         brd->msgbuf = brd->msgbuf_head =
 520                 (char *) dgap_driver_kzmalloc(sizeof(char) * 8192, GFP_KERNEL);
 521         if(!brd->msgbuf) {
 522                 kfree(brd);
 523                 APR(("memory allocation for board msgbuf failed\n"));
 524                 return(-ENOMEM);
 525         }
 526
 527         /* store the info for the board we've found */
 528         brd->magic = DGAP_BOARD_MAGIC;
 529         brd->boardnum = dgap_NumBoards;
 530         brd->firstminor = 0;
 531         brd->vendor = dgap_pci_tbl[id].vendor;
 532         brd->device = dgap_pci_tbl[id].device;
 533         brd->pdev = pdev;
 534         brd->pci_bus = pdev->bus->number;
 535         brd->pci_slot = PCI_SLOT(pdev->devfn);
 536         brd->name = dgap_Ids[id].name;
 537         brd->maxports = dgap_Ids[id].maxports;
 538         brd->type = dgap_Ids[id].config_type;
 539         brd->dpatype = dgap_Ids[id].dpatype;
 540         brd->dpastatus = BD_NOFEP;
 541         init_waitqueue_head(&brd->state_wait);
 542
 543         DGAP_SPINLOCK_INIT(brd->bd_lock);
 544
 545         brd->state              = BOARD_FOUND;
 546         brd->runwait            = 0;
 547         brd->inhibit_poller     = FALSE;
 548         brd->wait_for_bios      = 0;
 549         brd->wait_for_fep       = 0;
 550
 551         for (i = 0; i < MAXPORTS; i++) {
 552                 brd->channels[i] = NULL;
 553         }
 554
 555         /* store which card & revision we have */
 556         pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &brd->subvendor);
 557         pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &brd->subdevice);
 558         pci_read_config_byte(pdev, PCI_REVISION_ID, &brd->rev);
 559
 560         pci_irq = pdev->irq;
 561         brd->irq = pci_irq;
 562
 563         /* get the PCI Base Address Registers */
 564
 565         /* Xr Jupiter and EPC use BAR 2 */
 566         if (brd->device == PCI_DEVICE_XRJ_DID || brd->device == PCI_DEVICE_EPCJ_DID) {
 567                 brd->membase     = pci_resource_start(pdev, 2);
 568                 brd->membase_end = pci_resource_end(pdev, 2);
 569         }
 570         /* Everyone else uses BAR 0 */
 571         else {
 572                 brd->membase     = pci_resource_start(pdev, 0);
 573                 brd->membase_end = pci_resource_end(pdev, 0);
 574         }
 575
 576         if (!brd->membase) {
 577                 APR(("card has no PCI IO resources, failing board.\n"));
 578                 return -ENODEV;
 579         }
 580
 581         if (brd->membase & 1)
 582                 brd->membase &= ~3;
 583         else
 584                 brd->membase &= ~15;
 585
 586         /*
 587          * On the PCI boards, there is no IO space allocated
 588          * The I/O registers will be in the first 3 bytes of the
 589          * upper 2MB of the 4MB memory space.  The board memory
 590          * will be mapped into the low 2MB of the 4MB memory space
 591          */
 592         brd->port = brd->membase + PCI_IO_OFFSET;
 593         brd->port_end = brd->port + PCI_IO_SIZE;
 594
 595
 596         /*
 597          * Special initialization for non-PLX boards
 598          */
 599         if (brd->device != PCI_DEVICE_XRJ_DID && brd->device != PCI_DEVICE_EPCJ_DID) {
 600                 unsigned short cmd;
 601
 602                 pci_write_config_byte(pdev, 0x40, 0);
 603                 pci_write_config_byte(pdev, 0x46, 0);
 604
 605                 /* Limit burst length to 2 doubleword transactions */
 606                 pci_write_config_byte(pdev, 0x42, 1);
 607
 608                 /*
 609                  * Enable IO and mem if not already done.
 610                  * This was needed for support on Itanium.
 611                  */
 612                 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 613                 cmd |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
 614                 pci_write_config_word(pdev, PCI_COMMAND, cmd);
 615         }
 616
 617         /* init our poll helper tasklet */
 618         tasklet_init(&brd->helper_tasklet, dgap_poll_tasklet, (unsigned long) brd);
 619
 620          /* Log the information about the board */
 621         dgap_mbuf(brd, DRVSTR": board %d: %s (rev %d), irq %d\n",
 622                 dgap_NumBoards, brd->name, brd->rev, brd->irq);
 623
 624         DPR_INIT(("dgap_scan(%d) - printing out the msgbuf\n", i));
 625         DGAP_LOCK(dgap_global_lock, flags);
 626         brd->msgbuf = NULL;
 627         printk("%s", brd->msgbuf_head);
 628         kfree(brd->msgbuf_head);
 629         brd->msgbuf_head = NULL;
 630         DGAP_UNLOCK(dgap_global_lock, flags);
 631
 632         i = dgap_do_remap(brd);
 633         if (i)
 634                 brd->state = BOARD_FAILED;
 635         else
 636                 brd->state = NEED_RESET;
 637
 638         return(0);
 639 }
 640
 641
 642 int dgap_finalize_board_init(struct board_t *brd) {
 643
 644         int rc;
 645
 646         DPR_INIT(("dgap_finalize_board_init() - start\n"));
 647
 648         if (!brd || brd->magic != DGAP_BOARD_MAGIC)
 649                 return(-ENODEV);
 650
 651         DPR_INIT(("dgap_finalize_board_init() - start #2\n"));
 652
 653         brd->use_interrupts = dgap_config_get_useintr(brd);
 654
 655         /*
 656          * Set up our interrupt handler if we are set to do interrupts.
 657          */
 658         if (brd->use_interrupts && brd->irq) {
 659
 660                 rc = request_irq(brd->irq, dgap_intr, IRQF_SHARED, "DGAP", brd);
 661
 662                 if (rc) {
 663                         dgap_mbuf(brd, DRVSTR": Failed to hook IRQ %d. Board will work in poll mode.\n",
 664                                   brd->irq);
 665                         brd->intr_used = 0;
 666                 }
 667                 else
 668                         brd->intr_used = 1;
 669         } else {
 670                 brd->intr_used = 0;
 671         }
 672
 673         return(0);
 674 }
 675
 676
 677 /*
 678  * Remap PCI memory.
 679  */
 680 static int dgap_do_remap(struct board_t *brd)
 681 {
 682         if (!brd || brd->magic != DGAP_BOARD_MAGIC)
 683                 return -ENXIO;
 684
 685         if (!request_mem_region(brd->membase, 0x200000, "dgap")) {
 686                 APR(("dgap: mem_region %lx already in use.\n", brd->membase));
 687                 return -ENOMEM;
 688         }
 689
 690         if (!request_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000, "dgap")) {
 691                 APR(("dgap: mem_region IO %lx already in use.\n",
 692                         brd->membase + PCI_IO_OFFSET));
 693                 release_mem_region(brd->membase, 0x200000);
 694                 return -ENOMEM;
 695         }
 696
 697         brd->re_map_membase = ioremap(brd->membase, 0x200000);
 698         if (!brd->re_map_membase) {
 699                 APR(("dgap: ioremap mem %lx cannot be mapped.\n", brd->membase));
 700                 release_mem_region(brd->membase, 0x200000);
 701                 release_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000);
 702                 return -ENOMEM;
 703         }
 704
 705         brd->re_map_port = ioremap((brd->membase + PCI_IO_OFFSET), 0x200000);
 706         if (!brd->re_map_port) {
 707                 release_mem_region(brd->membase, 0x200000);
 708                 release_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000);
 709                 iounmap(brd->re_map_membase);
 710                 APR(("dgap: ioremap IO mem %lx cannot be mapped.\n",
 711                         brd->membase + PCI_IO_OFFSET));
 712                 return -ENOMEM;
 713         }
 714
 715         DPR_INIT(("remapped io: 0x%p  remapped mem: 0x%p\n",
 716                 brd->re_map_port, brd->re_map_membase));
 717         return 0;
 718 }
 719
 720
 721 /*****************************************************************************
 722 *
 723 * Function:
 724 *
 725 *    dgap_poll_handler
 726 *
 727 * Author:
 728 *
 729 *    Scott H Kilau
 730 *
 731 * Parameters:
 732 *
 733 *    dummy -- ignored
 734 *
 735 * Return Values:
 736 *
 737 *    none
 738 *
 739 * Description:
 740 *
 741 *    As each timer expires, it determines (a) whether the "transmit"
 742 *    waiter needs to be woken up, and (b) whether the poller needs to
 743 *    be rescheduled.
 744 *
 745 ******************************************************************************/
 746
 747 static void dgap_poll_handler(ulong dummy)
 748 {
 749         int i;
 750         struct board_t *brd;
 751         unsigned long lock_flags;
 752         unsigned long lock_flags2;
 753         ulong new_time;
 754
 755         dgap_poll_counter++;
 756
 757
 758         /*
 759          * If driver needs the config file still,
 760          * keep trying to wake up the downloader to
 761          * send us the file.
 762          */
 763         if (dgap_driver_state == DRIVER_NEED_CONFIG_LOAD) {
 764                 /*
 765                  * Signal downloader, its got some work to do.
 766                  */
 767                 DGAP_LOCK(dgap_dl_lock, lock_flags2);
 768                 if (dgap_dl_action != 1) {
 769                         dgap_dl_action = 1;
 770                         wake_up_interruptible(&dgap_dl_wait);
 771                 }
 772                 DGAP_UNLOCK(dgap_dl_lock, lock_flags2);
 773                 goto schedule_poller;
 774         }
 775         /*
 776          * Do not start the board state machine until
 777          * driver tells us its up and running, and has
 778          * everything it needs.
 779          */
 780         else if (dgap_driver_state != DRIVER_READY) {
 781                 goto schedule_poller;
 782         }
 783
 784         /*
 785          * If we have just 1 board, or the system is not SMP,
 786          * then use the typical old style poller.
 787          * Otherwise, use our new tasklet based poller, which should
 788          * speed things up for multiple boards.
 789          */
 790         if ( (dgap_NumBoards == 1) || (num_online_cpus() <= 1) ) {
 791                 for (i = 0; i < dgap_NumBoards; i++) {
 792
 793                         brd = dgap_Board[i];
 794
 795                         if (brd->state == BOARD_FAILED) {
 796                                 continue;
 797                         }
 798                         if (!brd->intr_running) {
 799                                 /* Call the real board poller directly */
 800                                 dgap_poll_tasklet((unsigned long) brd);
 801                         }
 802                 }
 803         }
 804         else {
 805                 /* Go thru each board, kicking off a tasklet for each if needed */
 806                 for (i = 0; i < dgap_NumBoards; i++) {
 807                         brd = dgap_Board[i];
 808
 809                         /*
 810                          * Attempt to grab the board lock.
 811                          *
 812                          * If we can't get it, no big deal, the next poll will get it.
 813                          * Basically, I just really don't want to spin in here, because I want
 814                          * to kick off my tasklets as fast as I can, and then get out the poller.
 815                          */
 816                         if (!spin_trylock(&brd->bd_lock)) {
 817                                 continue;
 818                         }
 819
 820                         /* If board is in a failed state, don't bother scheduling a tasklet */
 821                         if (brd->state == BOARD_FAILED) {
 822                                 spin_unlock(&brd->bd_lock);
 823                                 continue;
 824                         }
 825
 826                         /* Schedule a poll helper task */
 827                         if (!brd->intr_running) {
 828                                 tasklet_schedule(&brd->helper_tasklet);
 829                         }
 830
 831                         /*
 832                          * Can't do DGAP_UNLOCK here, as we don't have
 833                          * lock_flags because we did a trylock above.
 834                          */
 835                         spin_unlock(&brd->bd_lock);
 836                 }
 837         }
 838
 839 schedule_poller:
 840
 841         /*
 842          * Schedule ourself back at the nominal wakeup interval.
 843          */
 844         DGAP_LOCK(dgap_poll_lock, lock_flags );
 845         dgap_poll_time +=  dgap_jiffies_from_ms(dgap_poll_tick);
 846
 847         new_time = dgap_poll_time - jiffies;
 848
 849         if ((ulong) new_time >= 2 * dgap_poll_tick) {
 850                 dgap_poll_time = jiffies +  dgap_jiffies_from_ms(dgap_poll_tick);
 851         }
 852
 853         dgap_poll_timer.function = dgap_poll_handler;
 854         dgap_poll_timer.data = 0;
 855         dgap_poll_timer.expires = dgap_poll_time;
 856         DGAP_UNLOCK(dgap_poll_lock, lock_flags );
 857
 858         if (!dgap_poll_stop)
 859                 add_timer(&dgap_poll_timer);
 860 }
 861
 862
 863
 864
 865 /*
 866  * dgap_intr()
 867  *
 868  * Driver interrupt handler.
 869  */
 870 static irqreturn_t dgap_intr(int irq, void *voidbrd)
 871 {
 872         struct board_t *brd = (struct board_t *) voidbrd;
 873
 874         if (!brd) {
 875                 APR(("Received interrupt (%d) with null board associated\n", irq));
 876                 return IRQ_NONE;
 877         }
 878
 879         /*
 880          * Check to make sure its for us.
 881          */
 882         if (brd->magic != DGAP_BOARD_MAGIC) {
 883                 APR(("Received interrupt (%d) with a board pointer that wasn't ours!\n", irq));
 884                 return IRQ_NONE;
 885         }
 886
 887         brd->intr_count++;
 888
 889         /*
 890          * Schedule tasklet to run at a better time.
 891          */
 892         tasklet_schedule(&brd->helper_tasklet);
 893         return IRQ_HANDLED;
 894 }
 895
 896
 897 /*
 898  * dgap_init_globals()
 899  *
 900  * This is where we initialize the globals from the static insmod
 901  * configuration variables.  These are declared near the head of
 902  * this file.
 903  */
 904 static void dgap_init_globals(void)
 905 {
 906         int i = 0;
 907
 908         dgap_rawreadok          = rawreadok;
 909         dgap_trcbuf_size        = trcbuf_size;
 910         dgap_debug              = debug;
 911
 912         for (i = 0; i < MAXBOARDS; i++) {
 913                 dgap_Board[i] = NULL;
 914         }
 915
 916         init_timer( &dgap_poll_timer );
 917
 918         init_waitqueue_head(&dgap_dl_wait);
 919         dgap_dl_action = 0;
 920 }
 921
 922
 923 /************************************************************************
 924  *
 925  * Utility functions
 926  *
 927  ************************************************************************/
 928
 929
 930 /*
 931  * dgap_driver_kzmalloc()
 932  *
 933  * Malloc and clear memory,
 934  */
 935 void *dgap_driver_kzmalloc(size_t size, int priority)
 936 {
 937         void *p = kmalloc(size, priority);
 938         if(p)
 939                 memset(p, 0, size);
 940         return(p);
 941 }
 942
 943
 944 /*
 945  * dgap_mbuf()
 946  *
 947  * Used to print to the message buffer during board init.
 948  */
 949 static void dgap_mbuf(struct board_t *brd, const char *fmt, ...) {
 950         va_list         ap;
 951         char            buf[1024];
 952         int             i;
 953         unsigned long   flags;
 954         size_t          length;
 955
 956         DGAP_LOCK(dgap_global_lock, flags);
 957
 958         /* Format buf using fmt and arguments contained in ap. */
 959         va_start(ap, fmt);
 960         i = vsnprintf(buf, sizeof(buf), fmt,  ap);
 961         va_end(ap);
 962
 963         DPR((buf));
 964
 965         if (!brd || !brd->msgbuf) {
 966                 printk("%s", buf);
 967                 DGAP_UNLOCK(dgap_global_lock, flags);
 968                 return;
 969         }
 970
 971         length = strlen(buf) + 1;
 972         if (brd->msgbuf - brd->msgbuf_head < length)
 973                 length = brd->msgbuf - brd->msgbuf_head;
 974         memcpy(brd->msgbuf, buf, length);
 975         brd->msgbuf += length;
 976
 977         DGAP_UNLOCK(dgap_global_lock, flags);
 978 }
 979
 980
 981 /*
 982  * dgap_ms_sleep()
 983  *
 984  * Put the driver to sleep for x ms's
 985  *
 986  * Returns 0 if timed out, !0 (showing signal) if interrupted by a signal.
 987  */
 988 int dgap_ms_sleep(ulong ms)
 989 {
 990         current->state = TASK_INTERRUPTIBLE;
 991         schedule_timeout((ms * HZ) / 1000);
 992         return (signal_pending(current));
 993 }
 994
 995
 996
 997 /*
 998  *      dgap_ioctl_name() : Returns a text version of each ioctl value.
 999  */
1000 char *dgap_ioctl_name(int cmd)
1001 {
1002         switch(cmd) {
1003
1004         case TCGETA:            return("TCGETA");
1005         case TCGETS:            return("TCGETS");
1006         case TCSETA:            return("TCSETA");
1007         case TCSETS:            return("TCSETS");
1008         case TCSETAW:           return("TCSETAW");
1009         case TCSETSW:           return("TCSETSW");
1010         case TCSETAF:           return("TCSETAF");
1011         case TCSETSF:           return("TCSETSF");
1012         case TCSBRK:            return("TCSBRK");
1013         case TCXONC:            return("TCXONC");
1014         case TCFLSH:            return("TCFLSH");
1015         case TIOCGSID:          return("TIOCGSID");
1016
1017         case TIOCGETD:          return("TIOCGETD");
1018         case TIOCSETD:          return("TIOCSETD");
1019         case TIOCGWINSZ:        return("TIOCGWINSZ");
1020         case TIOCSWINSZ:        return("TIOCSWINSZ");
1021
1022         case TIOCMGET:          return("TIOCMGET");
1023         case TIOCMSET:          return("TIOCMSET");
1024         case TIOCMBIS:          return("TIOCMBIS");
1025         case TIOCMBIC:          return("TIOCMBIC");
1026
1027         /* from digi.h */
1028         case DIGI_SETA:         return("DIGI_SETA");
1029         case DIGI_SETAW:        return("DIGI_SETAW");
1030         case DIGI_SETAF:        return("DIGI_SETAF");
1031         case DIGI_SETFLOW:      return("DIGI_SETFLOW");
1032         case DIGI_SETAFLOW:     return("DIGI_SETAFLOW");
1033         case DIGI_GETFLOW:      return("DIGI_GETFLOW");
1034         case DIGI_GETAFLOW:     return("DIGI_GETAFLOW");
1035         case DIGI_GETA:         return("DIGI_GETA");
1036         case DIGI_GEDELAY:      return("DIGI_GEDELAY");
1037         case DIGI_SEDELAY:      return("DIGI_SEDELAY");
1038         case DIGI_GETCUSTOMBAUD: return("DIGI_GETCUSTOMBAUD");
1039         case DIGI_SETCUSTOMBAUD: return("DIGI_SETCUSTOMBAUD");
1040         case TIOCMODG:          return("TIOCMODG");
1041         case TIOCMODS:          return("TIOCMODS");
1042         case TIOCSDTR:          return("TIOCSDTR");
1043         case TIOCCDTR:          return("TIOCCDTR");
1044
1045         default:                return("unknown");
1046         }
1047 }