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);
520