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