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