Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/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);
533 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us