projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'sched_ext-for-6.12-rc1-fixes' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6-block.git] / drivers / isdn / hardware / mISDN / w6692.c
CommitLineData
82c29810 1// SPDX-License-Identifier: GPL-2.0-only
707b2ce6
KK		 2/*
3 * w6692.c mISDN driver for Winbond w6692 based cards
4 *
5 * Author Karsten Keil <kkeil@suse.de>
6 * based on the w6692 I4L driver from Petr Novak <petr.novak@i.cz>
7 *
8 * Copyright 2009 by Karsten Keil <keil@isdn4linux.de>
707b2ce6
KK		 9 */
10
a6b7a407 11#include <linux/interrupt.h>
707b2ce6
KK		 12#include <linux/module.h>
13#include <linux/pci.h>
14#include <linux/delay.h>
15#include <linux/mISDNhw.h>
5a0e3ad6 16#include <linux/slab.h>
707b2ce6
KK		 17#include "w6692.h"
18
19#define W6692_REV "2.0"
20
21#define DBUSY_TIMER_VALUE 80
22
23enum {
24 W6692_ASUS,
25 W6692_WINBOND,
26 W6692_USR
27};
28
29/* private data in the PCI devices list */
30struct w6692map {
31 u_int subtype;
32 char *name;
33};
34
35static const struct w6692map w6692_map[] =
36{
37 {W6692_ASUS, "Dynalink/AsusCom IS64PH"},
38 {W6692_WINBOND, "Winbond W6692"},
39 {W6692_USR, "USR W6692"}
40};
41
707b2ce6 42#define PCI_DEVICE_ID_USR_6692 0x3409
707b2ce6
KK		 43
44struct w6692_ch {
45 struct bchannel bch;
46 u32 addr;
47 struct timer_list timer;
48 u8 b_mode;
49};
50
51struct w6692_hw {
52 struct list_head list;
53 struct pci_dev *pdev;
54 char name[MISDN_MAX_IDLEN];
55 u32 irq;
56 u32 irqcnt;
57 u32 addr;
58 u32 fmask; /* feature mask - bit set per card nr */
59 int subtype;
60 spinlock_t lock; /* hw lock */
61 u8 imask;
62 u8 pctl;
63 u8 xaddr;
64 u8 xdata;
65 u8 state;
66 struct w6692_ch bc[2];
67 struct dchannel dch;
68 char log[64];
69};
70
71static LIST_HEAD(Cards);
72static DEFINE_RWLOCK(card_lock); /* protect Cards */
73
74static int w6692_cnt;
75static int debug;
76static u32 led;
77static u32 pots;
78
79static void
80_set_debug(struct w6692_hw *card)
81{
82 card->dch.debug = debug;
83 card->bc[0].bch.debug = debug;
84 card->bc[1].bch.debug = debug;
85}
86
87static int
e4dca7b7 88set_debug(const char *val, const struct kernel_param *kp)
707b2ce6
KK		 89{
90 int ret;
91 struct w6692_hw *card;
92
93 ret = param_set_uint(val, kp);
94 if (!ret) {
95 read_lock(&card_lock);
96 list_for_each_entry(card, &Cards, list)
97 _set_debug(card);
98 read_unlock(&card_lock);
99 }
100 return ret;
101}
102
103MODULE_AUTHOR("Karsten Keil");
2ebb87f4 104MODULE_DESCRIPTION("mISDN driver for Winbond w6692 based cards");
707b2ce6
KK		 105MODULE_LICENSE("GPL v2");
106MODULE_VERSION(W6692_REV);
107module_param_call(debug, set_debug, param_get_uint, &debug, S_IRUGO | S_IWUSR);
108MODULE_PARM_DESC(debug, "W6692 debug mask");
109module_param(led, uint, S_IRUGO | S_IWUSR);
110MODULE_PARM_DESC(led, "W6692 LED support bitmask (one bit per card)");
111module_param(pots, uint, S_IRUGO | S_IWUSR);
112MODULE_PARM_DESC(pots, "W6692 POTS support bitmask (one bit per card)");
113
114static inline u8
115ReadW6692(struct w6692_hw *card, u8 offset)
116{
117 return inb(card->addr + offset);
118}
119
120static inline void
121WriteW6692(struct w6692_hw *card, u8 offset, u8 value)
122{
123 outb(value, card->addr + offset);
124}
125
126static inline u8
127ReadW6692B(struct w6692_ch *bc, u8 offset)
128{
129 return inb(bc->addr + offset);
130}
131
132static inline void
133WriteW6692B(struct w6692_ch *bc, u8 offset, u8 value)
134{
135 outb(value, bc->addr + offset);
136}
137
138static void
139enable_hwirq(struct w6692_hw *card)
140{
141 WriteW6692(card, W_IMASK, card->imask);
142}
143
144static void
145disable_hwirq(struct w6692_hw *card)
146{
147 WriteW6692(card, W_IMASK, 0xff);
148}
149
150static const char *W6692Ver[] = {"V00", "V01", "V10", "V11"};
151
152static void
153W6692Version(struct w6692_hw *card)
154{
155 int val;
156
157 val = ReadW6692(card, W_D_RBCH);
158 pr_notice("%s: Winbond W6692 version: %s\n", card->name,
475be4d8 159 W6692Ver[(val >> 6) & 3]);
707b2ce6
KK		 160}
161
162static void
163w6692_led_handler(struct w6692_hw *card, int on)
164{
165 if ((!(card->fmask & led)) || card->subtype == W6692_USR)
166 return;
167 if (on) {
168 card->xdata &= 0xfb; /* LED ON */
169 WriteW6692(card, W_XDATA, card->xdata);
170 } else {
171 card->xdata |= 0x04; /* LED OFF */
172 WriteW6692(card, W_XDATA, card->xdata);
173 }
174}
175
176static void
177ph_command(struct w6692_hw *card, u8 cmd)
178{
179 pr_debug("%s: ph_command %x\n", card->name, cmd);
180 WriteW6692(card, W_CIX, cmd);
181}
182
183static void
184W6692_new_ph(struct w6692_hw *card)
185{
186 if (card->state == W_L1CMD_RST)
187 ph_command(card, W_L1CMD_DRC);
188 schedule_event(&card->dch, FLG_PHCHANGE);
189}
190
191static void
192W6692_ph_bh(struct dchannel *dch)
193{
194 struct w6692_hw *card = dch->hw;
195
196 switch (card->state) {
197 case W_L1CMD_RST:
198 dch->state = 0;
199 l1_event(dch->l1, HW_RESET_IND);
200 break;
201 case W_L1IND_CD:
202 dch->state = 3;
203 l1_event(dch->l1, HW_DEACT_CNF);
204 break;
205 case W_L1IND_DRD:
206 dch->state = 3;
207 l1_event(dch->l1, HW_DEACT_IND);
208 break;
209 case W_L1IND_CE:
210 dch->state = 4;
211 l1_event(dch->l1, HW_POWERUP_IND);
212 break;
213 case W_L1IND_LD:
214 if (dch->state <= 5) {
215 dch->state = 5;
216 l1_event(dch->l1, ANYSIGNAL);
217 } else {
218 dch->state = 8;
219 l1_event(dch->l1, LOSTFRAMING);
220 }
221 break;
222 case W_L1IND_ARD:
223 dch->state = 6;
224 l1_event(dch->l1, INFO2);
225 break;
226 case W_L1IND_AI8:
227 dch->state = 7;
228 l1_event(dch->l1, INFO4_P8);
229 break;
230 case W_L1IND_AI10:
231 dch->state = 7;
232 l1_event(dch->l1, INFO4_P10);
233 break;
234 default:
235 pr_debug("%s: TE unknown state %02x dch state %02x\n",
475be4d8 236 card->name, card->state, dch->state);
707b2ce6
KK		 237 break;
238 }
239 pr_debug("%s: TE newstate %02x\n", card->name, dch->state);
240}
241
242static void
243W6692_empty_Dfifo(struct w6692_hw *card, int count)
244{
245 struct dchannel *dch = &card->dch;
246 u8 *ptr;
247
248 pr_debug("%s: empty_Dfifo %d\n", card->name, count);
249 if (!dch->rx_skb) {
250 dch->rx_skb = mI_alloc_skb(card->dch.maxlen, GFP_ATOMIC);
251 if (!dch->rx_skb) {
252 pr_info("%s: D receive out of memory\n", card->name);
253 WriteW6692(card, W_D_CMDR, W_D_CMDR_RACK);
254 return;
255 }
256 }
257 if ((dch->rx_skb->len + count) >= dch->maxlen) {
258 pr_debug("%s: empty_Dfifo overrun %d\n", card->name,
475be4d8 259 dch->rx_skb->len + count);
707b2ce6
KK		 260 WriteW6692(card, W_D_CMDR, W_D_CMDR_RACK);
261 return;
262 }
263 ptr = skb_put(dch->rx_skb, count);
264 insb(card->addr + W_D_RFIFO, ptr, count);
265 WriteW6692(card, W_D_CMDR, W_D_CMDR_RACK);
266 if (debug & DEBUG_HW_DFIFO) {
267 snprintf(card->log, 63, "D-recv %s %d ",
475be4d8 268 card->name, count);
707b2ce6
KK		 269 print_hex_dump_bytes(card->log, DUMP_PREFIX_OFFSET, ptr, count);
270 }
271}
272
273static void
274W6692_fill_Dfifo(struct w6692_hw *card)
275{
276 struct dchannel *dch = &card->dch;
277 int count;
278 u8 *ptr;
279 u8 cmd = W_D_CMDR_XMS;
280
281 pr_debug("%s: fill_Dfifo\n", card->name);
282 if (!dch->tx_skb)
283 return;
284 count = dch->tx_skb->len - dch->tx_idx;
285 if (count <= 0)
286 return;
287 if (count > W_D_FIFO_THRESH)
288 count = W_D_FIFO_THRESH;
289 else
290 cmd |= W_D_CMDR_XME;
291 ptr = dch->tx_skb->data + dch->tx_idx;
292 dch->tx_idx += count;
293 outsb(card->addr + W_D_XFIFO, ptr, count);
294 WriteW6692(card, W_D_CMDR, cmd);
295 if (test_and_set_bit(FLG_BUSY_TIMER, &dch->Flags)) {
296 pr_debug("%s: fill_Dfifo dbusytimer running\n", card->name);
297 del_timer(&dch->timer);
298 }
475be4d8 299 dch->timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000);
707b2ce6
KK		 300 add_timer(&dch->timer);
301 if (debug & DEBUG_HW_DFIFO) {
302 snprintf(card->log, 63, "D-send %s %d ",
475be4d8 303 card->name, count);
707b2ce6
KK		 304 print_hex_dump_bytes(card->log, DUMP_PREFIX_OFFSET, ptr, count);
305 }
306}
307
308static void
309d_retransmit(struct w6692_hw *card)
310{
311 struct dchannel *dch = &card->dch;
312
313 if (test_and_clear_bit(FLG_BUSY_TIMER, &dch->Flags))
314 del_timer(&dch->timer);
315#ifdef FIXME
316 if (test_and_clear_bit(FLG_L1_BUSY, &dch->Flags))
317 dchannel_sched_event(dch, D_CLEARBUSY);
318#endif
319 if (test_bit(FLG_TX_BUSY, &dch->Flags)) {
320 /* Restart frame */
321 dch->tx_idx = 0;
322 W6692_fill_Dfifo(card);
323 } else if (dch->tx_skb) { /* should not happen */
324 pr_info("%s: %s without TX_BUSY\n", card->name, __func__);
325 test_and_set_bit(FLG_TX_BUSY, &dch->Flags);
326 dch->tx_idx = 0;
327 W6692_fill_Dfifo(card);
328 } else {
329 pr_info("%s: XDU no TX_BUSY\n", card->name);
330 if (get_next_dframe(dch))
331 W6692_fill_Dfifo(card);
332 }
333}
334
335static void
336handle_rxD(struct w6692_hw *card) {
337 u8 stat;
338 int count;
339
340 stat = ReadW6692(card, W_D_RSTA);
341 if (stat & (W_D_RSTA_RDOV | W_D_RSTA_CRCE | W_D_RSTA_RMB)) {
342 if (stat & W_D_RSTA_RDOV) {
343 pr_debug("%s: D-channel RDOV\n", card->name);
344#ifdef ERROR_STATISTIC
345 card->dch.err_rx++;
346#endif
347 }
348 if (stat & W_D_RSTA_CRCE) {
349 pr_debug("%s: D-channel CRC error\n", card->name);
350#ifdef ERROR_STATISTIC
351 card->dch.err_crc++;
352#endif
353 }
354 if (stat & W_D_RSTA_RMB) {
355 pr_debug("%s: D-channel ABORT\n", card->name);
356#ifdef ERROR_STATISTIC
357 card->dch.err_rx++;
358#endif
359 }
0f817a5e 360 dev_kfree_skb(card->dch.rx_skb);
707b2ce6
KK		 361 card->dch.rx_skb = NULL;
362 WriteW6692(card, W_D_CMDR, W_D_CMDR_RACK | W_D_CMDR_RRST);
363 } else {
364 count = ReadW6692(card, W_D_RBCL) & (W_D_FIFO_THRESH - 1);
365 if (count == 0)
366 count = W_D_FIFO_THRESH;
367 W6692_empty_Dfifo(card, count);
368 recv_Dchannel(&card->dch);
369 }
370}
371
372static void
373handle_txD(struct w6692_hw *card) {
374 if (test_and_clear_bit(FLG_BUSY_TIMER, &card->dch.Flags))
375 del_timer(&card->dch.timer);
376 if (card->dch.tx_skb && card->dch.tx_idx < card->dch.tx_skb->len) {
377 W6692_fill_Dfifo(card);
378 } else {
0f817a5e 379 dev_kfree_skb(card->dch.tx_skb);
707b2ce6
KK		 380 if (get_next_dframe(&card->dch))
381 W6692_fill_Dfifo(card);
382 }
383}
384
385static void
386handle_statusD(struct w6692_hw *card)
387{
388 struct dchannel *dch = &card->dch;
389 u8 exval, v1, cir;
390
391 exval = ReadW6692(card, W_D_EXIR);
392
393 pr_debug("%s: D_EXIR %02x\n", card->name, exval);
394 if (exval & (W_D_EXI_XDUN | W_D_EXI_XCOL)) {
395 /* Transmit underrun/collision */
396 pr_debug("%s: D-channel underrun/collision\n", card->name);
397#ifdef ERROR_STATISTIC
398 dch->err_tx++;
399#endif
400 d_retransmit(card);
401 }
402 if (exval & W_D_EXI_RDOV) { /* RDOV */
403 pr_debug("%s: D-channel RDOV\n", card->name);
404 WriteW6692(card, W_D_CMDR, W_D_CMDR_RRST);
405 }
406 if (exval & W_D_EXI_TIN2) /* TIN2 - never */
407 pr_debug("%s: spurious TIN2 interrupt\n", card->name);
408 if (exval & W_D_EXI_MOC) { /* MOC - not supported */
409 v1 = ReadW6692(card, W_MOSR);
410 pr_debug("%s: spurious MOC interrupt MOSR %02x\n",
475be4d8 411 card->name, v1);
707b2ce6
KK		 412 }
413 if (exval & W_D_EXI_ISC) { /* ISC - Level1 change */
414 cir = ReadW6692(card, W_CIR);
415 pr_debug("%s: ISC CIR %02X\n", card->name, cir);
416 if (cir & W_CIR_ICC) {
417 v1 = cir & W_CIR_COD_MASK;
418 pr_debug("%s: ph_state_change %x -> %x\n", card->name,
475be4d8 419 dch->state, v1);
707b2ce6
KK		 420 card->state = v1;
421 if (card->fmask & led) {
422 switch (v1) {
423 case W_L1IND_AI8:
424 case W_L1IND_AI10:
425 w6692_led_handler(card, 1);
426 break;
427 default:
428 w6692_led_handler(card, 0);
429 break;
430 }
431 }
432 W6692_new_ph(card);
433 }
434 if (cir & W_CIR_SCC) {
435 v1 = ReadW6692(card, W_SQR);
436 pr_debug("%s: SCC SQR %02X\n", card->name, v1);
437 }
438 }
439 if (exval & W_D_EXI_WEXP)
440 pr_debug("%s: spurious WEXP interrupt!\n", card->name);
441 if (exval & W_D_EXI_TEXP)
442 pr_debug("%s: spurious TEXP interrupt!\n", card->name);
443}
444
445static void
446W6692_empty_Bfifo(struct w6692_ch *wch, int count)
447{
448 struct w6692_hw *card = wch->bch.hw;
449 u8 *ptr;
7206e659 450 int maxlen;
707b2ce6
KK		 451
452 pr_debug("%s: empty_Bfifo %d\n", card->name, count);
453 if (unlikely(wch->bch.state == ISDN_P_NONE)) {
454 pr_debug("%s: empty_Bfifo ISDN_P_NONE\n", card->name);
455 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RACT);
456 if (wch->bch.rx_skb)
457 skb_trim(wch->bch.rx_skb, 0);
458 return;
459 }
c27b46e7
KK		 460 if (test_bit(FLG_RX_OFF, &wch->bch.Flags)) {
461 wch->bch.dropcnt += count;
462 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RACT);
463 return;
464 }
7206e659
KK		 465 maxlen = bchannel_get_rxbuf(&wch->bch, count);
466 if (maxlen < 0) {
707b2ce6 467 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RACT);
7206e659
KK		 468 if (wch->bch.rx_skb)
469 skb_trim(wch->bch.rx_skb, 0);
257daba4
KW		 470 pr_warn("%s.B%d: No bufferspace for %d bytes\n",
471 card->name, wch->bch.nr, count);
707b2ce6
KK		 472 return;
473 }
474 ptr = skb_put(wch->bch.rx_skb, count);
475 insb(wch->addr + W_B_RFIFO, ptr, count);
476 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK | W_B_CMDR_RACT);
477 if (debug & DEBUG_HW_DFIFO) {
478 snprintf(card->log, 63, "B%1d-recv %s %d ",
475be4d8 479 wch->bch.nr, card->name, count);
707b2ce6
KK		 480 print_hex_dump_bytes(card->log, DUMP_PREFIX_OFFSET, ptr, count);
481 }
482}
483
484static void
485W6692_fill_Bfifo(struct w6692_ch *wch)
486{
487 struct w6692_hw *card = wch->bch.hw;
6d1ee48f 488 int count, fillempty = 0;
707b2ce6
KK		 489 u8 *ptr, cmd = W_B_CMDR_RACT | W_B_CMDR_XMS;
490
491 pr_debug("%s: fill Bfifo\n", card->name);
6d1ee48f
KK		 492 if (!wch->bch.tx_skb) {
493 if (!test_bit(FLG_TX_EMPTY, &wch->bch.Flags))
494 return;
495 ptr = wch->bch.fill;
496 count = W_B_FIFO_THRESH;
497 fillempty = 1;
498 } else {
499 count = wch->bch.tx_skb->len - wch->bch.tx_idx;
500 if (count <= 0)
501 return;
502 ptr = wch->bch.tx_skb->data + wch->bch.tx_idx;
503 }
707b2ce6
KK		 504 if (count > W_B_FIFO_THRESH)
505 count = W_B_FIFO_THRESH;
506 else if (test_bit(FLG_HDLC, &wch->bch.Flags))
507 cmd |= W_B_CMDR_XME;
508
509 pr_debug("%s: fill Bfifo%d/%d\n", card->name,
475be4d8 510 count, wch->bch.tx_idx);
707b2ce6 511 wch->bch.tx_idx += count;
6d1ee48f
KK		 512 if (fillempty) {
513 while (count > 0) {
514 outsb(wch->addr + W_B_XFIFO, ptr, MISDN_BCH_FILL_SIZE);
515 count -= MISDN_BCH_FILL_SIZE;
516 }
517 } else {
518 outsb(wch->addr + W_B_XFIFO, ptr, count);
519 }
707b2ce6 520 WriteW6692B(wch, W_B_CMDR, cmd);
6d1ee48f 521 if ((debug & DEBUG_HW_BFIFO) && !fillempty) {
707b2ce6 522 snprintf(card->log, 63, "B%1d-send %s %d ",
475be4d8 523 wch->bch.nr, card->name, count);
707b2ce6
KK		 524 print_hex_dump_bytes(card->log, DUMP_PREFIX_OFFSET, ptr, count);
525 }
526}
527
3e598177 528#if 0
707b2ce6
KK		 529static int
530setvolume(struct w6692_ch *wch, int mic, struct sk_buff *skb)
531{
532 struct w6692_hw *card = wch->bch.hw;
533 u16 *vol = (u16 *)skb->data;
534 u8 val;
535
536 if ((!(card->fmask & pots)) ||
537 !test_bit(FLG_TRANSPARENT, &wch->bch.Flags))
538 return -ENODEV;
539 if (skb->len < 2)
540 return -EINVAL;
541 if (*vol > 7)
542 return -EINVAL;
543 val = *vol & 7;
544 val = 7 - val;
545 if (mic) {
546 val <<= 3;
547 card->xaddr &= 0xc7;
548 } else {
549 card->xaddr &= 0xf8;
550 }
551 card->xaddr |= val;
552 WriteW6692(card, W_XADDR, card->xaddr);
553 return 0;
554}
555
556static int
557enable_pots(struct w6692_ch *wch)
558{
559 struct w6692_hw *card = wch->bch.hw;
560
561 if ((!(card->fmask & pots)) ||
562 !test_bit(FLG_TRANSPARENT, &wch->bch.Flags))
563 return -ENODEV;
564 wch->b_mode |= W_B_MODE_EPCM | W_B_MODE_BSW0;
565 WriteW6692B(wch, W_B_MODE, wch->b_mode);
566 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RRST | W_B_CMDR_XRST);
567 card->pctl |= ((wch->bch.nr & 2) ? W_PCTL_PCX : 0);
568 WriteW6692(card, W_PCTL, card->pctl);
569 return 0;
570}
3e598177 571#endif
707b2ce6
KK		 572
573static int
574disable_pots(struct w6692_ch *wch)
575{
576 struct w6692_hw *card = wch->bch.hw;
577
578 if (!(card->fmask & pots))
579 return -ENODEV;
580 wch->b_mode &= ~(W_B_MODE_EPCM | W_B_MODE_BSW0);
581 WriteW6692B(wch, W_B_MODE, wch->b_mode);
582 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RRST | W_B_CMDR_RACT |
475be4d8 583 W_B_CMDR_XRST);
707b2ce6
KK		 584 return 0;
585}
586
587static int
588w6692_mode(struct w6692_ch *wch, u32 pr)
589{
590 struct w6692_hw *card;
591
592 card = wch->bch.hw;
593 pr_debug("%s: B%d protocol %x-->%x\n", card->name,
475be4d8 594 wch->bch.nr, wch->bch.state, pr);
707b2ce6
KK		 595 switch (pr) {
596 case ISDN_P_NONE:
597 if ((card->fmask & pots) && (wch->b_mode & W_B_MODE_EPCM))
598 disable_pots(wch);
599 wch->b_mode = 0;
600 mISDN_clear_bchannel(&wch->bch);
601 WriteW6692B(wch, W_B_MODE, wch->b_mode);
602 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RRST | W_B_CMDR_XRST);
603 test_and_clear_bit(FLG_HDLC, &wch->bch.Flags);
604 test_and_clear_bit(FLG_TRANSPARENT, &wch->bch.Flags);
605 break;
606 case ISDN_P_B_RAW:
607 wch->b_mode = W_B_MODE_MMS;
608 WriteW6692B(wch, W_B_MODE, wch->b_mode);
609 WriteW6692B(wch, W_B_EXIM, 0);
610 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RRST | W_B_CMDR_RACT |
475be4d8 611 W_B_CMDR_XRST);
707b2ce6
KK		 612 test_and_set_bit(FLG_TRANSPARENT, &wch->bch.Flags);
613 break;
614 case ISDN_P_B_HDLC:
615 wch->b_mode = W_B_MODE_ITF;
616 WriteW6692B(wch, W_B_MODE, wch->b_mode);
617 WriteW6692B(wch, W_B_ADM1, 0xff);
618 WriteW6692B(wch, W_B_ADM2, 0xff);
619 WriteW6692B(wch, W_B_EXIM, 0);
620 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RRST | W_B_CMDR_RACT |
475be4d8 621 W_B_CMDR_XRST);
707b2ce6
KK		 622 test_and_set_bit(FLG_HDLC, &wch->bch.Flags);
623 break;
624 default:
625 pr_info("%s: protocol %x not known\n", card->name, pr);
626 return -ENOPROTOOPT;
627 }
628 wch->bch.state = pr;
629 return 0;
630}
631
632static void
633send_next(struct w6692_ch *wch)
634{
8bfddfbe 635 if (wch->bch.tx_skb && wch->bch.tx_idx < wch->bch.tx_skb->len) {
707b2ce6 636 W6692_fill_Bfifo(wch);
8bfddfbe 637 } else {
0f817a5e 638 dev_kfree_skb(wch->bch.tx_skb);
6d1ee48f
KK		 639 if (get_next_bframe(&wch->bch)) {
640 W6692_fill_Bfifo(wch);
641 test_and_clear_bit(FLG_TX_EMPTY, &wch->bch.Flags);
642 } else if (test_bit(FLG_TX_EMPTY, &wch->bch.Flags)) {
707b2ce6 643 W6692_fill_Bfifo(wch);
6d1ee48f 644 }
707b2ce6
KK		 645 }
646}
647
648static void
649W6692B_interrupt(struct w6692_hw *card, int ch)
650{
651 struct w6692_ch *wch = &card->bc[ch];
652 int count;
653 u8 stat, star = 0;
654
655 stat = ReadW6692B(wch, W_B_EXIR);
656 pr_debug("%s: B%d EXIR %02x\n", card->name, wch->bch.nr, stat);
657 if (stat & W_B_EXI_RME) {
658 star = ReadW6692B(wch, W_B_STAR);
659 if (star & (W_B_STAR_RDOV | W_B_STAR_CRCE | W_B_STAR_RMB)) {
660 if ((star & W_B_STAR_RDOV) &&
661 test_bit(FLG_ACTIVE, &wch->bch.Flags)) {
662 pr_debug("%s: B%d RDOV proto=%x\n", card->name,
475be4d8 663 wch->bch.nr, wch->bch.state);
707b2ce6
KK		 664#ifdef ERROR_STATISTIC
665 wch->bch.err_rdo++;
666#endif
667 }
668 if (test_bit(FLG_HDLC, &wch->bch.Flags)) {
669 if (star & W_B_STAR_CRCE) {
670 pr_debug("%s: B%d CRC error\n",
475be4d8 671 card->name, wch->bch.nr);
707b2ce6
KK		 672#ifdef ERROR_STATISTIC
673 wch->bch.err_crc++;
674#endif
675 }
676 if (star & W_B_STAR_RMB) {
677 pr_debug("%s: B%d message abort\n",
475be4d8 678 card->name, wch->bch.nr);
707b2ce6
KK		 679#ifdef ERROR_STATISTIC
680 wch->bch.err_inv++;
681#endif
682 }
683 }
684 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK |
475be4d8 685 W_B_CMDR_RRST | W_B_CMDR_RACT);
707b2ce6
KK		 686 if (wch->bch.rx_skb)
687 skb_trim(wch->bch.rx_skb, 0);
688 } else {
689 count = ReadW6692B(wch, W_B_RBCL) &
690 (W_B_FIFO_THRESH - 1);
691 if (count == 0)
692 count = W_B_FIFO_THRESH;
693 W6692_empty_Bfifo(wch, count);
034005a0 694 recv_Bchannel(&wch->bch, 0, false);
707b2ce6
KK		 695 }
696 }
697 if (stat & W_B_EXI_RMR) {
698 if (!(stat & W_B_EXI_RME))
699 star = ReadW6692B(wch, W_B_STAR);
700 if (star & W_B_STAR_RDOV) {
701 pr_debug("%s: B%d RDOV proto=%x\n", card->name,
475be4d8 702 wch->bch.nr, wch->bch.state);
707b2ce6
KK		 703#ifdef ERROR_STATISTIC
704 wch->bch.err_rdo++;
705#endif
706 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK |
475be4d8 707 W_B_CMDR_RRST | W_B_CMDR_RACT);
707b2ce6
KK		 708 } else {
709 W6692_empty_Bfifo(wch, W_B_FIFO_THRESH);
034005a0
KK		 710 if (test_bit(FLG_TRANSPARENT, &wch->bch.Flags))
711 recv_Bchannel(&wch->bch, 0, false);
707b2ce6
KK		 712 }
713 }
714 if (stat & W_B_EXI_RDOV) {
715 /* only if it is not handled yet */
716 if (!(star & W_B_STAR_RDOV)) {
717 pr_debug("%s: B%d RDOV IRQ proto=%x\n", card->name,
475be4d8 718 wch->bch.nr, wch->bch.state);
707b2ce6
KK		 719#ifdef ERROR_STATISTIC
720 wch->bch.err_rdo++;
721#endif
722 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_RACK |
475be4d8 723 W_B_CMDR_RRST | W_B_CMDR_RACT);
707b2ce6
KK		 724 }
725 }
726 if (stat & W_B_EXI_XFR) {
727 if (!(stat & (W_B_EXI_RME | W_B_EXI_RMR))) {
728 star = ReadW6692B(wch, W_B_STAR);
729 pr_debug("%s: B%d star %02x\n", card->name,
475be4d8 730 wch->bch.nr, star);
707b2ce6
KK		 731 }
732 if (star & W_B_STAR_XDOW) {
257daba4
KW		 733 pr_warn("%s: B%d XDOW proto=%x\n", card->name,
734 wch->bch.nr, wch->bch.state);
707b2ce6
KK		 735#ifdef ERROR_STATISTIC
736 wch->bch.err_xdu++;
737#endif
738 WriteW6692B(wch, W_B_CMDR, W_B_CMDR_XRST |
475be4d8 739 W_B_CMDR_RACT);
707b2ce6
KK		 740 /* resend */
741 if (wch->bch.tx_skb) {
742 if (!test_bit(FLG_TRANSPARENT, &wch->bch.Flags))
743 wch->bch.tx_idx = 0;
744 }
745 }
746 send_next(wch);
6d1ee48f 747 if (star & W_B_STAR_XDOW)
707b2ce6
KK		 748 return; /* handle XDOW only once */
749 }
750 if (stat & W_B_EXI_XDUN) {
257daba4
KW		 751 pr_warn("%s: B%d XDUN proto=%x\n", card->name,
752 wch->bch.nr, wch->bch.state);
707b2ce6
KK		 753#ifdef ERROR_STATISTIC
754 wch->bch.err_xdu++;
755#endif
6d1ee48f 756 /* resend - no XRST needed */
707b2ce6
KK		 757 if (wch->bch.tx_skb) {
758 if (!test_bit(FLG_TRANSPARENT, &wch->bch.Flags))
759 wch->bch.tx_idx = 0;
6d1ee48f
KK		 760 } else if (test_bit(FLG_FILLEMPTY, &wch->bch.Flags)) {
761 test_and_set_bit(FLG_TX_EMPTY, &wch->bch.Flags);
707b2ce6
KK		 762 }
763 send_next(wch);
764 }
765}
766
767static irqreturn_t
768w6692_irq(int intno, void *dev_id)
769{
770 struct w6692_hw *card = dev_id;
771 u8 ista;
772
773 spin_lock(&card->lock);
774 ista = ReadW6692(card, W_ISTA);
775 if ((ista | card->imask) == card->imask) {
776 /* possible a shared IRQ reqest */
777 spin_unlock(&card->lock);
778 return IRQ_NONE;
779 }
780 card->irqcnt++;
781 pr_debug("%s: ista %02x\n", card->name, ista);
782 ista &= ~card->imask;
783 if (ista & W_INT_B1_EXI)
784 W6692B_interrupt(card, 0);
785 if (ista & W_INT_B2_EXI)
786 W6692B_interrupt(card, 1);
787 if (ista & W_INT_D_RME)
788 handle_rxD(card);
789 if (ista & W_INT_D_RMR)
790 W6692_empty_Dfifo(card, W_D_FIFO_THRESH);
791 if (ista & W_INT_D_XFR)
792 handle_txD(card);
793 if (ista & W_INT_D_EXI)
794 handle_statusD(card);
795 if (ista & (W_INT_XINT0 | W_INT_XINT1)) /* XINT0/1 - never */
796 pr_debug("%s: W6692 spurious XINT!\n", card->name);
797/* End IRQ Handler */
798 spin_unlock(&card->lock);
799 return IRQ_HANDLED;
800}
801
802static void
e313ac12 803dbusy_timer_handler(struct timer_list *t)
707b2ce6 804{
e313ac12 805 struct dchannel *dch = from_timer(dch, t, timer);
707b2ce6
KK		 806 struct w6692_hw *card = dch->hw;
807 int rbch, star;
808 u_long flags;
809
810 if (test_bit(FLG_BUSY_TIMER, &dch->Flags)) {
811 spin_lock_irqsave(&card->lock, flags);
812 rbch = ReadW6692(card, W_D_RBCH);
813 star = ReadW6692(card, W_D_STAR);
814 pr_debug("%s: D-Channel Busy RBCH %02x STAR %02x\n",
475be4d8 815 card->name, rbch, star);
707b2ce6
KK		 816 if (star & W_D_STAR_XBZ) /* D-Channel Busy */
817 test_and_set_bit(FLG_L1_BUSY, &dch->Flags);
818 else {
819 /* discard frame; reset transceiver */
820 test_and_clear_bit(FLG_BUSY_TIMER, &dch->Flags);
821 if (dch->tx_idx)
822 dch->tx_idx = 0;
823 else
824 pr_info("%s: W6692 D-Channel Busy no tx_idx\n",
825 card->name);
826 /* Transmitter reset */
827 WriteW6692(card, W_D_CMDR, W_D_CMDR_XRST);
828 }
829 spin_unlock_irqrestore(&card->lock, flags);
830 }
831}
832
569e937e 833static void initW6692(struct w6692_hw *card)
707b2ce6
KK		 834{
835 u8 val;
836
e313ac12 837 timer_setup(&card->dch.timer, dbusy_timer_handler, 0);
707b2ce6
KK		 838 w6692_mode(&card->bc[0], ISDN_P_NONE);
839 w6692_mode(&card->bc[1], ISDN_P_NONE);
840 WriteW6692(card, W_D_CTL, 0x00);
841 disable_hwirq(card);
842 WriteW6692(card, W_D_SAM, 0xff);
843 WriteW6692(card, W_D_TAM, 0xff);
844 WriteW6692(card, W_D_MODE, W_D_MODE_RACT);
845 card->state = W_L1CMD_RST;
846 ph_command(card, W_L1CMD_RST);
847 ph_command(card, W_L1CMD_ECK);
848 /* enable all IRQ but extern */
849 card->imask = 0x18;
850 WriteW6692(card, W_D_EXIM, 0x00);
851 WriteW6692B(&card->bc[0], W_B_EXIM, 0);
852 WriteW6692B(&card->bc[1], W_B_EXIM, 0);
853 /* Reset D-chan receiver and transmitter */
854 WriteW6692(card, W_D_CMDR, W_D_CMDR_RRST | W_D_CMDR_XRST);
855 /* Reset B-chan receiver and transmitter */
856 WriteW6692B(&card->bc[0], W_B_CMDR, W_B_CMDR_RRST | W_B_CMDR_XRST);
857 WriteW6692B(&card->bc[1], W_B_CMDR, W_B_CMDR_RRST | W_B_CMDR_XRST);
858 /* enable peripheral */
859 if (card->subtype == W6692_USR) {
860 /* seems that USR implemented some power control features
861 * Pin 79 is connected to the oscilator circuit so we
862 * have to handle it here
863 */
864 card->pctl = 0x80;
865 card->xdata = 0;
866 WriteW6692(card, W_PCTL, card->pctl);
867 WriteW6692(card, W_XDATA, card->xdata);
868 } else {
869 card->pctl = W_PCTL_OE5 | W_PCTL_OE4 | W_PCTL_OE2 |
870 W_PCTL_OE1 | W_PCTL_OE0;
871 card->xaddr = 0x00;/* all sw off */
872 if (card->fmask & pots)
873 card->xdata |= 0x06; /* POWER UP/ LED OFF / ALAW */
874 if (card->fmask & led)
875 card->xdata |= 0x04; /* LED OFF */
876 if ((card->fmask & pots) || (card->fmask & led)) {
877 WriteW6692(card, W_PCTL, card->pctl);
878 WriteW6692(card, W_XADDR, card->xaddr);
879 WriteW6692(card, W_XDATA, card->xdata);
880 val = ReadW6692(card, W_XADDR);
881 if (debug & DEBUG_HW)
882 pr_notice("%s: W_XADDR=%02x\n",
475be4d8 883 card->name, val);
707b2ce6
KK		 884 }
885 }
886}
887
888static void
889reset_w6692(struct w6692_hw *card)
890{
891 WriteW6692(card, W_D_CTL, W_D_CTL_SRST);
892 mdelay(10);
893 WriteW6692(card, W_D_CTL, 0);
894}
895
896static int
897init_card(struct w6692_hw *card)
898{
899 int cnt = 3;
900 u_long flags;
901
902 spin_lock_irqsave(&card->lock, flags);
903 disable_hwirq(card);
904 spin_unlock_irqrestore(&card->lock, flags);
905 if (request_irq(card->irq, w6692_irq, IRQF_SHARED, card->name, card)) {
906 pr_info("%s: couldn't get interrupt %d\n", card->name,
907 card->irq);
908 return -EIO;
909 }
910 while (cnt--) {
911 spin_lock_irqsave(&card->lock, flags);
912 initW6692(card);
913 enable_hwirq(card);
914 spin_unlock_irqrestore(&card->lock, flags);
915 /* Timeout 10ms */
916 msleep_interruptible(10);
917 if (debug & DEBUG_HW)
918 pr_notice("%s: IRQ %d count %d\n", card->name,
475be4d8 919 card->irq, card->irqcnt);
707b2ce6
KK		 920 if (!card->irqcnt) {
921 pr_info("%s: IRQ(%d) getting no IRQs during init %d\n",
922 card->name, card->irq, 3 - cnt);
923 reset_w6692(card);
924 } else
925 return 0;
926 }
927 free_irq(card->irq, card);
928 return -EIO;
929}
930
931static int
932w6692_l2l1B(struct mISDNchannel *ch, struct sk_buff *skb)
933{
934 struct bchannel *bch = container_of(ch, struct bchannel, ch);
935 struct w6692_ch *bc = container_of(bch, struct w6692_ch, bch);
936 struct w6692_hw *card = bch->hw;
937 int ret = -EINVAL;
938 struct mISDNhead *hh = mISDN_HEAD_P(skb);
8bfddfbe 939 unsigned long flags;
707b2ce6
KK		 940
941 switch (hh->prim) {
942 case PH_DATA_REQ:
943 spin_lock_irqsave(&card->lock, flags);
944 ret = bchannel_senddata(bch, skb);
945 if (ret > 0) { /* direct TX */
707b2ce6
KK		 946 ret = 0;
947 W6692_fill_Bfifo(bc);
8bfddfbe
KK		 948 }
949 spin_unlock_irqrestore(&card->lock, flags);
707b2ce6
KK		 950 return ret;
951 case PH_ACTIVATE_REQ:
952 spin_lock_irqsave(&card->lock, flags);
953 if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags))
954 ret = w6692_mode(bc, ch->protocol);
955 else
956 ret = 0;
957 spin_unlock_irqrestore(&card->lock, flags);
958 if (!ret)
959 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
475be4d8 960 NULL, GFP_KERNEL);
707b2ce6
KK		 961 break;
962 case PH_DEACTIVATE_REQ:
963 spin_lock_irqsave(&card->lock, flags);
964 mISDN_clear_bchannel(bch);
965 w6692_mode(bc, ISDN_P_NONE);
966 spin_unlock_irqrestore(&card->lock, flags);
967 _queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
475be4d8 968 NULL, GFP_KERNEL);
707b2ce6
KK		 969 ret = 0;
970 break;
971 default:
972 pr_info("%s: %s unknown prim(%x,%x)\n",
973 card->name, __func__, hh->prim, hh->id);
974 ret = -EINVAL;
975 }
976 if (!ret)
977 dev_kfree_skb(skb);
978 return ret;
979}
980
981static int
982channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
983{
034005a0 984 return mISDN_ctrl_bchannel(bch, cq);
707b2ce6
KK		 985}
986
987static int
988open_bchannel(struct w6692_hw *card, struct channel_req *rq)
989{
990 struct bchannel *bch;
991
819a1008 992 if (rq->adr.channel == 0 || rq->adr.channel > 2)
707b2ce6
KK		 993 return -EINVAL;
994 if (rq->protocol == ISDN_P_NONE)
995 return -EINVAL;
996 bch = &card->bc[rq->adr.channel - 1].bch;
997 if (test_and_set_bit(FLG_OPEN, &bch->Flags))
998 return -EBUSY; /* b-channel can be only open once */
707b2ce6
KK		 999 bch->ch.protocol = rq->protocol;
1000 rq->ch = &bch->ch;
1001 return 0;
1002}
1003
1004static int
1005channel_ctrl(struct w6692_hw *card, struct mISDN_ctrl_req *cq)
1006{
1007 int ret = 0;
1008
1009 switch (cq->op) {
1010 case MISDN_CTRL_GETOP:
c626c127
KK		 1011 cq->op = MISDN_CTRL_L1_TIMER3;
1012 break;
1013 case MISDN_CTRL_L1_TIMER3:
1014 ret = l1_event(card->dch.l1, HW_TIMER3_VALUE | (cq->p1 & 0xff));
707b2ce6
KK		 1015 break;
1016 default:
1017 pr_info("%s: unknown CTRL OP %x\n", card->name, cq->op);
1018 ret = -EINVAL;
1019 break;
1020 }
1021 return ret;
1022}
1023
1024static int
1025w6692_bctrl(struct mISDNchannel *ch, u32 cmd, void *arg)
1026{
1027 struct bchannel *bch = container_of(ch, struct bchannel, ch);
1028 struct w6692_ch *bc = container_of(bch, struct w6692_ch, bch);
1029 struct w6692_hw *card = bch->hw;
1030 int ret = -EINVAL;
1031 u_long flags;
1032
1033 pr_debug("%s: %s cmd:%x %p\n", card->name, __func__, cmd, arg);
1034 switch (cmd) {
1035 case CLOSE_CHANNEL:
1036 test_and_clear_bit(FLG_OPEN, &bch->Flags);
4b921eda 1037 cancel_work_sync(&bch->workq);
1368112c 1038 spin_lock_irqsave(&card->lock, flags);
4b921eda 1039 mISDN_clear_bchannel(bch);
1368112c
KK		 1040 w6692_mode(bc, ISDN_P_NONE);
1041 spin_unlock_irqrestore(&card->lock, flags);
707b2ce6
KK		 1042 ch->protocol = ISDN_P_NONE;
1043 ch->peer = NULL;
1044 module_put(THIS_MODULE);
1045 ret = 0;
1046 break;
1047 case CONTROL_CHANNEL:
1048 ret = channel_bctrl(bch, arg);
1049 break;
1050 default:
1051 pr_info("%s: %s unknown prim(%x)\n",
1052 card->name, __func__, cmd);
1053 }
1054 return ret;
1055}
1056
1057static int
1058w6692_l2l1D(struct mISDNchannel *ch, struct sk_buff *skb)
1059{
1060 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
1061 struct dchannel *dch = container_of(dev, struct dchannel, dev);
1062 struct w6692_hw *card = container_of(dch, struct w6692_hw, dch);
1063 int ret = -EINVAL;
1064 struct mISDNhead *hh = mISDN_HEAD_P(skb);
1065 u32 id;
1066 u_long flags;
1067
1068 switch (hh->prim) {
1069 case PH_DATA_REQ:
1070 spin_lock_irqsave(&card->lock, flags);
1071 ret = dchannel_senddata(dch, skb);
1072 if (ret > 0) { /* direct TX */
1073 id = hh->id; /* skb can be freed */
1074 W6692_fill_Dfifo(card);
1075 ret = 0;
1076 spin_unlock_irqrestore(&card->lock, flags);
1077 queue_ch_frame(ch, PH_DATA_CNF, id, NULL);
1078 } else
1079 spin_unlock_irqrestore(&card->lock, flags);
1080 return ret;
1081 case PH_ACTIVATE_REQ:
1082 ret = l1_event(dch->l1, hh->prim);
1083 break;
1084 case PH_DEACTIVATE_REQ:
1085 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
1086 ret = l1_event(dch->l1, hh->prim);
1087 break;
1088 }
1089
1090 if (!ret)
1091 dev_kfree_skb(skb);
1092 return ret;
1093}
1094
1095static int
1096w6692_l1callback(struct dchannel *dch, u32 cmd)
1097{
1098 struct w6692_hw *card = container_of(dch, struct w6692_hw, dch);
1099 u_long flags;
1100
1101 pr_debug("%s: cmd(%x) state(%02x)\n", card->name, cmd, card->state);
1102 switch (cmd) {
1103 case INFO3_P8:
1104 spin_lock_irqsave(&card->lock, flags);
1105 ph_command(card, W_L1CMD_AR8);
1106 spin_unlock_irqrestore(&card->lock, flags);
1107 break;
1108 case INFO3_P10:
1109 spin_lock_irqsave(&card->lock, flags);
1110 ph_command(card, W_L1CMD_AR10);
1111 spin_unlock_irqrestore(&card->lock, flags);
1112 break;
1113 case HW_RESET_REQ:
1114 spin_lock_irqsave(&card->lock, flags);
1115 if (card->state != W_L1IND_DRD)
1116 ph_command(card, W_L1CMD_RST);
1117 ph_command(card, W_L1CMD_ECK);
1118 spin_unlock_irqrestore(&card->lock, flags);
1119 break;
1120 case HW_DEACT_REQ:
1121 skb_queue_purge(&dch->squeue);
1122 if (dch->tx_skb) {
1123 dev_kfree_skb(dch->tx_skb);
1124 dch->tx_skb = NULL;
1125 }
1126 dch->tx_idx = 0;
1127 if (dch->rx_skb) {
1128 dev_kfree_skb(dch->rx_skb);
1129 dch->rx_skb = NULL;
1130 }
1131 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
1132 if (test_and_clear_bit(FLG_BUSY_TIMER, &dch->Flags))
1133 del_timer(&dch->timer);
1134 break;
1135 case HW_POWERUP_REQ:
1136 spin_lock_irqsave(&card->lock, flags);
1137 ph_command(card, W_L1CMD_ECK);
1138 spin_unlock_irqrestore(&card->lock, flags);
1139 break;
1140 case PH_ACTIVATE_IND:
1141 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
1142 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
475be4d8 1143 GFP_ATOMIC);
707b2ce6
KK		 1144 break;
1145 case PH_DEACTIVATE_IND:
1146 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
1147 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
475be4d8 1148 GFP_ATOMIC);
707b2ce6
KK		 1149 break;
1150 default:
1151 pr_debug("%s: %s unknown command %x\n", card->name,
475be4d8 1152 __func__, cmd);
707b2ce6
KK		 1153 return -1;
1154 }
1155 return 0;
1156}
1157
1158static int
3e7a8716 1159open_dchannel(struct w6692_hw *card, struct channel_req *rq, void *caller)
707b2ce6
KK		 1160{
1161 pr_debug("%s: %s dev(%d) open from %p\n", card->name, __func__,
3e7a8716 1162 card->dch.dev.id, caller);
707b2ce6
KK		 1163 if (rq->protocol != ISDN_P_TE_S0)
1164 return -EINVAL;
1165 if (rq->adr.channel == 1)
1166 /* E-Channel not supported */
1167 return -EINVAL;
1168 rq->ch = &card->dch.dev.D;
1169 rq->ch->protocol = rq->protocol;
1170 if (card->dch.state == 7)
1171 _queue_data(rq->ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
475be4d8 1172 0, NULL, GFP_KERNEL);
707b2ce6
KK		 1173 return 0;
1174}
1175
1176static int
1177w6692_dctrl(struct mISDNchannel *ch, u32 cmd, void *arg)
1178{
1179 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
1180 struct dchannel *dch = container_of(dev, struct dchannel, dev);
1181 struct w6692_hw *card = container_of(dch, struct w6692_hw, dch);
1182 struct channel_req *rq;
1183 int err = 0;
1184
1185 pr_debug("%s: DCTRL: %x %p\n", card->name, cmd, arg);
1186 switch (cmd) {
1187 case OPEN_CHANNEL:
1188 rq = arg;
1189 if (rq->protocol == ISDN_P_TE_S0)
3e7a8716 1190 err = open_dchannel(card, rq, __builtin_return_address(0));
707b2ce6
KK		 1191 else
1192 err = open_bchannel(card, rq);
1193 if (err)
1194 break;
1195 if (!try_module_get(THIS_MODULE))
1196 pr_info("%s: cannot get module\n", card->name);
1197 break;
1198 case CLOSE_CHANNEL:
1199 pr_debug("%s: dev(%d) close from %p\n", card->name,
475be4d8 1200 dch->dev.id, __builtin_return_address(0));
707b2ce6
KK		 1201 module_put(THIS_MODULE);
1202 break;
1203 case CONTROL_CHANNEL:
1204 err = channel_ctrl(card, arg);
1205 break;
1206 default:
1207 pr_debug("%s: unknown DCTRL command %x\n", card->name, cmd);
1208 return -EINVAL;
1209 }
1210 return err;
1211}
1212
70034918 1213static int
707b2ce6
KK		 1214setup_w6692(struct w6692_hw *card)
1215{
1216 u32 val;
1217
1218 if (!request_region(card->addr, 256, card->name)) {
1219 pr_info("%s: config port %x-%x already in use\n", card->name,
475be4d8 1220 card->addr, card->addr + 255);
707b2ce6
KK		 1221 return -EIO;
1222 }
1223 W6692Version(card);
1224 card->bc[0].addr = card->addr;
1225 card->bc[1].addr = card->addr + 0x40;
1226 val = ReadW6692(card, W_ISTA);
1227 if (debug & DEBUG_HW)
1228 pr_notice("%s ISTA=%02x\n", card->name, val);
1229 val = ReadW6692(card, W_IMASK);
1230 if (debug & DEBUG_HW)
1231 pr_notice("%s IMASK=%02x\n", card->name, val);
1232 val = ReadW6692(card, W_D_EXIR);
1233 if (debug & DEBUG_HW)
1234 pr_notice("%s D_EXIR=%02x\n", card->name, val);
1235 val = ReadW6692(card, W_D_EXIM);
1236 if (debug & DEBUG_HW)
1237 pr_notice("%s D_EXIM=%02x\n", card->name, val);
1238 val = ReadW6692(card, W_D_RSTA);
1239 if (debug & DEBUG_HW)
1240 pr_notice("%s D_RSTA=%02x\n", card->name, val);
1241 return 0;
1242}
1243
1244static void
1245release_card(struct w6692_hw *card)
1246{
1247 u_long flags;
1248
1249 spin_lock_irqsave(&card->lock, flags);
1250 disable_hwirq(card);
1251 w6692_mode(&card->bc[0], ISDN_P_NONE);
1252 w6692_mode(&card->bc[1], ISDN_P_NONE);
1253 if ((card->fmask & led) || card->subtype == W6692_USR) {
1254 card->xdata |= 0x04; /* LED OFF */
1255 WriteW6692(card, W_XDATA, card->xdata);
1256 }
1257 spin_unlock_irqrestore(&card->lock, flags);
1258 free_irq(card->irq, card);
1259 l1_event(card->dch.l1, CLOSE_CHANNEL);
1260 mISDN_unregister_device(&card->dch.dev);
1261 release_region(card->addr, 256);
1262 mISDN_freebchannel(&card->bc[1].bch);
1263 mISDN_freebchannel(&card->bc[0].bch);
1264 mISDN_freedchannel(&card->dch);
1265 write_lock_irqsave(&card_lock, flags);
1266 list_del(&card->list);
1267 write_unlock_irqrestore(&card_lock, flags);
1268 pci_disable_device(card->pdev);
1269 pci_set_drvdata(card->pdev, NULL);
1270 kfree(card);
1271}
1272
1273static int
1274setup_instance(struct w6692_hw *card)
1275{
1276 int i, err;
1277 u_long flags;
1278
1279 snprintf(card->name, MISDN_MAX_IDLEN - 1, "w6692.%d", w6692_cnt + 1);
1280 write_lock_irqsave(&card_lock, flags);
1281 list_add_tail(&card->list, &Cards);
1282 write_unlock_irqrestore(&card_lock, flags);
1283 card->fmask = (1 << w6692_cnt);
1284 _set_debug(card);
1285 spin_lock_init(&card->lock);
1286 mISDN_initdchannel(&card->dch, MAX_DFRAME_LEN_L1, W6692_ph_bh);
1287 card->dch.dev.Dprotocols = (1 << ISDN_P_TE_S0);
1288 card->dch.dev.D.send = w6692_l2l1D;
1289 card->dch.dev.D.ctrl = w6692_dctrl;
1290 card->dch.dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1291 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1292 card->dch.hw = card;
1293 card->dch.dev.nrbchan = 2;
1294 for (i = 0; i < 2; i++) {
034005a0
KK		 1295 mISDN_initbchannel(&card->bc[i].bch, MAX_DATA_MEM,
1296 W_B_FIFO_THRESH);
707b2ce6
KK		 1297 card->bc[i].bch.hw = card;
1298 card->bc[i].bch.nr = i + 1;
1299 card->bc[i].bch.ch.nr = i + 1;
1300 card->bc[i].bch.ch.send = w6692_l2l1B;
1301 card->bc[i].bch.ch.ctrl = w6692_bctrl;
1302 set_channelmap(i + 1, card->dch.dev.channelmap);
1303 list_add(&card->bc[i].bch.ch.list, &card->dch.dev.bchannels);
1304 }
1305 err = setup_w6692(card);
1306 if (err)
1307 goto error_setup;
1308 err = mISDN_register_device(&card->dch.dev, &card->pdev->dev,
475be4d8 1309 card->name);
707b2ce6
KK		 1310 if (err)
1311 goto error_reg;
1312 err = init_card(card);
1313 if (err)
1314 goto error_init;
1315 err = create_l1(&card->dch, w6692_l1callback);
1316 if (!err) {
1317 w6692_cnt++;
1318 pr_notice("W6692 %d cards installed\n", w6692_cnt);
1319 return 0;
1320 }
1321
1322 free_irq(card->irq, card);
1323error_init:
1324 mISDN_unregister_device(&card->dch.dev);
1325error_reg:
1326 release_region(card->addr, 256);
1327error_setup:
1328 mISDN_freebchannel(&card->bc[1].bch);
1329 mISDN_freebchannel(&card->bc[0].bch);
1330 mISDN_freedchannel(&card->dch);
1331 write_lock_irqsave(&card_lock, flags);
1332 list_del(&card->list);
1333 write_unlock_irqrestore(&card_lock, flags);
1334 kfree(card);
1335 return err;
1336}
1337
ed5a84cd 1338static int
707b2ce6
KK		 1339w6692_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1340{
1341 int err = -ENOMEM;
1342 struct w6692_hw *card;
1343 struct w6692map *m = (struct w6692map *)ent->driver_data;
1344
1345 card = kzalloc(sizeof(struct w6692_hw), GFP_KERNEL);
1346 if (!card) {
1347 pr_info("No kmem for w6692 card\n");
1348 return err;
1349 }
1350 card->pdev = pdev;
1351 card->subtype = m->subtype;
1352 err = pci_enable_device(pdev);
1353 if (err) {
1354 kfree(card);
1355 return err;
1356 }
1357
1358 printk(KERN_INFO "mISDN_w6692: found adapter %s at %s\n",
1359 m->name, pci_name(pdev));
1360
1361 card->addr = pci_resource_start(pdev, 1);
1362 card->irq = pdev->irq;
1363 pci_set_drvdata(pdev, card);
1364 err = setup_instance(card);
1365 if (err)
1366 pci_set_drvdata(pdev, NULL);
1367 return err;
1368}
1369
ed5a84cd 1370static void
707b2ce6
KK		 1371w6692_remove_pci(struct pci_dev *pdev)
1372{
1373 struct w6692_hw *card = pci_get_drvdata(pdev);
1374
1375 if (card)
1376 release_card(card);
1377 else
1378 if (debug)
698f9315 1379 pr_notice("%s: drvdata already removed\n", __func__);
707b2ce6
KK		 1380}
1381
e8336ed0 1382static const struct pci_device_id w6692_ids[] = {
707b2ce6
KK		 1383 { PCI_VENDOR_ID_DYNALINK, PCI_DEVICE_ID_DYNALINK_IS64PH,
1384 PCI_ANY_ID, PCI_ANY_ID, 0, 0, (ulong)&w6692_map[0]},
1385 { PCI_VENDOR_ID_WINBOND2, PCI_DEVICE_ID_WINBOND2_6692,
1386 PCI_VENDOR_ID_USR, PCI_DEVICE_ID_USR_6692, 0, 0,
1387 (ulong)&w6692_map[2]},
1388 { PCI_VENDOR_ID_WINBOND2, PCI_DEVICE_ID_WINBOND2_6692,
1389 PCI_ANY_ID, PCI_ANY_ID, 0, 0, (ulong)&w6692_map[1]},
1390 { }
1391};
1392MODULE_DEVICE_TABLE(pci, w6692_ids);
1393
1394static struct pci_driver w6692_driver = {
1395 .name = "w6692",
1396 .probe = w6692_probe,
ed5a84cd 1397 .remove = w6692_remove_pci,
707b2ce6
KK		 1398 .id_table = w6692_ids,
1399};
1400
1401static int __init w6692_init(void)
1402{
1403 int err;
1404
1405 pr_notice("Winbond W6692 PCI driver Rev. %s\n", W6692_REV);
1406
1407 err = pci_register_driver(&w6692_driver);
1408 return err;
1409}
1410
1411static void __exit w6692_cleanup(void)
1412{
1413 pci_unregister_driver(&w6692_driver);
1414}
1415
1416module_init(w6692_init);
1417module_exit(w6692_cleanup);
Linux 6.x block layer and io_uring tree(s)