?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.34-rc3
[pohmelfs.git] / drivers / isdn / hardware / mISDN / speedfax.c
blob7726afdbb40b72f043df0299ca64788a4e7599d9
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);