drivers/staging/dgnc/dgnc_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  */
  31
  32
  33 #include <linux/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/pci.h>
  36 #include <linux/slab.h>
  37 #include <linux/sched.h>
  38 #include "dgnc_driver.h"
  39 #include "dgnc_pci.h"
  40 #include "dpacompat.h"
  41 #include "dgnc_mgmt.h"
  42 #include "dgnc_tty.h"
  43 #include "dgnc_trace.h"
  44 #include "dgnc_cls.h"
  45 #include "dgnc_neo.h"
  46 #include "dgnc_sysfs.h"
  47
  48 MODULE_LICENSE("GPL");
  49 MODULE_AUTHOR("Digi International, http://www.digi.com");
  50 MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");
  51 MODULE_SUPPORTED_DEVICE("dgnc");
  52
  53 /*
  54  * insmod command line overrideable parameters
  55  *
  56  * NOTE: we use a set of macros to create the variables, which allows
  57  * us to specify the variable type, name, initial value, and description.
  58  */
  59 PARM_INT(debug,         0x00,           0644,   "Driver debugging level");
  60 PARM_INT(rawreadok,     1,              0644,   "Bypass flip buffers on input");
  61 PARM_INT(trcbuf_size,   0x100000,       0644,   "Debugging trace buffer size.");
  62
  63 /**************************************************************************
  64  *
  65  * protos for this file
  66  *
  67  */
  68 static int              dgnc_start(void);
  69 static int              dgnc_finalize_board_init(struct dgnc_board *brd);
  70 static void             dgnc_init_globals(void);
  71 static int              dgnc_found_board(struct pci_dev *pdev, int id);
  72 static void             dgnc_cleanup_board(struct dgnc_board *brd);
  73 static void             dgnc_poll_handler(ulong dummy);
  74 static int              dgnc_init_pci(void);
  75 static int              dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
  76 static void             dgnc_remove_one(struct pci_dev *dev);
  77 static int              dgnc_probe1(struct pci_dev *pdev, int card_type);
  78 static void             dgnc_do_remap(struct dgnc_board *brd);
  79
  80 /* Driver load/unload functions */
  81 int             dgnc_init_module(void);
  82 void            dgnc_cleanup_module(void);
  83
  84 module_init(dgnc_init_module);
  85 module_exit(dgnc_cleanup_module);
  86
  87
  88 /*
  89  * File operations permitted on Control/Management major.
  90  */
  91 static struct file_operations dgnc_BoardFops =
  92 {
  93         .owner          =       THIS_MODULE,
  94         .unlocked_ioctl =       dgnc_mgmt_ioctl,
  95         .open           =       dgnc_mgmt_open,
  96         .release        =       dgnc_mgmt_close
  97 };
  98
  99
 100 /*
 101  * Globals
 102  */
 103 uint                    dgnc_NumBoards;
 104 struct dgnc_board               *dgnc_Board[MAXBOARDS];
 105 DEFINE_SPINLOCK(dgnc_global_lock);
 106 int                     dgnc_driver_state = DRIVER_INITIALIZED;
 107 ulong                   dgnc_poll_counter;
 108 uint                    dgnc_Major;
 109 int                     dgnc_poll_tick = 20;    /* Poll interval - 20 ms */
 110
 111 /*
 112  * Static vars.
 113  */
 114 static uint             dgnc_Major_Control_Registered = FALSE;
 115 static uint             dgnc_driver_start = FALSE;
 116
 117 static struct class *dgnc_class;
 118
 119 /*
 120  * Poller stuff
 121  */
 122 static                  DEFINE_SPINLOCK(dgnc_poll_lock);        /* Poll scheduling lock */
 123 static ulong            dgnc_poll_time;                         /* Time of next poll */
 124 static uint             dgnc_poll_stop;                         /* Used to tell poller to stop */
 125 static struct timer_list dgnc_poll_timer;
 126
 127
 128 static struct pci_device_id dgnc_pci_tbl[] = {
 129         {       DIGI_VID, PCI_DEVICE_CLASSIC_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       0 },
 130         {       DIGI_VID, PCI_DEVICE_CLASSIC_4_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   1 },
 131         {       DIGI_VID, PCI_DEVICE_CLASSIC_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       2 },
 132         {       DIGI_VID, PCI_DEVICE_CLASSIC_8_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   3 },
 133         {       DIGI_VID, PCI_DEVICE_NEO_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,           4 },
 134         {       DIGI_VID, PCI_DEVICE_NEO_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,           5 },
 135         {       DIGI_VID, PCI_DEVICE_NEO_2DB9_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,        6 },
 136         {       DIGI_VID, PCI_DEVICE_NEO_2DB9PRI_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,     7 },
 137         {       DIGI_VID, PCI_DEVICE_NEO_2RJ45_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       8 },
 138         {       DIGI_VID, PCI_DEVICE_NEO_2RJ45PRI_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,    9 },
 139         {       DIGI_VID, PCI_DEVICE_NEO_1_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       10 },
 140         {       DIGI_VID, PCI_DEVICE_NEO_1_422_485_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   11 },
 141         {       DIGI_VID, PCI_DEVICE_NEO_2_422_485_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   12 },
 142         {       DIGI_VID, PCI_DEVICE_NEO_EXPRESS_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,    13 },
 143         {       DIGI_VID, PCI_DEVICE_NEO_EXPRESS_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   14 },
 144         {       DIGI_VID, PCI_DEVICE_NEO_EXPRESS_4RJ45_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       15 },
 145         {       DIGI_VID, PCI_DEVICE_NEO_EXPRESS_8RJ45_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       16 },
 146         {0,}                                            /* 0 terminated list. */
 147 };
 148 MODULE_DEVICE_TABLE(pci, dgnc_pci_tbl);
 149
 150 struct board_id {
 151         uchar *name;
 152         uint maxports;
 153         unsigned int is_pci_express;
 154 };
 155
 156 static struct board_id dgnc_Ids[] =
 157 {
 158         {       PCI_DEVICE_CLASSIC_4_PCI_NAME,          4,      0       },
 159         {       PCI_DEVICE_CLASSIC_4_422_PCI_NAME,      4,      0       },
 160         {       PCI_DEVICE_CLASSIC_8_PCI_NAME,          8,      0       },
 161         {       PCI_DEVICE_CLASSIC_8_422_PCI_NAME,      8,      0       },
 162         {       PCI_DEVICE_NEO_4_PCI_NAME,              4,      0       },
 163         {       PCI_DEVICE_NEO_8_PCI_NAME,              8,      0       },
 164         {       PCI_DEVICE_NEO_2DB9_PCI_NAME,           2,      0       },
 165         {       PCI_DEVICE_NEO_2DB9PRI_PCI_NAME,        2,      0       },
 166         {       PCI_DEVICE_NEO_2RJ45_PCI_NAME,          2,      0       },
 167         {       PCI_DEVICE_NEO_2RJ45PRI_PCI_NAME,       2,      0       },
 168         {       PCI_DEVICE_NEO_1_422_PCI_NAME,          1,      0       },
 169         {       PCI_DEVICE_NEO_1_422_485_PCI_NAME,      1,      0       },
 170         {       PCI_DEVICE_NEO_2_422_485_PCI_NAME,      2,      0       },
 171         {       PCI_DEVICE_NEO_EXPRESS_8_PCI_NAME,      8,      1       },
 172         {       PCI_DEVICE_NEO_EXPRESS_4_PCI_NAME,      4,      1       },
 173         {       PCI_DEVICE_NEO_EXPRESS_4RJ45_PCI_NAME,  4,      1       },
 174         {       PCI_DEVICE_NEO_EXPRESS_8RJ45_PCI_NAME,  8,      1       },
 175         {       NULL,                                   0,      0       }
 176 };
 177
 178 static struct pci_driver dgnc_driver = {
 179         .name           = "dgnc",
 180         .probe          = dgnc_init_one,
 181         .id_table       = dgnc_pci_tbl,
 182         .remove         = dgnc_remove_one,
 183 };
 184
 185
 186 char *dgnc_state_text[] = {
 187         "Board Failed",
 188         "Board Found",
 189         "Board READY",
 190 };
 191
 192 char *dgnc_driver_state_text[] = {
 193         "Driver Initialized",
 194         "Driver Ready."
 195 };
 196
 197
 198
 199 /************************************************************************
 200  *
 201  * Driver load/unload functions
 202  *
 203  ************************************************************************/
 204
 205
 206 /*
 207  * init_module()
 208  *
 209  * Module load.  This is where it all starts.
 210  */
 211 int dgnc_init_module(void)
 212 {
 213         int rc = 0;
 214
 215         APR(("%s, Digi International Part Number %s\n", DG_NAME, DG_PART));
 216
 217         /*
 218          * Initialize global stuff
 219          */
 220         rc = dgnc_start();
 221
 222         if (rc < 0) {
 223                 return rc;
 224         }
 225
 226         /*
 227          * Find and configure all the cards
 228          */
 229         rc = dgnc_init_pci();
 230
 231         /*
 232          * If something went wrong in the scan, bail out of driver.
 233          */
 234         if (rc < 0) {
 235                 /* Only unregister the pci driver if it was actually registered. */
 236                 if (dgnc_NumBoards)
 237                         pci_unregister_driver(&dgnc_driver);
 238                 else
 239                         printk("WARNING: dgnc driver load failed.  No Digi Neo or Classic boards found.\n");
 240
 241                 dgnc_cleanup_module();
 242         }
 243         else {
 244                 dgnc_create_driver_sysfiles(&dgnc_driver);
 245         }
 246
 247         DPR_INIT(("Finished init_module. Returning %d\n", rc));
 248         return rc;
 249 }
 250
 251
 252 /*
 253  * Start of driver.
 254  */
 255 static int dgnc_start(void)
 256 {
 257         int rc = 0;
 258         unsigned long flags;
 259
 260         if (dgnc_driver_start == FALSE) {
 261
 262                 dgnc_driver_start = TRUE;
 263
 264                 /* make sure that the globals are init'd before we do anything else */
 265                 dgnc_init_globals();
 266
 267                 dgnc_NumBoards = 0;
 268
 269                 APR(("For the tools package or updated drivers please visit http://www.digi.com\n"));
 270
 271                 /*
 272                  * Register our base character device into the kernel.
 273                  * This allows the download daemon to connect to the downld device
 274                  * before any of the boards are init'ed.
 275                  */
 276                 if (!dgnc_Major_Control_Registered) {
 277                         /*
 278                          * Register management/dpa devices
 279                          */
 280                         rc = register_chrdev(0, "dgnc", &dgnc_BoardFops);
 281                         if (rc <= 0) {
 282                                 APR(("Can't register dgnc driver device (%d)\n", rc));
 283                                 rc = -ENXIO;
 284                                 return rc;
 285                         }
 286                         dgnc_Major = rc;
 287
 288                         dgnc_class = class_create(THIS_MODULE, "dgnc_mgmt");
 289                         device_create(dgnc_class, NULL,
 290                                 MKDEV(dgnc_Major, 0),
 291                                 NULL, "dgnc_mgmt");
 292                         dgnc_Major_Control_Registered = TRUE;
 293                 }
 294
 295                 /*
 296                  * Init any global tty stuff.
 297                  */
 298                 rc = dgnc_tty_preinit();
 299
 300                 if (rc < 0) {
 301                         APR(("tty preinit - not enough memory (%d)\n", rc));
 302                         return rc;
 303                 }
 304
 305                 /* Start the poller */
 306                 DGNC_LOCK(dgnc_poll_lock, flags);
 307                 init_timer(&dgnc_poll_timer);
 308                 dgnc_poll_timer.function = dgnc_poll_handler;
 309                 dgnc_poll_timer.data = 0;
 310                 dgnc_poll_time = jiffies + dgnc_jiffies_from_ms(dgnc_poll_tick);
 311                 dgnc_poll_timer.expires = dgnc_poll_time;
 312                 DGNC_UNLOCK(dgnc_poll_lock, flags);
 313
 314                 add_timer(&dgnc_poll_timer);
 315
 316                 dgnc_driver_state = DRIVER_READY;
 317         }
 318
 319         return rc;
 320 }
 321
 322 /*
 323  * Register pci driver, and return how many boards we have.
 324  */
 325 static int dgnc_init_pci(void)
 326 {
 327         return pci_register_driver(&dgnc_driver);
 328 }
 329
 330
 331 /* returns count (>= 0), or negative on error */
 332 static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 333 {
 334         int rc;
 335
 336         /* wake up and enable device */
 337         rc = pci_enable_device(pdev);
 338
 339         if (rc < 0) {
 340                 rc = -EIO;
 341         } else {
 342                 rc = dgnc_probe1(pdev, ent->driver_data);
 343                 if (rc == 0) {
 344                         dgnc_NumBoards++;
 345                         DPR_INIT(("Incrementing numboards to %d\n", dgnc_NumBoards));
 346                 }
 347         }
 348         return rc;
 349 }
 350
 351 static int dgnc_probe1(struct pci_dev *pdev, int card_type)
 352 {
 353         return dgnc_found_board(pdev, card_type);
 354 }
 355
 356
 357 static void dgnc_remove_one(struct pci_dev *dev)
 358 {
 359         /* Do Nothing */
 360 }
 361
 362 /*
 363  * dgnc_cleanup_module()
 364  *
 365  * Module unload.  This is where it all ends.
 366  */
 367 void dgnc_cleanup_module(void)
 368 {
 369         int i;
 370         ulong lock_flags;
 371
 372         DGNC_LOCK(dgnc_poll_lock, lock_flags);
 373         dgnc_poll_stop = 1;
 374         DGNC_UNLOCK(dgnc_poll_lock, lock_flags);
 375
 376         /* Turn off poller right away. */
 377         del_timer_sync(&dgnc_poll_timer);
 378
 379         dgnc_remove_driver_sysfiles(&dgnc_driver);
 380
 381         if (dgnc_Major_Control_Registered) {
 382                 device_destroy(dgnc_class, MKDEV(dgnc_Major, 0));
 383                 class_destroy(dgnc_class);
 384                 unregister_chrdev(dgnc_Major, "dgnc");
 385         }
 386
 387         for (i = 0; i < dgnc_NumBoards; ++i) {
 388                 dgnc_remove_ports_sysfiles(dgnc_Board[i]);
 389                 dgnc_tty_uninit(dgnc_Board[i]);
 390                 dgnc_cleanup_board(dgnc_Board[i]);
 391         }
 392
 393         dgnc_tty_post_uninit();
 394
 395 #if defined(DGNC_TRACER)
 396         /* last thing, make sure we release the tracebuffer */
 397         dgnc_tracer_free();
 398 #endif
 399         if (dgnc_NumBoards)
 400                 pci_unregister_driver(&dgnc_driver);
 401 }
 402
 403
 404 /*
 405  * dgnc_cleanup_board()
 406  *
 407  * Free all the memory associated with a board
 408  */
 409 static void dgnc_cleanup_board(struct dgnc_board *brd)
 410 {
 411         int i = 0;
 412
 413         if(!brd || brd->magic != DGNC_BOARD_MAGIC)
 414                 return;
 415
 416         switch (brd->device) {
 417         case PCI_DEVICE_CLASSIC_4_DID:
 418         case PCI_DEVICE_CLASSIC_8_DID:
 419         case PCI_DEVICE_CLASSIC_4_422_DID:
 420         case PCI_DEVICE_CLASSIC_8_422_DID:
 421
 422                 /* Tell card not to interrupt anymore. */
 423                 outb(0, brd->iobase + 0x4c);
 424                 break;
 425
 426         default:
 427                 break;
 428         }
 429
 430         if (brd->irq)
 431                 free_irq(brd->irq, brd);
 432
 433         tasklet_kill(&brd->helper_tasklet);
 434
 435         if (brd->re_map_membase) {
 436                 iounmap(brd->re_map_membase);
 437                 brd->re_map_membase = NULL;
 438         }
 439
 440         if (brd->msgbuf_head) {
 441                 unsigned long flags;
 442
 443                 DGNC_LOCK(dgnc_global_lock, flags);
 444                 brd->msgbuf = NULL;
 445                 printk("%s", brd->msgbuf_head);
 446                 kfree(brd->msgbuf_head);
 447                 brd->msgbuf_head = NULL;
 448                 DGNC_UNLOCK(dgnc_global_lock, flags);
 449         }
 450
 451         /* Free all allocated channels structs */
 452         for (i = 0; i < MAXPORTS ; i++) {
 453                 if (brd->channels[i]) {
 454                         if (brd->channels[i]->ch_rqueue)
 455                                 kfree(brd->channels[i]->ch_rqueue);
 456                         if (brd->channels[i]->ch_equeue)
 457                                 kfree(brd->channels[i]->ch_equeue);
 458                         if (brd->channels[i]->ch_wqueue)
 459                                 kfree(brd->channels[i]->ch_wqueue);
 460
 461                         kfree(brd->channels[i]);
 462                         brd->channels[i] = NULL;
 463                 }
 464         }
 465
 466         if (brd->flipbuf)
 467                 kfree(brd->flipbuf);
 468
 469         dgnc_Board[brd->boardnum] = NULL;
 470
 471         kfree(brd);
 472 }
 473
 474
 475 /*
 476  * dgnc_found_board()
 477  *
 478  * A board has been found, init it.
 479  */
 480 static int dgnc_found_board(struct pci_dev *pdev, int id)
 481 {
 482         struct dgnc_board *brd;
 483         unsigned int pci_irq;
 484         int i = 0;
 485         int rc = 0;
 486         unsigned long flags;
 487
 488         /* get the board structure and prep it */
 489         brd = dgnc_Board[dgnc_NumBoards] =
 490                 kzalloc(sizeof(*brd), GFP_KERNEL);
 491         if (!brd) {
 492                 APR(("memory allocation for board structure failed\n"));
 493                 return -ENOMEM;
 494         }
 495
 496         /* make a temporary message buffer for the boot messages */
 497         brd->msgbuf = brd->msgbuf_head =
 498                 kzalloc(sizeof(u8) * 8192, GFP_KERNEL);
 499         if (!brd->msgbuf) {
 500                 kfree(brd);
 501                 APR(("memory allocation for board msgbuf failed\n"));
 502                 return -ENOMEM;
 503         }
 504
 505         /* store the info for the board we've found */
 506         brd->magic = DGNC_BOARD_MAGIC;
 507         brd->boardnum = dgnc_NumBoards;
 508         brd->vendor = dgnc_pci_tbl[id].vendor;
 509         brd->device = dgnc_pci_tbl[id].device;
 510         brd->pdev = pdev;
 511         brd->pci_bus = pdev->bus->number;
 512         brd->pci_slot = PCI_SLOT(pdev->devfn);
 513         brd->name = dgnc_Ids[id].name;
 514         brd->maxports = dgnc_Ids[id].maxports;
 515         if (dgnc_Ids[i].is_pci_express)
 516                 brd->bd_flags |= BD_IS_PCI_EXPRESS;
 517         brd->dpastatus = BD_NOFEP;
 518         init_waitqueue_head(&brd->state_wait);
 519
 520         DGNC_SPINLOCK_INIT(brd->bd_lock);
 521         DGNC_SPINLOCK_INIT(brd->bd_intr_lock);
 522
 523         brd->state              = BOARD_FOUND;
 524
 525         for (i = 0; i < MAXPORTS; i++) {
 526                 brd->channels[i] = NULL;
 527         }
 528
 529         /* store which card & revision we have */
 530         pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &brd->subvendor);
 531         pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &brd->subdevice);
 532         pci_read_config_byte(pdev, PCI_REVISION_ID, &brd->rev);
 533
 534         pci_irq = pdev->irq;
 535         brd->irq = pci_irq;
 536
 537
 538         switch(brd->device) {
 539
 540         case PCI_DEVICE_CLASSIC_4_DID:
 541         case PCI_DEVICE_CLASSIC_8_DID:
 542         case PCI_DEVICE_CLASSIC_4_422_DID:
 543         case PCI_DEVICE_CLASSIC_8_422_DID:
 544
 545                 brd->dpatype = T_CLASSIC | T_PCIBUS;
 546
 547                 DPR_INIT(("dgnc_found_board - Classic.\n"));
 548
 549                 /*
 550                  * For PCI ClassicBoards
 551                  * PCI Local Address (i.e. "resource" number) space
 552                  * 0    PLX Memory Mapped Config
 553                  * 1    PLX I/O Mapped Config
 554                  * 2    I/O Mapped UARTs and Status
 555                  * 3    Memory Mapped VPD
 556                  * 4    Memory Mapped UARTs and Status
 557                  */
 558
 559
 560                 /* get the PCI Base Address Registers */
 561                 brd->membase = pci_resource_start(pdev, 4);
 562
 563                 if (!brd->membase) {
 564                         APR(("card has no PCI IO resources, failing board.\n"));
 565                         return -ENODEV;
 566                 }
 567
 568                 brd->membase_end = pci_resource_end(pdev, 4);
 569
 570                 if (brd->membase & 1)
 571                         brd->membase &= ~3;
 572                 else
 573                         brd->membase &= ~15;
 574
 575                 brd->iobase     = pci_resource_start(pdev, 1);
 576                 brd->iobase_end = pci_resource_end(pdev, 1);
 577                 brd->iobase     = ((unsigned int) (brd->iobase)) & 0xFFFE;
 578
 579                 /* Assign the board_ops struct */
 580                 brd->bd_ops = &dgnc_cls_ops;
 581
 582                 brd->bd_uart_offset = 0x8;
 583                 brd->bd_dividend = 921600;
 584
 585                 dgnc_do_remap(brd);
 586
 587                 /* Get and store the board VPD, if it exists */
 588                 brd->bd_ops->vpd(brd);
 589
 590                 /*
 591                  * Enable Local Interrupt 1               (0x1),
 592                  * Local Interrupt 1 Polarity Active high (0x2),
 593                  * Enable PCI interrupt                   (0x40)
 594                  */
 595                 outb(0x43, brd->iobase + 0x4c);
 596
 597                 break;
 598
 599
 600         case PCI_DEVICE_NEO_4_DID:
 601         case PCI_DEVICE_NEO_8_DID:
 602         case PCI_DEVICE_NEO_2DB9_DID:
 603         case PCI_DEVICE_NEO_2DB9PRI_DID:
 604         case PCI_DEVICE_NEO_2RJ45_DID:
 605         case PCI_DEVICE_NEO_2RJ45PRI_DID:
 606         case PCI_DEVICE_NEO_1_422_DID:
 607         case PCI_DEVICE_NEO_1_422_485_DID:
 608         case PCI_DEVICE_NEO_2_422_485_DID:
 609         case PCI_DEVICE_NEO_EXPRESS_8_DID:
 610         case PCI_DEVICE_NEO_EXPRESS_4_DID:
 611         case PCI_DEVICE_NEO_EXPRESS_4RJ45_DID:
 612         case PCI_DEVICE_NEO_EXPRESS_8RJ45_DID:
 613
 614                 /*
 615                  * This chip is set up 100% when we get to it.
 616                  * No need to enable global interrupts or anything.
 617                  */
 618                 if (brd->bd_flags & BD_IS_PCI_EXPRESS)
 619                         brd->dpatype = T_NEO_EXPRESS | T_PCIBUS;
 620                 else
 621                         brd->dpatype = T_NEO | T_PCIBUS;
 622
 623                 DPR_INIT(("dgnc_found_board - NEO.\n"));
 624
 625                 /* get the PCI Base Address Registers */
 626                 brd->membase     = pci_resource_start(pdev, 0);
 627                 brd->membase_end = pci_resource_end(pdev, 0);
 628
 629                 if (brd->membase & 1)
 630                         brd->membase &= ~3;
 631                 else
 632                         brd->membase &= ~15;
 633
 634                 /* Assign the board_ops struct */
 635                 brd->bd_ops = &dgnc_neo_ops;
 636
 637                 brd->bd_uart_offset = 0x200;
 638                 brd->bd_dividend = 921600;
 639
 640                 dgnc_do_remap(brd);
 641
 642                 if (brd->re_map_membase) {
 643
 644                         /* After remap is complete, we need to read and store the dvid */
 645                         brd->dvid = readb(brd->re_map_membase + 0x8D);
 646
 647                         /* Get and store the board VPD, if it exists */
 648                         brd->bd_ops->vpd(brd);
 649                 }
 650                 break;
 651
 652         default:
 653                 APR(("Did not find any compatible Neo or Classic PCI boards in system.\n"));
 654                 return -ENXIO;
 655
 656         }
 657
 658         /*
 659          * Do tty device initialization.
 660          */
 661
 662         rc = dgnc_tty_register(brd);
 663         if (rc < 0) {
 664                 dgnc_tty_uninit(brd);
 665                 APR(("Can't register tty devices (%d)\n", rc));
 666                 brd->state = BOARD_FAILED;
 667                 brd->dpastatus = BD_NOFEP;
 668                 goto failed;
 669         }
 670
 671         rc = dgnc_finalize_board_init(brd);
 672         if (rc < 0) {
 673                 APR(("Can't finalize board init (%d)\n", rc));
 674                 brd->state = BOARD_FAILED;
 675                 brd->dpastatus = BD_NOFEP;
 676
 677                 goto failed;
 678         }
 679
 680         rc = dgnc_tty_init(brd);
 681         if (rc < 0) {
 682                 dgnc_tty_uninit(brd);
 683                 APR(("Can't init tty devices (%d)\n", rc));
 684                 brd->state = BOARD_FAILED;
 685                 brd->dpastatus = BD_NOFEP;
 686
 687                 goto failed;
 688         }
 689
 690         brd->state = BOARD_READY;
 691         brd->dpastatus = BD_RUNNING;
 692
 693         dgnc_create_ports_sysfiles(brd);
 694
 695         /* init our poll helper tasklet */
 696         tasklet_init(&brd->helper_tasklet, brd->bd_ops->tasklet, (unsigned long) brd);
 697
 698         DPR_INIT(("dgnc_scan(%d) - printing out the msgbuf\n", i));
 699         DGNC_LOCK(dgnc_global_lock, flags);
 700         brd->msgbuf = NULL;
 701         printk("%s", brd->msgbuf_head);
 702         kfree(brd->msgbuf_head);
 703         brd->msgbuf_head = NULL;
 704         DGNC_UNLOCK(dgnc_global_lock, flags);
 705
 706         /*
 707          * allocate flip buffer for board.
 708          *
 709          * Okay to malloc with GFP_KERNEL, we are not at interrupt
 710          * context, and there are no locks held.
 711          */
 712         brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL);
 713
 714         wake_up_interruptible(&brd->state_wait);
 715
 716         return 0;
 717
 718 failed:
 719
 720         return -ENXIO;
 721
 722 }
 723
 724
 725 static int dgnc_finalize_board_init(struct dgnc_board *brd) {
 726         int rc = 0;
 727
 728         DPR_INIT(("dgnc_finalize_board_init() - start\n"));
 729
 730         if (!brd || brd->magic != DGNC_BOARD_MAGIC)
 731                 return -ENODEV;
 732
 733         DPR_INIT(("dgnc_finalize_board_init() - start #2\n"));
 734
 735         if (brd->irq) {
 736                 rc = request_irq(brd->irq, brd->bd_ops->intr, IRQF_SHARED, "DGNC", brd);
 737
 738                 if (rc) {
 739                         printk("Failed to hook IRQ %d\n",brd->irq);
 740                         brd->state = BOARD_FAILED;
 741                         brd->dpastatus = BD_NOFEP;
 742                         rc = -ENODEV;
 743                 } else {
 744                         DPR_INIT(("Requested and received usage of IRQ %d\n", brd->irq));
 745                 }
 746         }
 747         return rc;
 748 }
 749
 750 /*
 751  * Remap PCI memory.
 752  */
 753 static void dgnc_do_remap(struct dgnc_board *brd)
 754 {
 755
 756         if (!brd || brd->magic != DGNC_BOARD_MAGIC)
 757                 return;
 758
 759         brd->re_map_membase = ioremap(brd->membase, 0x1000);
 760
 761         DPR_INIT(("remapped mem: 0x%p\n", brd->re_map_membase));
 762 }
 763
 764
 765 /*****************************************************************************
 766 *
 767 * Function:
 768 *
 769 *    dgnc_poll_handler
 770 *
 771 * Author:
 772 *
 773 *    Scott H Kilau
 774 *
 775 * Parameters:
 776 *
 777 *    dummy -- ignored
 778 *
 779 * Return Values:
 780 *
 781 *    none
 782 *
 783 * Description:
 784 *
 785 *    As each timer expires, it determines (a) whether the "transmit"
 786 *    waiter needs to be woken up, and (b) whether the poller needs to
 787 *    be rescheduled.
 788 *
 789 ******************************************************************************/
 790
 791 static void dgnc_poll_handler(ulong dummy)
 792 {
 793         struct dgnc_board *brd;
 794         unsigned long lock_flags;
 795         int i;
 796         unsigned long new_time;
 797
 798         dgnc_poll_counter++;
 799
 800         /*
 801          * Do not start the board state machine until
 802          * driver tells us its up and running, and has
 803          * everything it needs.
 804          */
 805         if (dgnc_driver_state != DRIVER_READY) {
 806                 goto schedule_poller;
 807         }
 808
 809         /* Go thru each board, kicking off a tasklet for each if needed */
 810         for (i = 0; i < dgnc_NumBoards; i++) {
 811                 brd = dgnc_Board[i];
 812
 813                 DGNC_LOCK(brd->bd_lock, lock_flags);
 814
 815                 /* If board is in a failed state, don't bother scheduling a tasklet */
 816                 if (brd->state == BOARD_FAILED) {
 817                         DGNC_UNLOCK(brd->bd_lock, lock_flags);
 818                         continue;
 819                 }
 820
 821                 /* Schedule a poll helper task */
 822                 tasklet_schedule(&brd->helper_tasklet);
 823
 824                 DGNC_UNLOCK(brd->bd_lock, lock_flags);
 825         }
 826
 827 schedule_poller:
 828
 829         /*
 830          * Schedule ourself back at the nominal wakeup interval.
 831          */
 832         DGNC_LOCK(dgnc_poll_lock, lock_flags);
 833         dgnc_poll_time += dgnc_jiffies_from_ms(dgnc_poll_tick);
 834
 835         new_time = dgnc_poll_time - jiffies;
 836
 837         if ((ulong) new_time >= 2 * dgnc_poll_tick) {
 838                 dgnc_poll_time = jiffies +  dgnc_jiffies_from_ms(dgnc_poll_tick);
 839         }
 840
 841         init_timer(&dgnc_poll_timer);
 842         dgnc_poll_timer.function = dgnc_poll_handler;
 843         dgnc_poll_timer.data = 0;
 844         dgnc_poll_timer.expires = dgnc_poll_time;
 845         DGNC_UNLOCK(dgnc_poll_lock, lock_flags);
 846
 847         if (!dgnc_poll_stop)
 848                 add_timer(&dgnc_poll_timer);
 849 }
 850
 851 /*
 852  * dgnc_init_globals()
 853  *
 854  * This is where we initialize the globals from the static insmod
 855  * configuration variables.  These are declared near the head of
 856  * this file.
 857  */
 858 static void dgnc_init_globals(void)
 859 {
 860         int i = 0;
 861
 862         dgnc_rawreadok          = rawreadok;
 863         dgnc_trcbuf_size        = trcbuf_size;
 864         dgnc_debug              = debug;
 865
 866         for (i = 0; i < MAXBOARDS; i++) {
 867                 dgnc_Board[i] = NULL;
 868         }
 869
 870         init_timer(&dgnc_poll_timer);
 871 }
 872
 873
 874 /************************************************************************
 875  *
 876  * Utility functions
 877  *
 878  ************************************************************************/
 879
 880 /*
 881  * dgnc_ms_sleep()
 882  *
 883  * Put the driver to sleep for x ms's
 884  *
 885  * Returns 0 if timed out, !0 (showing signal) if interrupted by a signal.
 886  */
 887 int dgnc_ms_sleep(ulong ms)
 888 {
 889         current->state = TASK_INTERRUPTIBLE;
 890         schedule_timeout((ms * HZ) / 1000);
 891         return signal_pending(current);
 892 }
 893
 894
 895
 896 /*
 897  *      dgnc_ioctl_name() : Returns a text version of each ioctl value.
 898  */
 899 char *dgnc_ioctl_name(int cmd)
 900 {
 901         switch(cmd) {
 902
 903         case TCGETA:            return "TCGETA";
 904         case TCGETS:            return "TCGETS";
 905         case TCSETA:            return "TCSETA";
 906         case TCSETS:            return "TCSETS";
 907         case TCSETAW:           return "TCSETAW";
 908         case TCSETSW:           return "TCSETSW";
 909         case TCSETAF:           return "TCSETAF";
 910         case TCSETSF:           return "TCSETSF";
 911         case TCSBRK:            return "TCSBRK";
 912         case TCXONC:            return "TCXONC";
 913         case TCFLSH:            return "TCFLSH";
 914         case TIOCGSID:          return "TIOCGSID";
 915
 916         case TIOCGETD:          return "TIOCGETD";
 917         case TIOCSETD:          return "TIOCSETD";
 918         case TIOCGWINSZ:        return "TIOCGWINSZ";
 919         case TIOCSWINSZ:        return "TIOCSWINSZ";
 920
 921         case TIOCMGET:          return "TIOCMGET";
 922         case TIOCMSET:          return "TIOCMSET";
 923         case TIOCMBIS:          return "TIOCMBIS";
 924         case TIOCMBIC:          return "TIOCMBIC";
 925
 926         /* from digi.h */
 927         case DIGI_SETA:         return "DIGI_SETA";
 928         case DIGI_SETAW:        return "DIGI_SETAW";
 929         case DIGI_SETAF:        return "DIGI_SETAF";
 930         case DIGI_SETFLOW:      return "DIGI_SETFLOW";
 931         case DIGI_SETAFLOW:     return "DIGI_SETAFLOW";
 932         case DIGI_GETFLOW:      return "DIGI_GETFLOW";
 933         case DIGI_GETAFLOW:     return "DIGI_GETAFLOW";
 934         case DIGI_GETA:         return "DIGI_GETA";
 935         case DIGI_GEDELAY:      return "DIGI_GEDELAY";
 936         case DIGI_SEDELAY:      return "DIGI_SEDELAY";
 937         case DIGI_GETCUSTOMBAUD: return "DIGI_GETCUSTOMBAUD";
 938         case DIGI_SETCUSTOMBAUD: return "DIGI_SETCUSTOMBAUD";
 939         case TIOCMODG:          return "TIOCMODG";
 940         case TIOCMODS:          return "TIOCMODS";
 941         case TIOCSDTR:          return "TIOCSDTR";
 942         case TIOCCDTR:          return "TIOCCDTR";
 943
 944         default:                return "unknown";
 945         }
 946 }