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         kfree(dgap_config_buf);
 420
 421         for (i = 0; i < dgap_NumBoards; ++i) {
 422                 dgap_remove_ports_sysfiles(dgap_Board[i]);
 423                 dgap_tty_uninit(dgap_Board[i]);
 424                 dgap_cleanup_board(dgap_Board[i]);
 425         }
 426
 427         dgap_tty_post_uninit();
 428
 429 #if defined(DGAP_TRACER)
 430         /* last thing, make sure we release the tracebuffer */
 431         dgap_tracer_free();
 432 #endif
 433         if (dgap_NumBoards)
 434                 pci_unregister_driver(&dgap_driver);
 435 }
 436
 437
 438 /*
 439  * dgap_cleanup_board()
 440  *
 441  * Free all the memory associated with a board
 442  */
 443 static void dgap_cleanup_board(struct board_t *brd)
 444 {
 445         int i = 0;
 446
 447         if(!brd || brd->magic != DGAP_BOARD_MAGIC)
 448                 return;
 449
 450         if (brd->intr_used && brd->irq)
 451                 free_irq(brd->irq, brd);
 452
 453         tasklet_kill(&brd->helper_tasklet);
 454
 455         if (brd->re_map_port) {
 456                 release_mem_region(brd->membase + 0x200000, 0x200000);
 457                 iounmap(brd->re_map_port);
 458                 brd->re_map_port = NULL;
 459         }
 460
 461         if (brd->re_map_membase) {
 462                 release_mem_region(brd->membase, 0x200000);
 463                 iounmap(brd->re_map_membase);
 464                 brd->re_map_membase = NULL;
 465         }
 466
 467         if (brd->msgbuf_head) {
 468                 unsigned long flags;
 469
 470                 DGAP_LOCK(dgap_global_lock, flags);
 471                 brd->msgbuf = NULL;
 472                 printk("%s", brd->msgbuf_head);
 473                 kfree(brd->msgbuf_head);
 474                 brd->msgbuf_head = NULL;
 475                 DGAP_UNLOCK(dgap_global_lock, flags);
 476         }
 477
 478         /* Free all allocated channels structs */
 479         for (i = 0; i < MAXPORTS ; i++) {
 480                 if (brd->channels[i]) {
 481                         kfree(brd->channels[i]);
 482                         brd->channels[i] = NULL;
 483                 }
 484         }
 485
 486         kfree(brd->flipbuf);
 487         kfree(brd->flipflagbuf);
 488
 489         dgap_Board[brd->boardnum] = NULL;
 490
 491         kfree(brd);
 492 }
 493
 494
 495 /*
 496  * dgap_found_board()
 497  *
 498  * A board has been found, init it.
 499  */
 500 static int dgap_found_board(struct pci_dev *pdev, int id)
 501 {
 502         struct board_t *brd;
 503         unsigned int pci_irq;
 504         int i = 0;
 505         unsigned long flags;
 506
 507         /* get the board structure and prep it */
 508         brd = dgap_Board[dgap_NumBoards] =
 509         (struct board_t *) dgap_driver_kzmalloc(sizeof(struct board_t), GFP_KERNEL);
 510         if (!brd) {
 511                 APR(("memory allocation for board structure failed\n"));
 512                 return(-ENOMEM);
 513         }
 514
 515         /* make a temporary message buffer for the boot messages */
 516         brd->msgbuf = brd->msgbuf_head =
 517                 (char *) dgap_driver_kzmalloc(sizeof(char) * 8192, GFP_KERNEL);
 518         if(!brd->msgbuf) {
 519                 kfree(brd);
 520                 APR(("memory allocation for board msgbuf failed\n"));
 521                 return(-ENOMEM);
 522         }
 523
 524         /* store the info for the board we've found */
 525         brd->magic = DGAP_BOARD_MAGIC;
 526         brd->boardnum = dgap_NumBoards;
 527         brd->firstminor = 0;
 528         brd->vendor = dgap_pci_tbl[id].vendor;
 529         brd->device = dgap_pci_tbl[id].device;
 530         brd->pdev = pdev;
 531         brd->pci_bus = pdev->bus->number;
 532         brd->pci_slot = PCI_SLOT(pdev->devfn);
 533         brd->name = dgap_Ids[id].name;
 534         brd->maxports = dgap_Ids[id].maxports;
 535         brd->type = dgap_Ids[id].config_type;
 536         brd->dpatype = dgap_Ids[id].dpatype;
 537         brd->dpastatus = BD_NOFEP;
 538         init_waitqueue_head(&brd->state_wait);
 539
 540         DGAP_SPINLOCK_INIT(brd->bd_lock);
 541
 542         brd->state              = BOARD_FOUND;
 543         brd->runwait            = 0;
 544         brd->inhibit_poller     = FALSE;
 545         brd->wait_for_bios      = 0;
 546         brd->wait_for_fep       = 0;
 547
 548         for (i = 0; i < MAXPORTS; i++) {
 549                 brd->channels[i] = NULL;
 550         }
 551
 552         /* store which card & revision we have */
 553         pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &brd->subvendor);
 554         pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &brd->subdevice);
 555         pci_read_config_byte(pdev, PCI_REVISION_ID, &brd->rev);
 556
 557         pci_irq = pdev->irq;
 558         brd->irq = pci_irq;
 559
 560         /* get the PCI Base Address Registers */
 561
 562         /* Xr Jupiter and EPC use BAR 2 */
 563         if (brd->device == PCI_DEVICE_XRJ_DID || brd->device == PCI_DEVICE_EPCJ_DID) {
 564                 brd->membase     = pci_resource_start(pdev, 2);
 565                 brd->membase_end = pci_resource_end(pdev, 2);
 566         }
 567         /* Everyone else uses BAR 0 */
 568         else {
 569                 brd->membase     = pci_resource_start(pdev, 0);
 570                 brd->membase_end = pci_resource_end(pdev, 0);
 571         }
 572
 573         if (!brd->membase) {
 574                 APR(("card has no PCI IO resources, failing board.\n"));
 575                 return -ENODEV;
 576         }
 577
 578         if (brd->membase & 1)
 579                 brd->membase &= ~3;
 580         else
 581                 brd->membase &= ~15;
 582
 583         /*
 584          * On the PCI boards, there is no IO space allocated
 585          * The I/O registers will be in the first 3 bytes of the
 586          * upper 2MB of the 4MB memory space.  The board memory
 587          * will be mapped into the low 2MB of the 4MB memory space
 588          */
 589         brd->port = brd->membase + PCI_IO_OFFSET;
 590         brd->port_end = brd->port + PCI_IO_SIZE;
 591
 592
 593         /*
 594          * Special initialization for non-PLX boards
 595          */
 596         if (brd->device != PCI_DEVICE_XRJ_DID && brd->device != PCI_DEVICE_EPCJ_DID) {
 597                 unsigned short cmd;
 598
 599                 pci_write_config_byte(pdev, 0x40, 0);
 600                 pci_write_config_byte(pdev, 0x46, 0);
 601
 602                 /* Limit burst length to 2 doubleword transactions */
 603                 pci_write_config_byte(pdev, 0x42, 1);
 604
 605                 /*
 606                  * Enable IO and mem if not already done.
 607                  * This was needed for support on Itanium.
 608                  */
 609                 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 610                 cmd |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
 611                 pci_write_config_word(pdev, PCI_COMMAND, cmd);
 612         }
 613
 614         /* init our poll helper tasklet */
 615         tasklet_init(&brd->helper_tasklet, dgap_poll_tasklet, (unsigned long) brd);
 616
 617          /* Log the information about the board */
 618         dgap_mbuf(brd, DRVSTR": board %d: %s (rev %d), irq %d\n",
 619                 dgap_NumBoards, brd->name, brd->rev, brd->irq);
 620
 621         DPR_INIT(("dgap_scan(%d) - printing out the msgbuf\n", i));
 622         DGAP_LOCK(dgap_global_lock, flags);
 623         brd->msgbuf = NULL;
 624         printk("%s", brd->msgbuf_head);
 625         kfree(brd->msgbuf_head);
 626         brd->msgbuf_head = NULL;
 627         DGAP_UNLOCK(dgap_global_lock, flags);
 628
 629         i = dgap_do_remap(brd);
 630         if (i)
 631                 brd->state = BOARD_FAILED;
 632         else
 633                 brd->state = NEED_RESET;
 634
 635         return(0);
 636 }
 637
 638
 639 int dgap_finalize_board_init(struct board_t *brd) {
 640
 641         int rc;
 642
 643         DPR_INIT(("dgap_finalize_board_init() - start\n"));
 644
 645         if (!brd || brd->magic != DGAP_BOARD_MAGIC)
 646                 return(-ENODEV);
 647
 648         DPR_INIT(("dgap_finalize_board_init() - start #2\n"));
 649
 650         brd->use_interrupts = dgap_config_get_useintr(brd);
 651
 652         /*
 653          * Set up our interrupt handler if we are set to do interrupts.
 654          */
 655         if (brd->use_interrupts && brd->irq) {
 656
 657                 rc = request_irq(brd->irq, dgap_intr, IRQF_SHARED, "DGAP", brd);
 658
 659                 if (rc) {
 660                         dgap_mbuf(brd, DRVSTR": Failed to hook IRQ %d. Board will work in poll mode.\n",
 661                                   brd->irq);
 662                         brd->intr_used = 0;
 663                 }
 664                 else
 665                         brd->intr_used = 1;
 666         } else {
 667                 brd->intr_used = 0;
 668         }
 669
 670         return(0);
 671 }
 672
 673
 674 /*
 675  * Remap PCI memory.
 676  */
 677 static int dgap_do_remap(struct board_t *brd)
 678 {
 679         if (!brd || brd->magic != DGAP_BOARD_MAGIC)
 680                 return -ENXIO;
 681
 682         if (!request_mem_region(brd->membase, 0x200000, "dgap")) {
 683                 APR(("dgap: mem_region %lx already in use.\n", brd->membase));
 684                 return -ENOMEM;
 685         }
 686
 687         if (!request_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000, "dgap")) {
 688                 APR(("dgap: mem_region IO %lx already in use.\n",
 689                         brd->membase + PCI_IO_OFFSET));
 690                 release_mem_region(brd->membase, 0x200000);
 691                 return -ENOMEM;
 692         }
 693
 694         brd->re_map_membase = ioremap(brd->membase, 0x200000);
 695         if (!brd->re_map_membase) {
 696                 APR(("dgap: ioremap mem %lx cannot be mapped.\n", brd->membase));
 697                 release_mem_region(brd->membase, 0x200000);
 698                 release_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000);
 699                 return -ENOMEM;
 700         }
 701
 702         brd->re_map_port = ioremap((brd->membase + PCI_IO_OFFSET), 0x200000);
 703         if (!brd->re_map_port) {
 704                 release_mem_region(brd->membase, 0x200000);
 705                 release_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000);
 706                 iounmap(brd->re_map_membase);
 707                 APR(("dgap: ioremap IO mem %lx cannot be mapped.\n",
 708                         brd->membase + PCI_IO_OFFSET));
 709                 return -ENOMEM;
 710         }
 711
 712         DPR_INIT(("remapped io: 0x%p  remapped mem: 0x%p\n",
 713                 brd->re_map_port, brd->re_map_membase));
 714         return 0;
 715 }
 716
 717
 718 /*****************************************************************************
 719 *
 720 * Function:
 721 *
 722 *    dgap_poll_handler
 723 *
 724 * Author:
 725 *
 726 *    Scott H Kilau
 727 *
 728 * Parameters:
 729 *
 730 *    dummy -- ignored
 731 *
 732 * Return Values:
 733 *
 734 *    none
 735 *
 736 * Description:
 737 *
 738 *    As each timer expires, it determines (a) whether the "transmit"
 739 *    waiter needs to be woken up, and (b) whether the poller needs to
 740 *    be rescheduled.
 741 *
 742 ******************************************************************************/
 743
 744 static void dgap_poll_handler(ulong dummy)
 745 {
 746         int i;
 747         struct board_t *brd;
 748         unsigned long lock_flags;
 749         unsigned long lock_flags2;
 750         ulong new_time;
 751
 752         dgap_poll_counter++;
 753
 754
 755         /*
 756          * If driver needs the config file still,
 757          * keep trying to wake up the downloader to
 758          * send us the file.
 759          */
 760         if (dgap_driver_state == DRIVER_NEED_CONFIG_LOAD) {
 761                 /*
 762                  * Signal downloader, its got some work to do.
 763                  */
 764                 DGAP_LOCK(dgap_dl_lock, lock_flags2);
 765                 if (dgap_dl_action != 1) {
 766                         dgap_dl_action = 1;
 767                         wake_up_interruptible(&dgap_dl_wait);
 768                 }
 769                 DGAP_UNLOCK(dgap_dl_lock, lock_flags2);
 770                 goto schedule_poller;
 771         }
 772         /*
 773          * Do not start the board state machine until
 774          * driver tells us its up and running, and has
 775          * everything it needs.
 776          */
 777         else if (dgap_driver_state != DRIVER_READY) {
 778                 goto schedule_poller;
 779         }
 780
 781         /*
 782          * If we have just 1 board, or the system is not SMP,
 783          * then use the typical old style poller.
 784          * Otherwise, use our new tasklet based poller, which should
 785          * speed things up for multiple boards.
 786          */
 787         if ( (dgap_NumBoards == 1) || (num_online_cpus() <= 1) ) {
 788                 for (i = 0; i < dgap_NumBoards; i++) {
 789
 790                         brd = dgap_Board[i];
 791
 792                         if (brd->state == BOARD_FAILED) {
 793                                 continue;
 794                         }
 795                         if (!brd->intr_running) {
 796                                 /* Call the real board poller directly */
 797                                 dgap_poll_tasklet((unsigned long) brd);
 798                         }
 799                 }
 800         }
 801         else {
 802                 /* Go thru each board, kicking off a tasklet for each if needed */
 803                 for (i = 0; i < dgap_NumBoards; i++) {
 804                         brd = dgap_Board[i];
 805
 806                         /*
 807                          * Attempt to grab the board lock.
 808                          *
 809                          * If we can't get it, no big deal, the next poll will get it.
 810                          * Basically, I just really don't want to spin in here, because I want
 811                          * to kick off my tasklets as fast as I can, and then get out the poller.
 812                          */
 813                         if (!spin_trylock(&brd->bd_lock)) {
 814                                 continue;
 815                         }
 816
 817                         /* If board is in a failed state, don't bother scheduling a tasklet */
 818                         if (brd->state == BOARD_FAILED) {
 819                                 spin_unlock(&brd->bd_lock);
 820                                 continue;
 821                         }
 822
 823                         /* Schedule a poll helper task */
 824                         if (!brd->intr_running) {
 825                                 tasklet_schedule(&brd->helper_tasklet);
 826                         }
 827
 828                         /*
 829                          * Can't do DGAP_UNLOCK here, as we don't have
 830                          * lock_flags because we did a trylock above.
 831                          */
 832                         spin_unlock(&brd->bd_lock);
 833                 }
 834         }
 835
 836 schedule_poller:
 837
 838         /*
 839          * Schedule ourself back at the nominal wakeup interval.
 840          */
 841         DGAP_LOCK(dgap_poll_lock, lock_flags );
 842         dgap_poll_time +=  dgap_jiffies_from_ms(dgap_poll_tick);
 843
 844         new_time = dgap_poll_time - jiffies;
 845
 846         if ((ulong) new_time >= 2 * dgap_poll_tick) {
 847                 dgap_poll_time = jiffies +  dgap_jiffies_from_ms(dgap_poll_tick);
 848         }
 849
 850         dgap_poll_timer.function = dgap_poll_handler;
 851         dgap_poll_timer.data = 0;
 852         dgap_poll_timer.expires = dgap_poll_time;
 853         DGAP_UNLOCK(dgap_poll_lock, lock_flags );
 854
 855         if (!dgap_poll_stop)
 856                 add_timer(&dgap_poll_timer);
 857 }
 858
 859
 860
 861
 862 /*
 863  * dgap_intr()
 864  *
 865  * Driver interrupt handler.
 866  */
 867 static irqreturn_t dgap_intr(int irq, void *voidbrd)
 868 {
 869         struct board_t *brd = (struct board_t *) voidbrd;
 870
 871         if (!brd) {
 872                 APR(("Received interrupt (%d) with null board associated\n", irq));
 873                 return IRQ_NONE;
 874         }
 875
 876         /*
 877          * Check to make sure its for us.
 878          */
 879         if (brd->magic != DGAP_BOARD_MAGIC) {
 880                 APR(("Received interrupt (%d) with a board pointer that wasn't ours!\n", irq));
 881                 return IRQ_NONE;
 882         }
 883
 884         brd->intr_count++;
 885
 886         /*
 887          * Schedule tasklet to run at a better time.
 888          */
 889         tasklet_schedule(&brd->helper_tasklet);
 890         return IRQ_HANDLED;
 891 }
 892
 893
 894 /*
 895  * dgap_init_globals()
 896  *
 897  * This is where we initialize the globals from the static insmod
 898  * configuration variables.  These are declared near the head of
 899  * this file.
 900  */
 901 static void dgap_init_globals(void)
 902 {
 903         int i = 0;
 904
 905         dgap_rawreadok          = rawreadok;
 906         dgap_trcbuf_size        = trcbuf_size;
 907         dgap_debug              = debug;
 908
 909         for (i = 0; i < MAXBOARDS; i++) {
 910                 dgap_Board[i] = NULL;
 911         }
 912
 913         init_timer( &dgap_poll_timer );
 914
 915         init_waitqueue_head(&dgap_dl_wait);
 916         dgap_dl_action = 0;
 917 }
 918
 919
 920 /************************************************************************
 921  *
 922  * Utility functions
 923  *
 924  ************************************************************************/
 925
 926
 927 /*
 928  * dgap_driver_kzmalloc()
 929  *
 930  * Malloc and clear memory,
 931  */
 932 void *dgap_driver_kzmalloc(size_t size, int priority)
 933 {
 934         void *p = kmalloc(size, priority);
 935         if(p)
 936                 memset(p, 0, size);
 937         return(p);
 938 }
 939
 940
 941 /*
 942  * dgap_mbuf()
 943  *
 944  * Used to print to the message buffer during board init.
 945  */
 946 static void dgap_mbuf(struct board_t *brd, const char *fmt, ...) {
 947         va_list         ap;
 948         char            buf[1024];
 949         int             i;
 950         unsigned long   flags;
 951         size_t          length;
 952
 953         DGAP_LOCK(dgap_global_lock, flags);
 954
 955         /* Format buf using fmt and arguments contained in ap. */
 956         va_start(ap, fmt);
 957         i = vsnprintf(buf, sizeof(buf), fmt,  ap);
 958         va_end(ap);
 959
 960         DPR((buf));
 961
 962         if (!brd || !brd->msgbuf) {
 963                 printk("%s", buf);
 964                 DGAP_UNLOCK(dgap_global_lock, flags);
 965                 return;
 966         }
 967
 968         length = strlen(buf) + 1;
 969         if (brd->msgbuf - brd->msgbuf_head < length)
 970                 length = brd->msgbuf - brd->msgbuf_head;
 971         memcpy(brd->msgbuf, buf, length);
 972         brd->msgbuf += length;
 973
 974         DGAP_UNLOCK(dgap_global_lock, flags);
 975 }
 976
 977
 978 /*
 979  * dgap_ms_sleep()
 980  *
 981  * Put the driver to sleep for x ms's
 982  *
 983  * Returns 0 if timed out, !0 (showing signal) if interrupted by a signal.
 984  */
 985 int dgap_ms_sleep(ulong ms)
 986 {
 987         current->state = TASK_INTERRUPTIBLE;
 988         schedule_timeout((ms * HZ) / 1000);
 989         return (signal_pending(current));
 990 }
 991
 992
 993
 994 /*
 995  *      dgap_ioctl_name() : Returns a text version of each ioctl value.
 996  */
 997 char *dgap_ioctl_name(int cmd)
 998 {
 999         switch(cmd) {
1000
1001         case TCGETA:            return("TCGETA");
1002         case TCGETS:            return("TCGETS");
1003         case TCSETA:            return("TCSETA");
1004         case TCSETS:            return("TCSETS");
1005         case TCSETAW:           return("TCSETAW");
1006         case TCSETSW:           return("TCSETSW");
1007         case TCSETAF:           return("TCSETAF");
1008         case TCSETSF:           return("TCSETSF");
1009         case TCSBRK:            return("TCSBRK");
1010         case TCXONC:            return("TCXONC");
1011         case TCFLSH:            return("TCFLSH");
1012         case TIOCGSID:          return("TIOCGSID");
1013
1014         case TIOCGETD:          return("TIOCGETD");
1015         case TIOCSETD:          return("TIOCSETD");
1016         case TIOCGWINSZ:        return("TIOCGWINSZ");
1017         case TIOCSWINSZ:        return("TIOCSWINSZ");
1018
1019         case TIOCMGET:          return("TIOCMGET");
1020         case TIOCMSET:          return("TIOCMSET");
1021         case TIOCMBIS:          return("TIOCMBIS");
1022         case TIOCMBIC:          return("TIOCMBIC");
1023
1024         /* from digi.h */
1025         case DIGI_SETA:         return("DIGI_SETA");
1026         case DIGI_SETAW:        return("DIGI_SETAW");
1027         case DIGI_SETAF:        return("DIGI_SETAF");
1028         case DIGI_SETFLOW:      return("DIGI_SETFLOW");
1029         case DIGI_SETAFLOW:     return("DIGI_SETAFLOW");
1030         case DIGI_GETFLOW:      return("DIGI_GETFLOW");
1031         case DIGI_GETAFLOW:     return("DIGI_GETAFLOW");
1032         case DIGI_GETA:         return("DIGI_GETA");
1033         case DIGI_GEDELAY:      return("DIGI_GEDELAY");
1034         case DIGI_SEDELAY:      return("DIGI_SEDELAY");
1035         case DIGI_GETCUSTOMBAUD: return("DIGI_GETCUSTOMBAUD");
1036         case DIGI_SETCUSTOMBAUD: return("DIGI_SETCUSTOMBAUD");
1037         case TIOCMODG:          return("TIOCMODG");
1038         case TIOCMODS:          return("TIOCMODS");
1039         case TIOCSDTR:          return("TIOCSDTR");
1040         case TIOCCDTR:          return("TIOCCDTR");
1041
1042         default:                return("unknown");
1043         }
1044 }