drivers/isdn/avmb1/t1pci.c

   1 /*
   2  * $Id: t1pci.c,v 1.13.6.1 2000/11/28 12:02:45 kai Exp $
   3  *
   4  * Module for AVM T1 PCI-card.
   5  *
   6  * (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
   7  *
   8  * $Log: t1pci.c,v $
   9  * Revision 1.13.6.1  2000/11/28 12:02:45  kai
  10  * MODULE_DEVICE_TABLE for 2.4
  11  *
  12  * Revision 1.13.2.2  2000/11/26 17:47:53  kai
  13  * added PCI_DEV_TABLE for 2.4
  14  *
  15  * Revision 1.13.2.1  2000/11/26 17:14:19  kai
  16  * fix device ids
  17  * also needs patches to include/linux/pci_ids.h
  18  *
  19  * Revision 1.13  2000/11/23 20:45:14  kai
  20  * fixed module_init/exit stuff
  21  * Note: compiled-in kernel doesn't work pre 2.2.18 anymore.
  22  *
  23  * Revision 1.12  2000/11/01 14:05:02  calle
  24  * - use module_init/module_exit from linux/init.h.
  25  * - all static struct variables are initialized with "membername:" now.
  26  * - avm_cs.c, let it work with newer pcmcia-cs.
  27  *
  28  * Revision 1.11  2000/08/08 09:24:19  calle
  29  * calls to pci_enable_device surounded by #ifndef COMPAT_HAS_2_2_PCI
  30  *
  31  * Revision 1.10  2000/07/20 10:21:21  calle
  32  * Bugfix: driver will not be unregistered, if not cards were detected.
  33  *         this result in an oops in kcapi.c
  34  *
  35  * Revision 1.9  2000/05/19 15:43:22  calle
  36  * added calls to pci_device_start().
  37  *
  38  * Revision 1.8  2000/05/06 00:52:36  kai
  39  * merged changes from kernel tree
  40  * fixed timer and net_device->name breakage
  41  *
  42  * Revision 1.7  2000/04/07 15:26:55  calle
  43  * better error message if cabel not connected or T1 has no power.
  44  *
  45  * Revision 1.6  2000/04/03 13:29:25  calle
  46  * make Tim Waugh happy (module unload races in 2.3.99-pre3).
  47  * no real problem there, but now it is much cleaner ...
  48  *
  49  * Revision 1.5  2000/02/02 18:36:04  calle
  50  * - Modules are now locked while init_module is running
  51  * - fixed problem with memory mapping if address is not aligned
  52  *
  53  * Revision 1.4  2000/01/25 14:33:38  calle
  54  * - Added Support AVM B1 PCI V4.0 (tested with prototype)
  55  *   - splitted up t1pci.c into b1dma.c for common function with b1pciv4
  56  *   - support for revision register
  57  *
  58  * Revision 1.3  1999/11/13 21:27:16  keil
  59  * remove KERNELVERSION
  60  *
  61  * Revision 1.2  1999/11/05 16:38:02  calle
  62  * Cleanups before kernel 2.4:
  63  * - Changed all messages to use card->name or driver->name instead of
  64  *   constant string.
  65  * - Moved some data from struct avmcard into new struct avmctrl_info.
  66  *   Changed all lowlevel capi driver to match the new structur.
  67  *
  68  * Revision 1.1  1999/10/26 15:31:42  calle
  69  * Added driver for T1-PCI card.
  70  *
  71  *
  72  */
  73
  74 #include <linux/config.h>
  75 #include <linux/module.h>
  76 #include <linux/kernel.h>
  77 #include <linux/skbuff.h>
  78 #include <linux/delay.h>
  79 #include <linux/mm.h>
  80 #include <linux/interrupt.h>
  81 #include <linux/ioport.h>
  82 #include <linux/pci.h>
  83 #include <linux/capi.h>
  84 #include <linux/init.h>
  85 #include <asm/io.h>
  86 #include "capicmd.h"
  87 #include "capiutil.h"
  88 #include "capilli.h"
  89 #include "avmcard.h"
  90
  91 static char *revision = "$Revision: 1.13.6.1 $";
  92
  93 #undef CONFIG_T1PCI_DEBUG
  94 #undef CONFIG_T1PCI_POLLDEBUG
  95
  96 /* ------------------------------------------------------------- */
  97
  98 static struct pci_device_id t1pci_pci_tbl[] __initdata = {
  99         { PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_T1, PCI_ANY_ID, PCI_ANY_ID },
 100         { }                             /* Terminating entry */
 101 };
 102
 103 MODULE_DEVICE_TABLE(pci, t1pci_pci_tbl);
 104 MODULE_AUTHOR("Carsten Paeth <calle@calle.in-berlin.de>");
 105
 106 /* ------------------------------------------------------------- */
 107
 108 static struct capi_driver_interface *di;
 109
 110 /* ------------------------------------------------------------- */
 111
 112 static void t1pci_remove_ctr(struct capi_ctr *ctrl)
 113 {
 114         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 115         avmcard *card = cinfo->card;
 116
 117         b1dma_reset(card);
 118
 119         di->detach_ctr(ctrl);
 120         free_irq(card->irq, card);
 121         iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
 122         release_region(card->port, AVMB1_PORTLEN);
 123         ctrl->driverdata = 0;
 124         kfree(card->ctrlinfo);
 125         kfree(card->dma);
 126         kfree(card);
 127
 128         MOD_DEC_USE_COUNT;
 129 }
 130
 131 /* ------------------------------------------------------------- */
 132
 133 static int t1pci_add_card(struct capi_driver *driver, struct capicardparams *p)
 134 {
 135         unsigned long base, page_offset;
 136         avmcard *card;
 137         avmctrl_info *cinfo;
 138         int retval;
 139
 140         MOD_INC_USE_COUNT;
 141
 142         card = (avmcard *) kmalloc(sizeof(avmcard), GFP_ATOMIC);
 143
 144         if (!card) {
 145                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 146                 MOD_DEC_USE_COUNT;
 147                 return -ENOMEM;
 148         }
 149         memset(card, 0, sizeof(avmcard));
 150         card->dma = (avmcard_dmainfo *) kmalloc(sizeof(avmcard_dmainfo), GFP_ATOMIC);
 151         if (!card->dma) {
 152                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 153                 kfree(card);
 154                 MOD_DEC_USE_COUNT;
 155                 return -ENOMEM;
 156         }
 157         memset(card->dma, 0, sizeof(avmcard_dmainfo));
 158         cinfo = (avmctrl_info *) kmalloc(sizeof(avmctrl_info), GFP_ATOMIC);
 159         if (!cinfo) {
 160                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 161                 kfree(card->dma);
 162                 kfree(card);
 163                 MOD_DEC_USE_COUNT;
 164                 return -ENOMEM;
 165         }
 166         memset(cinfo, 0, sizeof(avmctrl_info));
 167         card->ctrlinfo = cinfo;
 168         cinfo->card = card;
 169         sprintf(card->name, "t1pci-%x", p->port);
 170         card->port = p->port;
 171         card->irq = p->irq;
 172         card->membase = p->membase;
 173         card->cardtype = avm_t1pci;
 174
 175         if (check_region(card->port, AVMB1_PORTLEN)) {
 176                 printk(KERN_WARNING
 177                        "%s: ports 0x%03x-0x%03x in use.\n",
 178                        driver->name, card->port, card->port + AVMB1_PORTLEN);
 179                 kfree(card->ctrlinfo);
 180                 kfree(card->dma);
 181                 kfree(card);
 182                 MOD_DEC_USE_COUNT;
 183                 return -EBUSY;
 184         }
 185
 186         base = card->membase & PAGE_MASK;
 187         page_offset = card->membase - base;
 188         card->mbase = ioremap_nocache(base, page_offset + 64);
 189         if (card->mbase) {
 190                 card->mbase += page_offset;
 191         } else {
 192                 printk(KERN_NOTICE "%s: can't remap memory at 0x%lx\n",
 193                                         driver->name, card->membase);
 194                 kfree(card->ctrlinfo);
 195                 kfree(card->dma);
 196                 kfree(card);
 197                 MOD_DEC_USE_COUNT;
 198                 return -EIO;
 199         }
 200
 201         b1dma_reset(card);
 202
 203         if ((retval = t1pci_detect(card)) != 0) {
 204                 if (retval < 6)
 205                         printk(KERN_NOTICE "%s: NO card at 0x%x (%d)\n",
 206                                         driver->name, card->port, retval);
 207                 else
 208                         printk(KERN_NOTICE "%s: card at 0x%x, but cabel not connected or T1 has no power (%d)\n",
 209                                         driver->name, card->port, retval);
 210                 iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
 211                 kfree(card->ctrlinfo);
 212                 kfree(card->dma);
 213                 kfree(card);
 214                 MOD_DEC_USE_COUNT;
 215                 return -EIO;
 216         }
 217         b1dma_reset(card);
 218
 219         request_region(p->port, AVMB1_PORTLEN, card->name);
 220
 221         retval = request_irq(card->irq, b1dma_interrupt, SA_SHIRQ, card->name, card);
 222         if (retval) {
 223                 printk(KERN_ERR "%s: unable to get IRQ %d.\n",
 224                                 driver->name, card->irq);
 225                 iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
 226                 release_region(card->port, AVMB1_PORTLEN);
 227                 kfree(card->ctrlinfo);
 228                 kfree(card->dma);
 229                 kfree(card);
 230                 MOD_DEC_USE_COUNT;
 231                 return -EBUSY;
 232         }
 233
 234         cinfo->capi_ctrl = di->attach_ctr(driver, card->name, cinfo);
 235         if (!cinfo->capi_ctrl) {
 236                 printk(KERN_ERR "%s: attach controller failed.\n", driver->name);
 237                 iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
 238                 free_irq(card->irq, card);
 239                 release_region(card->port, AVMB1_PORTLEN);
 240                 kfree(card->ctrlinfo);
 241                 kfree(card->dma);
 242                 kfree(card);
 243                 MOD_DEC_USE_COUNT;
 244                 return -EBUSY;
 245         }
 246         card->cardnr = cinfo->capi_ctrl->cnr;
 247
 248         skb_queue_head_init(&card->dma->send_queue);
 249
 250         printk(KERN_INFO
 251                 "%s: AVM T1 PCI at i/o %#x, irq %d, mem %#lx\n",
 252                 driver->name, card->port, card->irq, card->membase);
 253
 254         return 0;
 255 }
 256
 257 /* ------------------------------------------------------------- */
 258
 259 static char *t1pci_procinfo(struct capi_ctr *ctrl)
 260 {
 261         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 262
 263         if (!cinfo)
 264                 return "";
 265         sprintf(cinfo->infobuf, "%s %s 0x%x %d 0x%lx",
 266                 cinfo->cardname[0] ? cinfo->cardname : "-",
 267                 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
 268                 cinfo->card ? cinfo->card->port : 0x0,
 269                 cinfo->card ? cinfo->card->irq : 0,
 270                 cinfo->card ? cinfo->card->membase : 0
 271                 );
 272         return cinfo->infobuf;
 273 }
 274
 275 /* ------------------------------------------------------------- */
 276
 277 static struct capi_driver t1pci_driver = {
 278     name: "t1pci",
 279     revision: "0.0",
 280     load_firmware: b1dma_load_firmware,
 281     reset_ctr: b1dma_reset_ctr,
 282     remove_ctr: t1pci_remove_ctr,
 283     register_appl: b1dma_register_appl,
 284     release_appl: b1dma_release_appl,
 285     send_message: b1dma_send_message,
 286
 287     procinfo: t1pci_procinfo,
 288     ctr_read_proc: b1dmactl_read_proc,
 289     driver_read_proc: 0,        /* use standard driver_read_proc */
 290
 291     add_card: 0, /* no add_card function */
 292 };
 293
 294 static int ncards = 0;
 295
 296 static int __init t1pci_init(void)
 297 {
 298         struct capi_driver *driver = &t1pci_driver;
 299         struct pci_dev *dev = NULL;
 300         char *p;
 301         int retval;
 302
 303         MOD_INC_USE_COUNT;
 304
 305         if ((p = strchr(revision, ':'))) {
 306                 strncpy(driver->revision, p + 1, sizeof(driver->revision));
 307                 p = strchr(driver->revision, '$');
 308                 *p = 0;
 309         }
 310
 311         printk(KERN_INFO "%s: revision %s\n", driver->name, driver->revision);
 312
 313         di = attach_capi_driver(driver);
 314
 315         if (!di) {
 316                 printk(KERN_ERR "%s: failed to attach capi_driver\n",
 317                                 driver->name);
 318                 MOD_DEC_USE_COUNT;
 319                 return -EIO;
 320         }
 321
 322 #ifdef CONFIG_PCI
 323         if (!pci_present()) {
 324                 printk(KERN_ERR "%s: no PCI bus present\n", driver->name);
 325                 detach_capi_driver(driver);
 326                 MOD_DEC_USE_COUNT;
 327                 return -EIO;
 328         }
 329
 330         while ((dev = pci_find_device(PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_T1, dev))) {
 331                 struct capicardparams param;
 332
 333                 param.port = pci_resource_start(dev, 1);
 334                 param.irq = dev->irq;
 335                 param.membase = pci_resource_start(dev, 0);
 336
 337                 retval = pci_enable_device (dev);
 338                 if (retval != 0) {
 339                         printk(KERN_ERR
 340                         "%s: failed to enable AVM-T1-PCI at i/o %#x, irq %d, mem %#x err=%d\n",
 341                         driver->name, param.port, param.irq, param.membase, retval);
 342                         detach_capi_driver(&t1pci_driver);
 343                         MOD_DEC_USE_COUNT;
 344                         return -EIO;
 345                 }
 346
 347                 printk(KERN_INFO
 348                         "%s: PCI BIOS reports AVM-T1-PCI at i/o %#x, irq %d, mem %#x\n",
 349                         driver->name, param.port, param.irq, param.membase);
 350                 retval = t1pci_add_card(driver, &param);
 351                 if (retval != 0) {
 352                         printk(KERN_ERR
 353                         "%s: no AVM-T1-PCI at i/o %#x, irq %d detected, mem %#x\n",
 354                         driver->name, param.port, param.irq, param.membase);
 355                         detach_capi_driver(&t1pci_driver);
 356                         MOD_DEC_USE_COUNT;
 357                         return retval;
 358                 }
 359                 ncards++;
 360         }
 361         if (ncards) {
 362                 printk(KERN_INFO "%s: %d T1-PCI card(s) detected\n",
 363                                 driver->name, ncards);
 364                 MOD_DEC_USE_COUNT;
 365                 return 0;
 366         }
 367         printk(KERN_ERR "%s: NO T1-PCI card detected\n", driver->name);
 368         detach_capi_driver(&t1pci_driver);
 369         MOD_DEC_USE_COUNT;
 370         return -ESRCH;
 371 #else
 372         printk(KERN_ERR "%s: kernel not compiled with PCI.\n", driver->name);
 373         MOD_DEC_USE_COUNT;
 374         return -EIO;
 375 #endif
 376 }
 377
 378 static void __exit t1pci_exit(void)
 379 {
 380     detach_capi_driver(&t1pci_driver);
 381 }
 382
 383 module_init(t1pci_init);
 384 module_exit(t1pci_exit);