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