drivers/isdn/avmb1/b1pci.c

   1 /* $Id: b1pci.c,v 1.1.4.1 2001/11/20 14:19:34 kai Exp $
   2  *
   3  * Module for AVM B1 PCI-card.
   4  *
   5  * Copyright 1999 by Carsten Paeth <calle@calle.de>
   6  *
   7  * This software may be used and distributed according to the terms
   8  * of the GNU General Public License, incorporated herein by reference.
   9  *
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/skbuff.h>
  16 #include <linux/delay.h>
  17 #include <linux/mm.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/ioport.h>
  20 #include <linux/pci.h>
  21 #include <linux/capi.h>
  22 #include <asm/io.h>
  23 #include <linux/init.h>
  24 #include "capicmd.h"
  25 #include "capiutil.h"
  26 #include "capilli.h"
  27 #include "avmcard.h"
  28
  29 static char *revision = "$Revision: 1.1.4.1 $";
  30
  31 /* ------------------------------------------------------------- */
  32
  33 static struct pci_device_id b1pci_pci_tbl[] __initdata = {
  34         { PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_B1, PCI_ANY_ID, PCI_ANY_ID },
  35         { }                             /* Terminating entry */
  36 };
  37
  38 MODULE_DEVICE_TABLE(pci, b1pci_pci_tbl);
  39 MODULE_DESCRIPTION("CAPI4Linux: Driver for AVM B1 PCI card");
  40 MODULE_AUTHOR("Carsten Paeth");
  41 MODULE_LICENSE("GPL");
  42
  43 /* ------------------------------------------------------------- */
  44
  45 static struct capi_driver_interface *di;
  46
  47 /* ------------------------------------------------------------- */
  48
  49 static void b1pci_interrupt(int interrupt, void *devptr, struct pt_regs *regs)
  50 {
  51         avmcard *card;
  52
  53         card = (avmcard *) devptr;
  54
  55         if (!card) {
  56                 printk(KERN_WARNING "b1pci: interrupt: wrong device\n");
  57                 return;
  58         }
  59         if (card->interrupt) {
  60                 printk(KERN_ERR "%s: reentering interrupt hander.\n", card->name);
  61                 return;
  62         }
  63
  64         card->interrupt = 1;
  65
  66         b1_handle_interrupt(card);
  67
  68         card->interrupt = 0;
  69 }
  70 /* ------------------------------------------------------------- */
  71
  72 static void b1pci_remove_ctr(struct capi_ctr *ctrl)
  73 {
  74         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
  75         avmcard *card = cinfo->card;
  76         unsigned int port = card->port;
  77
  78         b1_reset(port);
  79         b1_reset(port);
  80
  81         di->detach_ctr(ctrl);
  82         free_irq(card->irq, card);
  83         release_region(card->port, AVMB1_PORTLEN);
  84         ctrl->driverdata = 0;
  85         kfree(card->ctrlinfo);
  86         kfree(card);
  87
  88         MOD_DEC_USE_COUNT;
  89 }
  90
  91 /* ------------------------------------------------------------- */
  92
  93 static char *b1pci_procinfo(struct capi_ctr *ctrl)
  94 {
  95         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
  96
  97         if (!cinfo)
  98                 return "";
  99         sprintf(cinfo->infobuf, "%s %s 0x%x %d r%d",
 100                 cinfo->cardname[0] ? cinfo->cardname : "-",
 101                 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
 102                 cinfo->card ? cinfo->card->port : 0x0,
 103                 cinfo->card ? cinfo->card->irq : 0,
 104                 cinfo->card ? cinfo->card->revision : 0
 105                 );
 106         return cinfo->infobuf;
 107 }
 108
 109 /* ------------------------------------------------------------- */
 110
 111 static int b1pci_add_card(struct capi_driver *driver, struct capicardparams *p)
 112 {
 113         avmcard *card;
 114         avmctrl_info *cinfo;
 115         int retval;
 116
 117         MOD_INC_USE_COUNT;
 118
 119         card = (avmcard *) kmalloc(sizeof(avmcard), GFP_ATOMIC);
 120
 121         if (!card) {
 122                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 123                 MOD_DEC_USE_COUNT;
 124                 return -ENOMEM;
 125         }
 126         memset(card, 0, sizeof(avmcard));
 127         cinfo = (avmctrl_info *) kmalloc(sizeof(avmctrl_info), GFP_ATOMIC);
 128         if (!cinfo) {
 129                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 130                 kfree(card);
 131                 MOD_DEC_USE_COUNT;
 132                 return -ENOMEM;
 133         }
 134         memset(cinfo, 0, sizeof(avmctrl_info));
 135         card->ctrlinfo = cinfo;
 136         cinfo->card = card;
 137         sprintf(card->name, "b1pci-%x", p->port);
 138         card->port = p->port;
 139         card->irq = p->irq;
 140         card->cardtype = avm_b1pci;
 141
 142         if (check_region(card->port, AVMB1_PORTLEN)) {
 143                 printk(KERN_WARNING
 144                        "%s: ports 0x%03x-0x%03x in use.\n",
 145                        driver->name, card->port, card->port + AVMB1_PORTLEN);
 146                 kfree(card->ctrlinfo);
 147                 kfree(card);
 148                 MOD_DEC_USE_COUNT;
 149                 return -EBUSY;
 150         }
 151         b1_reset(card->port);
 152         if ((retval = b1_detect(card->port, card->cardtype)) != 0) {
 153                 printk(KERN_NOTICE "%s: NO card at 0x%x (%d)\n",
 154                                         driver->name, card->port, retval);
 155                 kfree(card->ctrlinfo);
 156                 kfree(card);
 157                 MOD_DEC_USE_COUNT;
 158                 return -EIO;
 159         }
 160         b1_reset(card->port);
 161         b1_getrevision(card);
 162
 163         request_region(p->port, AVMB1_PORTLEN, card->name);
 164
 165         retval = request_irq(card->irq, b1pci_interrupt, SA_SHIRQ, card->name, card);
 166         if (retval) {
 167                 printk(KERN_ERR "%s: unable to get IRQ %d.\n",
 168                                 driver->name, card->irq);
 169                 release_region(card->port, AVMB1_PORTLEN);
 170                 kfree(card->ctrlinfo);
 171                 kfree(card);
 172                 MOD_DEC_USE_COUNT;
 173                 return -EBUSY;
 174         }
 175
 176         cinfo->capi_ctrl = di->attach_ctr(driver, card->name, cinfo);
 177         if (!cinfo->capi_ctrl) {
 178                 printk(KERN_ERR "%s: attach controller failed.\n",
 179                                 driver->name);
 180                 free_irq(card->irq, card);
 181                 release_region(card->port, AVMB1_PORTLEN);
 182                 kfree(card->ctrlinfo);
 183                 kfree(card);
 184                 MOD_DEC_USE_COUNT;
 185                 return -EBUSY;
 186         }
 187
 188         if (card->revision >= 4) {
 189                 printk(KERN_INFO
 190                         "%s: AVM B1 PCI V4 at i/o %#x, irq %d, revision %d (no dma)\n",
 191                         driver->name, card->port, card->irq, card->revision);
 192         } else {
 193                 printk(KERN_INFO
 194                         "%s: AVM B1 PCI at i/o %#x, irq %d, revision %d\n",
 195                         driver->name, card->port, card->irq, card->revision);
 196         }
 197
 198         return 0;
 199 }
 200
 201 /* ------------------------------------------------------------- */
 202
 203 static struct capi_driver b1pci_driver = {
 204     name: "b1pci",
 205     revision: "0.0",
 206     load_firmware: b1_load_firmware,
 207     reset_ctr: b1_reset_ctr,
 208     remove_ctr: b1pci_remove_ctr,
 209     register_appl: b1_register_appl,
 210     release_appl: b1_release_appl,
 211     send_message: b1_send_message,
 212
 213     procinfo: b1pci_procinfo,
 214     ctr_read_proc: b1ctl_read_proc,
 215     driver_read_proc: 0,        /* use standard driver_read_proc */
 216
 217     add_card: 0, /* no add_card function */
 218 };
 219
 220 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 221 /* ------------------------------------------------------------- */
 222
 223 static struct capi_driver_interface *div4;
 224
 225 /* ------------------------------------------------------------- */
 226
 227 static void b1pciv4_remove_ctr(struct capi_ctr *ctrl)
 228 {
 229         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 230         avmcard *card = cinfo->card;
 231
 232         b1dma_reset(card);
 233
 234         div4->detach_ctr(ctrl);
 235         free_irq(card->irq, card);
 236         iounmap(card->mbase);
 237         release_region(card->port, AVMB1_PORTLEN);
 238         ctrl->driverdata = 0;
 239         kfree(card->ctrlinfo);
 240         kfree(card->dma);
 241         kfree(card);
 242
 243         MOD_DEC_USE_COUNT;
 244 }
 245
 246 static char *b1pciv4_procinfo(struct capi_ctr *ctrl)
 247 {
 248         avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
 249
 250         if (!cinfo)
 251                 return "";
 252         sprintf(cinfo->infobuf, "%s %s 0x%x %d 0x%lx r%d",
 253                 cinfo->cardname[0] ? cinfo->cardname : "-",
 254                 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
 255                 cinfo->card ? cinfo->card->port : 0x0,
 256                 cinfo->card ? cinfo->card->irq : 0,
 257                 cinfo->card ? cinfo->card->membase : 0,
 258                 cinfo->card ? cinfo->card->revision : 0
 259                 );
 260         return cinfo->infobuf;
 261 }
 262
 263 /* ------------------------------------------------------------- */
 264
 265 static int b1pciv4_add_card(struct capi_driver *driver, struct capicardparams *p)
 266 {
 267         avmcard *card;
 268         avmctrl_info *cinfo;
 269         int retval;
 270
 271         MOD_INC_USE_COUNT;
 272
 273         card = (avmcard *) kmalloc(sizeof(avmcard), GFP_ATOMIC);
 274
 275         if (!card) {
 276                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 277                 MOD_DEC_USE_COUNT;
 278                 return -ENOMEM;
 279         }
 280         memset(card, 0, sizeof(avmcard));
 281         card->dma = (avmcard_dmainfo *) kmalloc(sizeof(avmcard_dmainfo), GFP_ATOMIC);
 282         if (!card->dma) {
 283                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 284                 kfree(card);
 285                 MOD_DEC_USE_COUNT;
 286                 return -ENOMEM;
 287         }
 288         memset(card->dma, 0, sizeof(avmcard_dmainfo));
 289         cinfo = (avmctrl_info *) kmalloc(sizeof(avmctrl_info), GFP_ATOMIC);
 290         if (!cinfo) {
 291                 printk(KERN_WARNING "%s: no memory.\n", driver->name);
 292                 kfree(card->dma);
 293                 kfree(card);
 294                 MOD_DEC_USE_COUNT;
 295                 return -ENOMEM;
 296         }
 297         memset(cinfo, 0, sizeof(avmctrl_info));
 298         card->ctrlinfo = cinfo;
 299         cinfo->card = card;
 300         sprintf(card->name, "b1pciv4-%x", p->port);
 301         card->port = p->port;
 302         card->irq = p->irq;
 303         card->membase = p->membase;
 304         card->cardtype = avm_b1pci;
 305
 306         if (check_region(card->port, AVMB1_PORTLEN)) {
 307                 printk(KERN_WARNING
 308                        "%s: ports 0x%03x-0x%03x in use.\n",
 309                        driver->name, card->port, card->port + AVMB1_PORTLEN);
 310                 kfree(card->ctrlinfo);
 311                 kfree(card->dma);
 312                 kfree(card);
 313                 MOD_DEC_USE_COUNT;
 314                 return -EBUSY;
 315         }
 316
 317         card->mbase = ioremap_nocache(card->membase, 64);
 318         if (!card->mbase) {
 319                 printk(KERN_NOTICE "%s: can't remap memory at 0x%lx\n",
 320                                         driver->name, card->membase);
 321                 kfree(card->ctrlinfo);
 322                 kfree(card->dma);
 323                 kfree(card);
 324                 MOD_DEC_USE_COUNT;
 325                 return -EIO;
 326         }
 327
 328         b1dma_reset(card);
 329
 330         if ((retval = b1pciv4_detect(card)) != 0) {
 331                 printk(KERN_NOTICE "%s: NO card at 0x%x (%d)\n",
 332                                         driver->name, card->port, retval);
 333                 iounmap(card->mbase);
 334                 kfree(card->ctrlinfo);
 335                 kfree(card->dma);
 336                 kfree(card);
 337                 MOD_DEC_USE_COUNT;
 338                 return -EIO;
 339         }
 340         b1dma_reset(card);
 341         b1_getrevision(card);
 342
 343         request_region(p->port, AVMB1_PORTLEN, card->name);
 344
 345         retval = request_irq(card->irq, b1dma_interrupt, SA_SHIRQ, card->name, card);
 346         if (retval) {
 347                 printk(KERN_ERR "%s: unable to get IRQ %d.\n",
 348                                 driver->name, card->irq);
 349                 iounmap(card->mbase);
 350                 release_region(card->port, AVMB1_PORTLEN);
 351                 kfree(card->ctrlinfo);
 352                 kfree(card->dma);
 353                 kfree(card);
 354                 MOD_DEC_USE_COUNT;
 355                 return -EBUSY;
 356         }
 357
 358         cinfo->capi_ctrl = div4->attach_ctr(driver, card->name, cinfo);
 359         if (!cinfo->capi_ctrl) {
 360                 printk(KERN_ERR "%s: attach controller failed.\n", driver->name);
 361                 iounmap(card->mbase);
 362                 free_irq(card->irq, card);
 363                 release_region(card->port, AVMB1_PORTLEN);
 364                 kfree(card->ctrlinfo);
 365                 kfree(card->dma);
 366                 kfree(card);
 367                 MOD_DEC_USE_COUNT;
 368                 return -EBUSY;
 369         }
 370         card->cardnr = cinfo->capi_ctrl->cnr;
 371
 372         skb_queue_head_init(&card->dma->send_queue);
 373
 374         printk(KERN_INFO
 375                 "%s: AVM B1 PCI V4 at i/o %#x, irq %d, mem %#lx, revision %d (dma)\n",
 376                 driver->name, card->port, card->irq,
 377                 card->membase, card->revision);
 378
 379         return 0;
 380 }
 381
 382 /* ------------------------------------------------------------- */
 383
 384
 385 static struct capi_driver b1pciv4_driver = {
 386     name: "b1pciv4",
 387     revision: "0.0",
 388     load_firmware: b1dma_load_firmware,
 389     reset_ctr: b1dma_reset_ctr,
 390     remove_ctr: b1pciv4_remove_ctr,
 391     register_appl: b1dma_register_appl,
 392     release_appl: b1dma_release_appl,
 393     send_message: b1dma_send_message,
 394
 395     procinfo: b1pciv4_procinfo,
 396     ctr_read_proc: b1dmactl_read_proc,
 397     driver_read_proc: 0,        /* use standard driver_read_proc */
 398
 399     add_card: 0, /* no add_card function */
 400 };
 401
 402 #endif /* CONFIG_ISDN_DRV_AVMB1_B1PCIV4 */
 403
 404 static int ncards = 0;
 405
 406 static int add_card(struct pci_dev *dev)
 407 {
 408         struct capi_driver *driver = &b1pci_driver;
 409         struct capicardparams param;
 410         int retval;
 411
 412         if (pci_enable_device(dev) < 0) {
 413                 printk(KERN_ERR "%s: failed to enable AVM-B1\n",
 414                        driver->name);
 415                 return -ENODEV;
 416         }
 417         param.irq = dev->irq;
 418
 419         if (pci_resource_start(dev, 2)) { /* B1 PCI V4 */
 420 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 421                 driver = &b1pciv4_driver;
 422
 423                 pci_set_master(dev);
 424 #endif
 425                 param.membase = pci_resource_start(dev, 0);
 426                 param.port = pci_resource_start(dev, 2);
 427
 428                 printk(KERN_INFO
 429                 "%s: PCI BIOS reports AVM-B1 V4 at i/o %#x, irq %d, mem %#x\n",
 430                 driver->name, param.port, param.irq, param.membase);
 431 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 432                 retval = b1pciv4_add_card(driver, &param);
 433 #else
 434                 retval = b1pci_add_card(driver, &param);
 435 #endif
 436                 if (retval != 0) {
 437                         printk(KERN_ERR
 438                         "%s: no AVM-B1 V4 at i/o %#x, irq %d, mem %#x detected\n",
 439                         driver->name, param.port, param.irq, param.membase);
 440                 }
 441         } else {
 442                 param.membase = 0;
 443                 param.port = pci_resource_start(dev, 1);
 444
 445                 printk(KERN_INFO
 446                 "%s: PCI BIOS reports AVM-B1 at i/o %#x, irq %d\n",
 447                 driver->name, param.port, param.irq);
 448                 retval = b1pci_add_card(driver, &param);
 449                 if (retval != 0) {
 450                         printk(KERN_ERR
 451                         "%s: no AVM-B1 at i/o %#x, irq %d detected\n",
 452                         driver->name, param.port, param.irq);
 453                 }
 454         }
 455         return retval;
 456 }
 457
 458 static int __init b1pci_init(void)
 459 {
 460         struct capi_driver *driver = &b1pci_driver;
 461 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 462         struct capi_driver *driverv4 = &b1pciv4_driver;
 463 #endif
 464         struct pci_dev *dev = NULL;
 465         char *p;
 466
 467         MOD_INC_USE_COUNT;
 468
 469         if ((p = strchr(revision, ':')) != 0 && p[1]) {
 470                 strncpy(driver->revision, p + 2, sizeof(driver->revision));
 471                 driver->revision[sizeof(driver->revision)-1] = 0;
 472                 if ((p = strchr(driver->revision, '$')) != 0 && p > driver->revision)
 473                         *(p-1) = 0;
 474         }
 475 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 476         if ((p = strchr(revision, ':')) != 0 && p[1]) {
 477                 strncpy(driverv4->revision, p + 2, sizeof(driverv4->revision));
 478                 driverv4->revision[sizeof(driverv4->revision)-1] = 0;
 479                 if ((p = strchr(driverv4->revision, '$')) != 0 && p > driverv4->revision)
 480                         *(p-1) = 0;
 481         }
 482 #endif
 483
 484         printk(KERN_INFO "%s: revision %s\n", driver->name, driver->revision);
 485
 486         di = attach_capi_driver(driver);
 487         if (!di) {
 488                 printk(KERN_ERR "%s: failed to attach capi_driver\n",
 489                                 driver->name);
 490                 MOD_DEC_USE_COUNT;
 491                 return -ENODEV;
 492         }
 493
 494 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 495         printk(KERN_INFO "%s: revision %s\n", driverv4->name, driverv4->revision);
 496
 497         div4 = attach_capi_driver(driverv4);
 498         if (!div4) {
 499                 detach_capi_driver(driver);
 500                 printk(KERN_ERR "%s: failed to attach capi_driver\n",
 501                                 driverv4->name);
 502                 MOD_DEC_USE_COUNT;
 503                 return -ENODEV;
 504         }
 505 #endif
 506
 507         while ((dev = pci_find_device(PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_B1, dev))) {
 508                 if (add_card(dev) == 0)
 509                         ncards++;
 510         }
 511         if (ncards) {
 512                 printk(KERN_INFO "%s: %d B1-PCI card(s) detected\n",
 513                                 driver->name, ncards);
 514                 MOD_DEC_USE_COUNT;
 515                 return 0;
 516         }
 517         printk(KERN_ERR "%s: NO B1-PCI card detected\n", driver->name);
 518         detach_capi_driver(driver);
 519 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 520         detach_capi_driver(driverv4);
 521 #endif
 522         MOD_DEC_USE_COUNT;
 523         return -ENODEV;
 524 }
 525
 526 static void __exit b1pci_exit(void)
 527 {
 528     detach_capi_driver(&b1pci_driver);
 529 #ifdef CONFIG_ISDN_DRV_AVMB1_B1PCIV4
 530     detach_capi_driver(&b1pciv4_driver);
 531 #endif
 532 }
 533
 534 module_init(b1pci_init);
 535 module_exit(b1pci_exit);