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