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