Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kaber/nf-next-2.6
[linux-2.6.git] / 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/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);