drivers/isdn/hardware/mISDN/speedfax.c

   1 /*
   2  * speedfax.c   low level stuff for Sedlbauer Speedfax+ cards
   3  *              based on the ISAR DSP
   4  *              Thanks to Sedlbauer AG for informations and HW
   5  *
   6  * Author       Karsten Keil <keil@isdn4linux.de>
   7  *
   8  * Copyright 2009  by Karsten Keil <keil@isdn4linux.de>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24
  25 #include <linux/interrupt.h>
  26 #include <linux/module.h>
  27 #include <linux/slab.h>
  28 #include <linux/pci.h>
  29 #include <linux/delay.h>
  30 #include <linux/mISDNhw.h>
  31 #include <linux/firmware.h>
  32 #include "ipac.h"
  33 #include "isar.h"
  34
  35 #define SPEEDFAX_REV    "2.0"
  36
  37 #define PCI_SUBVENDOR_SPEEDFAX_PYRAMID  0x51
  38 #define PCI_SUBVENDOR_SPEEDFAX_PCI      0x54
  39 #define PCI_SUB_ID_SEDLBAUER            0x01
  40
  41 #define SFAX_PCI_ADDR           0xc8
  42 #define SFAX_PCI_ISAC           0xd0
  43 #define SFAX_PCI_ISAR           0xe0
  44
  45 /* TIGER 100 Registers */
  46
  47 #define TIGER_RESET_ADDR        0x00
  48 #define TIGER_EXTERN_RESET_ON   0x01
  49 #define TIGER_EXTERN_RESET_OFF  0x00
  50 #define TIGER_AUX_CTRL          0x02
  51 #define TIGER_AUX_DATA          0x03
  52 #define TIGER_AUX_IRQMASK       0x05
  53 #define TIGER_AUX_STATUS        0x07
  54
  55 /* Tiger AUX BITs */
  56 #define SFAX_AUX_IOMASK         0xdd    /* 1 and 5 are inputs */
  57 #define SFAX_ISAR_RESET_BIT_OFF 0x00
  58 #define SFAX_ISAR_RESET_BIT_ON  0x01
  59 #define SFAX_TIGER_IRQ_BIT      0x02
  60 #define SFAX_LED1_BIT           0x08
  61 #define SFAX_LED2_BIT           0x10
  62
  63 #define SFAX_PCI_RESET_ON       (SFAX_ISAR_RESET_BIT_ON)
  64 #define SFAX_PCI_RESET_OFF      (SFAX_LED1_BIT | SFAX_LED2_BIT)
  65
  66 static int sfax_cnt;
  67 static u32 debug;
  68 static u32 irqloops = 4;
  69
  70 struct sfax_hw {
  71         struct list_head        list;
  72         struct pci_dev          *pdev;
  73         char                    name[MISDN_MAX_IDLEN];
  74         u32                     irq;
  75         u32                     irqcnt;
  76         u32                     cfg;
  77         struct _ioport          p_isac;
  78         struct _ioport          p_isar;
  79         u8                      aux_data;
  80         spinlock_t              lock;   /* HW access lock */
  81         struct isac_hw          isac;
  82         struct isar_hw          isar;
  83 };
  84
  85 static LIST_HEAD(Cards);
  86 static DEFINE_RWLOCK(card_lock); /* protect Cards */
  87
  88 static void
  89 _set_debug(struct sfax_hw *card)
  90 {
  91         card->isac.dch.debug = debug;
  92         card->isar.ch[0].bch.debug = debug;
  93         card->isar.ch[1].bch.debug = debug;
  94 }
  95
  96 static int
  97 set_debug(const char *val, struct kernel_param *kp)
  98 {
  99         int ret;
 100         struct sfax_hw *card;
 101
 102         ret = param_set_uint(val, kp);
 103         if (!ret) {
 104                 read_lock(&card_lock);
 105                 list_for_each_entry(card, &Cards, list)
 106                         _set_debug(card);
 107                 read_unlock(&card_lock);
 108         }
 109         return ret;
 110 }
 111
 112 MODULE_AUTHOR("Karsten Keil");
 113 MODULE_LICENSE("GPL v2");
 114 MODULE_VERSION(SPEEDFAX_REV);
 115 MODULE_FIRMWARE("isdn/ISAR.BIN");
 116 module_param_call(debug, set_debug, param_get_uint, &debug, S_IRUGO | S_IWUSR);
 117 MODULE_PARM_DESC(debug, "Speedfax debug mask");
 118 module_param(irqloops, uint, S_IRUGO | S_IWUSR);
 119 MODULE_PARM_DESC(irqloops, "Speedfax maximal irqloops (default 4)");
 120
 121 IOFUNC_IND(ISAC, sfax_hw, p_isac)
 122 IOFUNC_IND(ISAR, sfax_hw, p_isar)
 123
 124 static irqreturn_t
 125 speedfax_irq(int intno, void *dev_id)
 126 {
 127         struct sfax_hw  *sf = dev_id;
 128         u8 val;
 129         int cnt = irqloops;
 130
 131         spin_lock(&sf->lock);
 132         val = inb(sf->cfg + TIGER_AUX_STATUS);
 133         if (val & SFAX_TIGER_IRQ_BIT) { /* for us or shared ? */
 134                 spin_unlock(&sf->lock);
 135                 return IRQ_NONE; /* shared */
 136         }
 137         sf->irqcnt++;
 138         val = ReadISAR_IND(sf, ISAR_IRQBIT);
 139 Start_ISAR:
 140         if (val & ISAR_IRQSTA)
 141                 mISDNisar_irq(&sf->isar);
 142         val = ReadISAC_IND(sf, ISAC_ISTA);
 143         if (val)
 144                 mISDNisac_irq(&sf->isac, val);
 145         val = ReadISAR_IND(sf, ISAR_IRQBIT);
 146         if ((val & ISAR_IRQSTA) && cnt--)
 147                 goto Start_ISAR;
 148         if (cnt < irqloops)
 149                 pr_debug("%s: %d irqloops cpu%d\n", sf->name,
 150                          irqloops - cnt, smp_processor_id());
 151         if (irqloops && !cnt)
 152                 pr_notice("%s: %d IRQ LOOP cpu%d\n", sf->name,
 153                           irqloops, smp_processor_id());
 154         spin_unlock(&sf->lock);
 155         return IRQ_HANDLED;
 156 }
 157
 158 static void
 159 enable_hwirq(struct sfax_hw *sf)
 160 {
 161         WriteISAC_IND(sf, ISAC_MASK, 0);
 162         WriteISAR_IND(sf, ISAR_IRQBIT, ISAR_IRQMSK);
 163         outb(SFAX_TIGER_IRQ_BIT, sf->cfg + TIGER_AUX_IRQMASK);
 164 }
 165
 166 static void
 167 disable_hwirq(struct sfax_hw *sf)
 168 {
 169         WriteISAC_IND(sf, ISAC_MASK, 0xFF);
 170         WriteISAR_IND(sf, ISAR_IRQBIT, 0);
 171         outb(0, sf->cfg + TIGER_AUX_IRQMASK);
 172 }
 173
 174 static void
 175 reset_speedfax(struct sfax_hw *sf)
 176 {
 177
 178         pr_debug("%s: resetting card\n", sf->name);
 179         outb(TIGER_EXTERN_RESET_ON, sf->cfg + TIGER_RESET_ADDR);
 180         outb(SFAX_PCI_RESET_ON, sf->cfg + TIGER_AUX_DATA);
 181         mdelay(1);
 182         outb(TIGER_EXTERN_RESET_OFF, sf->cfg + TIGER_RESET_ADDR);
 183         sf->aux_data = SFAX_PCI_RESET_OFF;
 184         outb(sf->aux_data, sf->cfg + TIGER_AUX_DATA);
 185         mdelay(1);
 186 }
 187
 188 static int
 189 sfax_ctrl(struct sfax_hw  *sf, u32 cmd, u_long arg)
 190 {
 191         int ret = 0;
 192
 193         switch (cmd) {
 194         case HW_RESET_REQ:
 195                 reset_speedfax(sf);
 196                 break;
 197         case HW_ACTIVATE_IND:
 198                 if (arg & 1)
 199                         sf->aux_data &= ~SFAX_LED1_BIT;
 200                 if (arg & 2)
 201                         sf->aux_data &= ~SFAX_LED2_BIT;
 202                 outb(sf->aux_data, sf->cfg + TIGER_AUX_DATA);
 203                 break;
 204         case HW_DEACT_IND:
 205                 if (arg & 1)
 206                         sf->aux_data |= SFAX_LED1_BIT;
 207                 if (arg & 2)
 208                         sf->aux_data |= SFAX_LED2_BIT;
 209                 outb(sf->aux_data, sf->cfg + TIGER_AUX_DATA);
 210                 break;
 211         default:
 212                 pr_info("%s: %s unknown command %x %lx\n",
 213                         sf->name, __func__, cmd, arg);
 214                 ret = -EINVAL;
 215                 break;
 216         }
 217         return ret;
 218 }
 219
 220 static int
 221 channel_ctrl(struct sfax_hw  *sf, struct mISDN_ctrl_req *cq)
 222 {
 223         int     ret = 0;
 224
 225         switch (cq->op) {
 226         case MISDN_CTRL_GETOP:
 227                 cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_L1_TIMER3;
 228                 break;
 229         case MISDN_CTRL_LOOP:
 230                 /* cq->channel: 0 disable, 1 B1 loop 2 B2 loop, 3 both */
 231                 if (cq->channel < 0 || cq->channel > 3) {
 232                         ret = -EINVAL;
 233                         break;
 234                 }
 235                 ret = sf->isac.ctrl(&sf->isac, HW_TESTLOOP, cq->channel);
 236                 break;
 237         case MISDN_CTRL_L1_TIMER3:
 238                 ret = sf->isac.ctrl(&sf->isac, HW_TIMER3_VALUE, cq->p1);
 239                 break;
 240         default:
 241                 pr_info("%s: unknown Op %x\n", sf->name, cq->op);
 242                 ret = -EINVAL;
 243                 break;
 244         }
 245         return ret;
 246 }
 247
 248 static int
 249 sfax_dctrl(struct mISDNchannel *ch, u32 cmd, void *arg)
 250 {
 251         struct mISDNdevice      *dev = container_of(ch, struct mISDNdevice, D);
 252         struct dchannel         *dch = container_of(dev, struct dchannel, dev);
 253         struct sfax_hw          *sf = dch->hw;
 254         struct channel_req      *rq;
 255         int                     err = 0;
 256
 257         pr_debug("%s: cmd:%x %p\n", sf->name, cmd, arg);
 258         switch (cmd) {
 259         case OPEN_CHANNEL:
 260                 rq = arg;
 261                 if (rq->protocol == ISDN_P_TE_S0)
 262                         err = sf->isac.open(&sf->isac, rq);
 263                 else
 264                         err = sf->isar.open(&sf->isar, rq);
 265                 if (err)
 266                         break;
 267                 if (!try_module_get(THIS_MODULE))
 268                         pr_info("%s: cannot get module\n", sf->name);
 269                 break;
 270         case CLOSE_CHANNEL:
 271                 pr_debug("%s: dev(%d) close from %p\n", sf->name,
 272                          dch->dev.id, __builtin_return_address(0));
 273                 module_put(THIS_MODULE);
 274                 break;
 275         case CONTROL_CHANNEL:
 276                 err = channel_ctrl(sf, arg);
 277                 break;
 278         default:
 279                 pr_debug("%s: unknown command %x\n", sf->name, cmd);
 280                 return -EINVAL;
 281         }
 282         return err;
 283 }
 284
 285 static int
 286 init_card(struct sfax_hw *sf)
 287 {
 288         int     ret, cnt = 3;
 289         u_long  flags;
 290
 291         ret = request_irq(sf->irq, speedfax_irq, IRQF_SHARED, sf->name, sf);
 292         if (ret) {
 293                 pr_info("%s: couldn't get interrupt %d\n", sf->name, sf->irq);
 294                 return ret;
 295         }
 296         while (cnt--) {
 297                 spin_lock_irqsave(&sf->lock, flags);
 298                 ret = sf->isac.init(&sf->isac);
 299                 if (ret) {
 300                         spin_unlock_irqrestore(&sf->lock, flags);
 301                         pr_info("%s: ISAC init failed with %d\n",
 302                                 sf->name, ret);
 303                         break;
 304                 }
 305                 enable_hwirq(sf);
 306                 /* RESET Receiver and Transmitter */
 307                 WriteISAC_IND(sf, ISAC_CMDR, 0x41);
 308                 spin_unlock_irqrestore(&sf->lock, flags);
 309                 msleep_interruptible(10);
 310                 if (debug & DEBUG_HW)
 311                         pr_notice("%s: IRQ %d count %d\n", sf->name,
 312                                   sf->irq, sf->irqcnt);
 313                 if (!sf->irqcnt) {
 314                         pr_info("%s: IRQ(%d) got no requests during init %d\n",
 315                                 sf->name, sf->irq, 3 - cnt);
 316                 } else
 317                         return 0;
 318         }
 319         free_irq(sf->irq, sf);
 320         return -EIO;
 321 }
 322
 323
 324 static int
 325 setup_speedfax(struct sfax_hw *sf)
 326 {
 327         u_long flags;
 328
 329         if (!request_region(sf->cfg, 256, sf->name)) {
 330                 pr_info("mISDN: %s config port %x-%x already in use\n",
 331                         sf->name, sf->cfg, sf->cfg + 255);
 332                 return -EIO;
 333         }
 334         outb(0xff, sf->cfg);
 335         outb(0, sf->cfg);
 336         outb(0xdd, sf->cfg + TIGER_AUX_CTRL);
 337         outb(0, sf->cfg + TIGER_AUX_IRQMASK);
 338
 339         sf->isac.type = IPAC_TYPE_ISAC;
 340         sf->p_isac.ale = sf->cfg + SFAX_PCI_ADDR;
 341         sf->p_isac.port = sf->cfg + SFAX_PCI_ISAC;
 342         sf->p_isar.ale = sf->cfg + SFAX_PCI_ADDR;
 343         sf->p_isar.port = sf->cfg + SFAX_PCI_ISAR;
 344         ASSIGN_FUNC(IND, ISAC, sf->isac);
 345         ASSIGN_FUNC(IND, ISAR, sf->isar);
 346         spin_lock_irqsave(&sf->lock, flags);
 347         reset_speedfax(sf);
 348         disable_hwirq(sf);
 349         spin_unlock_irqrestore(&sf->lock, flags);
 350         return 0;
 351 }
 352
 353 static void
 354 release_card(struct sfax_hw *card) {
 355         u_long  flags;
 356
 357         spin_lock_irqsave(&card->lock, flags);
 358         disable_hwirq(card);
 359         spin_unlock_irqrestore(&card->lock, flags);
 360         card->isac.release(&card->isac);
 361         free_irq(card->irq, card);
 362         card->isar.release(&card->isar);
 363         mISDN_unregister_device(&card->isac.dch.dev);
 364         release_region(card->cfg, 256);
 365         pci_disable_device(card->pdev);
 366         pci_set_drvdata(card->pdev, NULL);
 367         write_lock_irqsave(&card_lock, flags);
 368         list_del(&card->list);
 369         write_unlock_irqrestore(&card_lock, flags);
 370         kfree(card);
 371         sfax_cnt--;
 372 }
 373
 374 static int
 375 setup_instance(struct sfax_hw *card)
 376 {
 377         const struct firmware *firmware;
 378         int i, err;
 379         u_long flags;
 380
 381         snprintf(card->name, MISDN_MAX_IDLEN - 1, "Speedfax.%d", sfax_cnt + 1);
 382         write_lock_irqsave(&card_lock, flags);
 383         list_add_tail(&card->list, &Cards);
 384         write_unlock_irqrestore(&card_lock, flags);
 385         _set_debug(card);
 386         spin_lock_init(&card->lock);
 387         card->isac.hwlock = &card->lock;
 388         card->isar.hwlock = &card->lock;
 389         card->isar.ctrl = (void *)&sfax_ctrl;
 390         card->isac.name = card->name;
 391         card->isar.name = card->name;
 392         card->isar.owner = THIS_MODULE;
 393
 394         err = request_firmware(&firmware, "isdn/ISAR.BIN", &card->pdev->dev);
 395         if (err < 0) {
 396                 pr_info("%s: firmware request failed %d\n",
 397                         card->name, err);
 398                 goto error_fw;
 399         }
 400         if (debug & DEBUG_HW)
 401                 pr_notice("%s: got firmware %zu bytes\n",
 402                           card->name, firmware->size);
 403
 404         mISDNisac_init(&card->isac, card);
 405
 406         card->isac.dch.dev.D.ctrl = sfax_dctrl;
 407         card->isac.dch.dev.Bprotocols =
 408                 mISDNisar_init(&card->isar, card);
 409         for (i = 0; i < 2; i++) {
 410                 set_channelmap(i + 1, card->isac.dch.dev.channelmap);
 411                 list_add(&card->isar.ch[i].bch.ch.list,
 412                          &card->isac.dch.dev.bchannels);
 413         }
 414
 415         err = setup_speedfax(card);
 416         if (err)
 417                 goto error_setup;
 418         err = card->isar.init(&card->isar);
 419         if (err)
 420                 goto error;
 421         err = mISDN_register_device(&card->isac.dch.dev,
 422                                     &card->pdev->dev, card->name);
 423         if (err)
 424                 goto error;
 425         err = init_card(card);
 426         if (err)
 427                 goto error_init;
 428         err = card->isar.firmware(&card->isar, firmware->data, firmware->size);
 429         if (!err)  {
 430                 release_firmware(firmware);
 431                 sfax_cnt++;
 432                 pr_notice("SpeedFax %d cards installed\n", sfax_cnt);
 433                 return 0;
 434         }
 435         disable_hwirq(card);
 436         free_irq(card->irq, card);
 437 error_init:
 438         mISDN_unregister_device(&card->isac.dch.dev);
 439 error:
 440         release_region(card->cfg, 256);
 441 error_setup:
 442         card->isac.release(&card->isac);
 443         card->isar.release(&card->isar);
 444         release_firmware(firmware);
 445 error_fw:
 446         pci_disable_device(card->pdev);
 447         write_lock_irqsave(&card_lock, flags);
 448         list_del(&card->list);
 449         write_unlock_irqrestore(&card_lock, flags);
 450         kfree(card);
 451         return err;
 452 }
 453
 454 static int
 455 sfaxpci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 456 {
 457         int err = -ENOMEM;
 458         struct sfax_hw *card = kzalloc(sizeof(struct sfax_hw), GFP_KERNEL);
 459
 460         if (!card) {
 461                 pr_info("No memory for Speedfax+ PCI\n");
 462                 return err;
 463         }
 464         card->pdev = pdev;
 465         err = pci_enable_device(pdev);
 466         if (err) {
 467                 kfree(card);
 468                 return err;
 469         }
 470
 471         pr_notice("mISDN: Speedfax found adapter %s at %s\n",
 472                   (char *)ent->driver_data, pci_name(pdev));
 473
 474         card->cfg = pci_resource_start(pdev, 0);
 475         card->irq = pdev->irq;
 476         pci_set_drvdata(pdev, card);
 477         err = setup_instance(card);
 478         if (err)
 479                 pci_set_drvdata(pdev, NULL);
 480         return err;
 481 }
 482
 483 static void
 484 sfax_remove_pci(struct pci_dev *pdev)
 485 {
 486         struct sfax_hw  *card = pci_get_drvdata(pdev);
 487
 488         if (card)
 489                 release_card(card);
 490         else
 491                 pr_debug("%s: drvdata already removed\n", __func__);
 492 }
 493
 494 static struct pci_device_id sfaxpci_ids[] = {
 495         { PCI_VENDOR_ID_TIGERJET, PCI_DEVICE_ID_TIGERJET_100,
 496           PCI_SUBVENDOR_SPEEDFAX_PYRAMID, PCI_SUB_ID_SEDLBAUER,
 497           0, 0, (unsigned long) "Pyramid Speedfax + PCI"
 498         },
 499         { PCI_VENDOR_ID_TIGERJET, PCI_DEVICE_ID_TIGERJET_100,
 500           PCI_SUBVENDOR_SPEEDFAX_PCI, PCI_SUB_ID_SEDLBAUER,
 501           0, 0, (unsigned long) "Sedlbauer Speedfax + PCI"
 502         },
 503         { }
 504 };
 505 MODULE_DEVICE_TABLE(pci, sfaxpci_ids);
 506
 507 static struct pci_driver sfaxpci_driver = {
 508         .name = "speedfax+ pci",
 509         .probe = sfaxpci_probe,
 510         .remove = sfax_remove_pci,
 511         .id_table = sfaxpci_ids,
 512 };
 513
 514 static int __init
 515 Speedfax_init(void)
 516 {
 517         int err;
 518
 519         pr_notice("Sedlbauer Speedfax+ Driver Rev. %s\n",
 520                   SPEEDFAX_REV);
 521         err = pci_register_driver(&sfaxpci_driver);
 522         return err;
 523 }
 524
 525 static void __exit
 526 Speedfax_cleanup(void)
 527 {
 528         pci_unregister_driver(&sfaxpci_driver);
 529 }
 530
 531 module_init(Speedfax_init);
 532 module_exit(Speedfax_cleanup);