blob: 89342f7e0c5b700eb302484ba5eb556ccadacef9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* gerdes_amd7930.c,v 0.99 2001/10/02
2 *
3 * gerdes_amd7930.c Amd 79C30A and 79C32A specific routines
4 * (based on HiSax driver by Karsten Keil)
5 *
6 * Author Christoph Ersfeld <info@formula-n.de>
7 * Formula-n Europe AG (www.formula-n.com)
8 * previously Gerdes AG
9 *
10 *
11 * This file is (c) under GNU PUBLIC LICENSE
12 *
13 *
14 * Notes:
15 * Version 0.99 is the first release of this driver and there are
16 * certainly a few bugs.
17 *
18 * Please don't report any malfunction to me without sending
19 * (compressed) debug-logs.
20 * It would be nearly impossible to retrace it.
21 *
22 * Log D-channel-processing as follows:
23 *
24 * 1. Load hisax with card-specific parameters, this example ist for
25 * Formula-n enter:now ISDN PCI and compatible
26 * (f.e. Gerdes Power ISDN PCI)
27 *
28 * modprobe hisax type=41 protocol=2 id=gerdes
29 *
30 * if you chose an other value for id, you need to modify the
31 * code below, too.
32 *
33 * 2. set debug-level
34 *
35 * hisaxctrl gerdes 1 0x3ff
36 * hisaxctrl gerdes 11 0x4f
37 * cat /dev/isdnctrl >> ~/log &
38 *
39 * Please take also a look into /var/log/messages if there is
40 * anything importand concerning HISAX.
41 *
42 *
43 * Credits:
44 * Programming the driver for Formula-n enter:now ISDN PCI and
45 * necessary this driver for the used Amd 7930 D-channel-controller
46 * was spnsored by Formula-n Europe AG.
47 * Thanks to Karsten Keil and Petr Novak, who gave me support in
48 * Hisax-specific questions.
49 * I want so say special thanks to Carl-Friedrich Braun, who had to
50 * answer a lot of questions about generally ISDN and about handling
51 * of the Amd-Chip.
52 *
53 */
54
55
56#include "hisax.h"
57#include "isdnl1.h"
58#include "isac.h"
59#include "amd7930_fn.h"
60#include <linux/interrupt.h>
61#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090062#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64static void Amd7930_new_ph(struct IsdnCardState *cs);
65
66static WORD initAMD[] = {
67 0x0100,
68
69 0x00A5, 3, 0x01, 0x40, 0x58, // LPR, LMR1, LMR2
70 0x0086, 1, 0x0B, // DMR1 (D-Buffer TH-Interrupts on)
71 0x0087, 1, 0xFF, // DMR2
72 0x0092, 1, 0x03, // EFCR (extended mode d-channel-fifo on)
73 0x0090, 4, 0xFE, 0xFF, 0x02, 0x0F, // FRAR4, SRAR4, DMR3, DMR4 (address recognition )
74 0x0084, 2, 0x80, 0x00, // DRLR
75 0x00C0, 1, 0x47, // PPCR1
76 0x00C8, 1, 0x01, // PPCR2
77
78 0x0102,
79 0x0107,
80 0x01A1, 1,
81 0x0121, 1,
82 0x0189, 2,
83
84 0x0045, 4, 0x61, 0x72, 0x00, 0x00, // MCR1, MCR2, MCR3, MCR4
85 0x0063, 2, 0x08, 0x08, // GX
86 0x0064, 2, 0x08, 0x08, // GR
87 0x0065, 2, 0x99, 0x00, // GER
88 0x0066, 2, 0x7C, 0x8B, // STG
89 0x0067, 2, 0x00, 0x00, // FTGR1, FTGR2
90 0x0068, 2, 0x20, 0x20, // ATGR1, ATGR2
91 0x0069, 1, 0x4F, // MMR1
92 0x006A, 1, 0x00, // MMR2
93 0x006C, 1, 0x40, // MMR3
94 0x0021, 1, 0x02, // INIT
95 0x00A3, 1, 0x40, // LMR1
96
97 0xFFFF
98};
99
100
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700101static void /* macro wWordAMD */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102WriteWordAmd7930(struct IsdnCardState *cs, BYTE reg, WORD val)
103{
Joe Perches475be4d2012-02-19 19:52:38 -0800104 wByteAMD(cs, 0x00, reg);
105 wByteAMD(cs, 0x01, LOBYTE(val));
106 wByteAMD(cs, 0x01, HIBYTE(val));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700109static WORD /* macro rWordAMD */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110ReadWordAmd7930(struct IsdnCardState *cs, BYTE reg)
111{
Joe Perches475be4d2012-02-19 19:52:38 -0800112 WORD res;
113 /* direct access register */
114 if (reg < 8) {
115 res = rByteAMD(cs, reg);
116 res += 256 * rByteAMD(cs, reg);
117 }
118 /* indirect access register */
119 else {
120 wByteAMD(cs, 0x00, reg);
121 res = rByteAMD(cs, 0x01);
122 res += 256 * rByteAMD(cs, 0x01);
123 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 return (res);
125}
126
127
128static void
129Amd7930_ph_command(struct IsdnCardState *cs, u_char command, char *s)
130{
131 if (cs->debug & L1_DEB_ISAC)
132 debugl1(cs, "AMD7930: %s: ph_command 0x%02X", s, command);
133
Joe Perches475be4d2012-02-19 19:52:38 -0800134 cs->dc.amd7930.lmr1 = command;
135 wByteAMD(cs, 0xA3, command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
138
139
140static BYTE i430States[] = {
141// to reset F3 F4 F5 F6 F7 F8 AR from
Joe Perches475be4d2012-02-19 19:52:38 -0800142 0x01, 0x02, 0x00, 0x00, 0x00, 0x07, 0x05, 0x00, // init
143 0x01, 0x02, 0x00, 0x00, 0x00, 0x07, 0x05, 0x00, // reset
144 0x01, 0x02, 0x00, 0x00, 0x00, 0x09, 0x05, 0x04, // F3
145 0x01, 0x02, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, // F4
146 0x01, 0x02, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, // F5
147 0x01, 0x03, 0x00, 0x00, 0x00, 0x06, 0x05, 0x00, // F6
148 0x11, 0x13, 0x00, 0x00, 0x1B, 0x00, 0x15, 0x00, // F7
149 0x01, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, // F8
150 0x01, 0x03, 0x00, 0x00, 0x00, 0x09, 0x00, 0x0A}; // AR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152
153/* Row init - reset F3 F4 F5 F6 F7 F8 AR */
154static BYTE stateHelper[] = { 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
155
156
157
158
159static void
160Amd7930_get_state(struct IsdnCardState *cs) {
Joe Perches475be4d2012-02-19 19:52:38 -0800161 BYTE lsr = rByteAMD(cs, 0xA1);
162 cs->dc.amd7930.ph_state = (lsr & 0x7) + 2;
163 Amd7930_new_ph(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
165
166
167
168static void
169Amd7930_new_ph(struct IsdnCardState *cs)
170{
Joe Perches475be4d2012-02-19 19:52:38 -0800171 u_char index = stateHelper[cs->dc.amd7930.old_state] * 8 + stateHelper[cs->dc.amd7930.ph_state] - 1;
172 u_char message = i430States[index];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Joe Perches475be4d2012-02-19 19:52:38 -0800174 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 debugl1(cs, "AMD7930: new_ph %d, old_ph %d, message %d, index %d",
Joe Perches475be4d2012-02-19 19:52:38 -0800176 cs->dc.amd7930.ph_state, cs->dc.amd7930.old_state, message & 0x0f, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
Joe Perches475be4d2012-02-19 19:52:38 -0800178 cs->dc.amd7930.old_state = cs->dc.amd7930.ph_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Joe Perches475be4d2012-02-19 19:52:38 -0800180 /* abort transmit if nessesary */
181 if ((message & 0xf0) && (cs->tx_skb)) {
182 wByteAMD(cs, 0x21, 0xC2);
183 wByteAMD(cs, 0x21, 0x02);
184 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
186 switch (message & 0x0f) {
187
Joe Perches475be4d2012-02-19 19:52:38 -0800188 case (1):
189 l1_msg(cs, HW_RESET | INDICATION, NULL);
190 Amd7930_get_state(cs);
191 break;
192 case (2): /* init, Card starts in F3 */
193 l1_msg(cs, HW_DEACTIVATE | CONFIRM, NULL);
194 break;
195 case (3):
196 l1_msg(cs, HW_DEACTIVATE | INDICATION, NULL);
197 break;
198 case (4):
199 l1_msg(cs, HW_POWERUP | CONFIRM, NULL);
200 Amd7930_ph_command(cs, 0x50, "HW_ENABLE REQUEST");
201 break;
202 case (5):
203 l1_msg(cs, HW_RSYNC | INDICATION, NULL);
204 break;
205 case (6):
206 l1_msg(cs, HW_INFO4_P8 | INDICATION, NULL);
207 break;
208 case (7): /* init, Card starts in F7 */
209 l1_msg(cs, HW_RSYNC | INDICATION, NULL);
210 l1_msg(cs, HW_INFO4_P8 | INDICATION, NULL);
211 break;
212 case (8):
213 l1_msg(cs, HW_POWERUP | CONFIRM, NULL);
214 /* fall through */
215 case (9):
216 Amd7930_ph_command(cs, 0x40, "HW_ENABLE REQ cleared if set");
217 l1_msg(cs, HW_RSYNC | INDICATION, NULL);
218 l1_msg(cs, HW_INFO2 | INDICATION, NULL);
219 l1_msg(cs, HW_INFO4_P8 | INDICATION, NULL);
220 break;
221 case (10):
222 Amd7930_ph_command(cs, 0x40, "T3 expired, HW_ENABLE REQ cleared");
223 cs->dc.amd7930.old_state = 3;
224 break;
225 case (11):
226 l1_msg(cs, HW_INFO2 | INDICATION, NULL);
227 break;
228 default:
229 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 }
231}
232
233
234
235static void
David Howellsc4028952006-11-22 14:57:56 +0000236Amd7930_bh(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237{
David Howellsc4028952006-11-22 14:57:56 +0000238 struct IsdnCardState *cs =
239 container_of(work, struct IsdnCardState, tqueue);
Joe Perches475be4d2012-02-19 19:52:38 -0800240 struct PStack *stptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 if (test_and_clear_bit(D_CLEARBUSY, &cs->event)) {
Joe Perches475be4d2012-02-19 19:52:38 -0800243 if (cs->debug)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 debugl1(cs, "Amd7930: bh, D-Channel Busy cleared");
245 stptr = cs->stlist;
246 while (stptr != NULL) {
247 stptr->l1.l1l2(stptr, PH_PAUSE | CONFIRM, NULL);
248 stptr = stptr->next;
249 }
250 }
251 if (test_and_clear_bit(D_L1STATECHANGE, &cs->event)) {
Joe Perches475be4d2012-02-19 19:52:38 -0800252 if (cs->debug & L1_DEB_ISAC)
253 debugl1(cs, "AMD7930: bh, D_L1STATECHANGE");
254 Amd7930_new_ph(cs);
255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Joe Perches475be4d2012-02-19 19:52:38 -0800257 if (test_and_clear_bit(D_RCVBUFREADY, &cs->event)) {
258 if (cs->debug & L1_DEB_ISAC)
259 debugl1(cs, "AMD7930: bh, D_RCVBUFREADY");
260 DChannel_proc_rcv(cs);
261 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Joe Perches475be4d2012-02-19 19:52:38 -0800263 if (test_and_clear_bit(D_XMTBUFREADY, &cs->event)) {
264 if (cs->debug & L1_DEB_ISAC)
265 debugl1(cs, "AMD7930: bh, D_XMTBUFREADY");
266 DChannel_proc_xmt(cs);
267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
270static void
271Amd7930_empty_Dfifo(struct IsdnCardState *cs, int flag)
272{
273
Joe Perches475be4d2012-02-19 19:52:38 -0800274 BYTE stat, der;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 BYTE *ptr;
276 struct sk_buff *skb;
277
278
279 if ((cs->debug & L1_DEB_ISAC) && !(cs->debug & L1_DEB_ISAC_FIFO))
280 debugl1(cs, "Amd7930: empty_Dfifo");
281
282
283 ptr = cs->rcvbuf + cs->rcvidx;
284
285 /* AMD interrupts off */
286 AmdIrqOff(cs);
287
288 /* read D-Channel-Fifo*/
289 stat = rByteAMD(cs, 0x07); // DSR2
290
Joe Perches475be4d2012-02-19 19:52:38 -0800291 /* while Data in Fifo ... */
292 while ((stat & 2) && ((ptr-cs->rcvbuf) < MAX_DFRAME_LEN_L1)) {
293 *ptr = rByteAMD(cs, 0x04); // DCRB
294 ptr++;
295 stat = rByteAMD(cs, 0x07); // DSR2
296 cs->rcvidx = ptr - cs->rcvbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Joe Perches475be4d2012-02-19 19:52:38 -0800298 /* Paket ready? */
299 if (stat & 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
Joe Perches475be4d2012-02-19 19:52:38 -0800301 der = rWordAMD(cs, 0x03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Joe Perches475be4d2012-02-19 19:52:38 -0800303 /* no errors, packet ok */
304 if (!der && !flag) {
305 rWordAMD(cs, 0x89); // clear DRCR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Joe Perches475be4d2012-02-19 19:52:38 -0800307 if ((cs->rcvidx) > 0) {
308 if (!(skb = alloc_skb(cs->rcvidx, GFP_ATOMIC)))
309 printk(KERN_WARNING "HiSax: Amd7930: empty_Dfifo, D receive out of memory!\n");
310 else {
311 /* Debugging */
312 if (cs->debug & L1_DEB_ISAC_FIFO) {
313 char *t = cs->dlog;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Joe Perches475be4d2012-02-19 19:52:38 -0800315 t += sprintf(t, "Amd7930: empty_Dfifo cnt: %d |", cs->rcvidx);
316 QuickHex(t, cs->rcvbuf, cs->rcvidx);
317 debugl1(cs, cs->dlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
Joe Perches475be4d2012-02-19 19:52:38 -0800319 /* moves received data in sk-buffer */
320 memcpy(skb_put(skb, cs->rcvidx), cs->rcvbuf, cs->rcvidx);
321 skb_queue_tail(&cs->rq, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 }
Joe Perches475be4d2012-02-19 19:52:38 -0800324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 }
Joe Perches475be4d2012-02-19 19:52:38 -0800326 /* throw damaged packets away, reset receive-buffer, indicate RX */
327 ptr = cs->rcvbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 cs->rcvidx = 0;
Joe Perches475be4d2012-02-19 19:52:38 -0800329 schedule_event(cs, D_RCVBUFREADY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 }
Joe Perches475be4d2012-02-19 19:52:38 -0800331 }
332 /* Packet to long, overflow */
333 if (cs->rcvidx >= MAX_DFRAME_LEN_L1) {
334 if (cs->debug & L1_DEB_WARN)
335 debugl1(cs, "AMD7930: empty_Dfifo L2-Framelength overrun");
336 cs->rcvidx = 0;
337 return;
338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 /* AMD interrupts on */
340 AmdIrqOn(cs);
341}
342
343
344static void
345Amd7930_fill_Dfifo(struct IsdnCardState *cs)
346{
347
Joe Perches475be4d2012-02-19 19:52:38 -0800348 WORD dtcrr, dtcrw, len, count;
349 BYTE txstat, dmr3;
350 BYTE *ptr, *deb_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 if ((cs->debug & L1_DEB_ISAC) && !(cs->debug & L1_DEB_ISAC_FIFO))
353 debugl1(cs, "Amd7930: fill_Dfifo");
354
355 if ((!cs->tx_skb) || (cs->tx_skb->len <= 0))
356 return;
357
Joe Perches475be4d2012-02-19 19:52:38 -0800358 dtcrw = 0;
359 if (!cs->dc.amd7930.tx_xmtlen)
360 /* new Frame */
361 len = dtcrw = cs->tx_skb->len;
362 /* continue frame */
363 else len = cs->dc.amd7930.tx_xmtlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365
366 /* AMD interrupts off */
367 AmdIrqOff(cs);
368
Joe Perches475be4d2012-02-19 19:52:38 -0800369 deb_ptr = ptr = cs->tx_skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Joe Perches475be4d2012-02-19 19:52:38 -0800371 /* while free place in tx-fifo available and data in sk-buffer */
372 txstat = 0x10;
373 while ((txstat & 0x10) && (cs->tx_cnt < len)) {
374 wByteAMD(cs, 0x04, *ptr);
375 ptr++;
376 cs->tx_cnt++;
377 txstat = rByteAMD(cs, 0x07);
378 }
379 count = ptr - cs->tx_skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 skb_pull(cs->tx_skb, count);
381
382
Joe Perches475be4d2012-02-19 19:52:38 -0800383 dtcrr = rWordAMD(cs, 0x85); // DTCR
384 dmr3 = rByteAMD(cs, 0x8E);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
386 if (cs->debug & L1_DEB_ISAC) {
387 debugl1(cs, "Amd7930: fill_Dfifo, DMR3: 0x%02X, DTCR read: 0x%04X write: 0x%02X 0x%02X", dmr3, dtcrr, LOBYTE(dtcrw), HIBYTE(dtcrw));
Joe Perches475be4d2012-02-19 19:52:38 -0800388 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Joe Perches475be4d2012-02-19 19:52:38 -0800390 /* writeing of dtcrw starts transmit */
391 if (!cs->dc.amd7930.tx_xmtlen) {
392 wWordAMD(cs, 0x85, dtcrw);
393 cs->dc.amd7930.tx_xmtlen = dtcrw;
394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 if (test_and_set_bit(FLG_DBUSY_TIMER, &cs->HW_Flags)) {
397 debugl1(cs, "Amd7930: fill_Dfifo dbusytimer running");
398 del_timer(&cs->dbusytimer);
399 }
400 init_timer(&cs->dbusytimer);
401 cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000);
402 add_timer(&cs->dbusytimer);
403
404 if (cs->debug & L1_DEB_ISAC_FIFO) {
405 char *t = cs->dlog;
406
407 t += sprintf(t, "Amd7930: fill_Dfifo cnt: %d |", count);
408 QuickHex(t, deb_ptr, count);
409 debugl1(cs, cs->dlog);
410 }
411 /* AMD interrupts on */
Joe Perches475be4d2012-02-19 19:52:38 -0800412 AmdIrqOn(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413}
414
415
416void Amd7930_interrupt(struct IsdnCardState *cs, BYTE irflags)
417{
418 BYTE dsr1, dsr2, lsr;
Joe Perches475be4d2012-02-19 19:52:38 -0800419 WORD der;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Joe Perches475be4d2012-02-19 19:52:38 -0800421 while (irflags)
422 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
Joe Perches475be4d2012-02-19 19:52:38 -0800424 dsr1 = rByteAMD(cs, 0x02);
425 der = rWordAMD(cs, 0x03);
426 dsr2 = rByteAMD(cs, 0x07);
427 lsr = rByteAMD(cs, 0xA1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Joe Perches475be4d2012-02-19 19:52:38 -0800429 if (cs->debug & L1_DEB_ISAC)
430 debugl1(cs, "Amd7930: interrupt: flags: 0x%02X, DSR1: 0x%02X, DSR2: 0x%02X, LSR: 0x%02X, DER=0x%04X", irflags, dsr1, dsr2, lsr, der);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Joe Perches475be4d2012-02-19 19:52:38 -0800432 /* D error -> read DER and DSR2 bit 2 */
433 if (der || (dsr2 & 4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Joe Perches475be4d2012-02-19 19:52:38 -0800435 if (cs->debug & L1_DEB_WARN)
436 debugl1(cs, "Amd7930: interrupt: D error DER=0x%04X", der);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Joe Perches475be4d2012-02-19 19:52:38 -0800438 /* RX, TX abort if collision detected */
439 if (der & 2) {
440 wByteAMD(cs, 0x21, 0xC2);
441 wByteAMD(cs, 0x21, 0x02);
442 if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
443 del_timer(&cs->dbusytimer);
444 if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
445 schedule_event(cs, D_CLEARBUSY);
446 /* restart frame */
447 if (cs->tx_skb) {
448 skb_push(cs->tx_skb, cs->tx_cnt);
449 cs->tx_cnt = 0;
450 cs->dc.amd7930.tx_xmtlen = 0;
451 Amd7930_fill_Dfifo(cs);
452 } else {
453 printk(KERN_WARNING "HiSax: Amd7930 D-Collision, no skb\n");
454 debugl1(cs, "Amd7930: interrupt: D-Collision, no skb");
455 }
456 }
457 /* remove damaged data from fifo */
458 Amd7930_empty_Dfifo(cs, 1);
459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
461 del_timer(&cs->dbusytimer);
462 if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
463 schedule_event(cs, D_CLEARBUSY);
Joe Perches475be4d2012-02-19 19:52:38 -0800464 /* restart TX-Frame */
465 if (cs->tx_skb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 skb_push(cs->tx_skb, cs->tx_cnt);
467 cs->tx_cnt = 0;
Joe Perches475be4d2012-02-19 19:52:38 -0800468 cs->dc.amd7930.tx_xmtlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 Amd7930_fill_Dfifo(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Joe Perches475be4d2012-02-19 19:52:38 -0800473 /* D TX FIFO empty -> fill */
474 if (irflags & 1) {
475 if (cs->debug & L1_DEB_ISAC)
476 debugl1(cs, "Amd7930: interrupt: clear Timer and fill D-TX-FIFO if data");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Joe Perches475be4d2012-02-19 19:52:38 -0800478 /* AMD interrupts off */
479 AmdIrqOff(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Joe Perches475be4d2012-02-19 19:52:38 -0800481 if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
482 del_timer(&cs->dbusytimer);
483 if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
484 schedule_event(cs, D_CLEARBUSY);
485 if (cs->tx_skb) {
486 if (cs->tx_skb->len)
487 Amd7930_fill_Dfifo(cs);
488 }
489 /* AMD interrupts on */
490 AmdIrqOn(cs);
491 }
492
493
494 /* D RX FIFO full or tiny packet in Fifo -> empty */
495 if ((irflags & 2) || (dsr1 & 2)) {
496 if (cs->debug & L1_DEB_ISAC)
497 debugl1(cs, "Amd7930: interrupt: empty D-FIFO");
498 Amd7930_empty_Dfifo(cs, 0);
499 }
500
501
502 /* D-Frame transmit complete */
503 if (dsr1 & 64) {
504 if (cs->debug & L1_DEB_ISAC) {
505 debugl1(cs, "Amd7930: interrupt: transmit packet ready");
506 }
507 /* AMD interrupts off */
508 AmdIrqOff(cs);
509
510 if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
511 del_timer(&cs->dbusytimer);
512 if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
513 schedule_event(cs, D_CLEARBUSY);
514
515 if (cs->tx_skb) {
516 if (cs->debug & L1_DEB_ISAC)
517 debugl1(cs, "Amd7930: interrupt: TX-Packet ready, freeing skb");
518 dev_kfree_skb_irq(cs->tx_skb);
519 cs->tx_cnt = 0;
520 cs->dc.amd7930.tx_xmtlen = 0;
521 cs->tx_skb = NULL;
522 }
523 if ((cs->tx_skb = skb_dequeue(&cs->sq))) {
524 if (cs->debug & L1_DEB_ISAC)
525 debugl1(cs, "Amd7930: interrupt: TX-Packet ready, next packet dequeued");
526 cs->tx_cnt = 0;
527 cs->dc.amd7930.tx_xmtlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 Amd7930_fill_Dfifo(cs);
Joe Perches475be4d2012-02-19 19:52:38 -0800529 }
530 else
531 schedule_event(cs, D_XMTBUFREADY);
532 /* AMD interrupts on */
533 AmdIrqOn(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Joe Perches475be4d2012-02-19 19:52:38 -0800536 /* LIU status interrupt -> read LSR, check statechanges */
537 if (lsr & 0x38) {
538 /* AMD interrupts off */
539 AmdIrqOff(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Joe Perches475be4d2012-02-19 19:52:38 -0800541 if (cs->debug & L1_DEB_ISAC)
542 debugl1(cs, "Amd: interrupt: LSR=0x%02X, LIU is in state %d", lsr, ((lsr & 0x7) + 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Joe Perches475be4d2012-02-19 19:52:38 -0800544 cs->dc.amd7930.ph_state = (lsr & 0x7) + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Joe Perches475be4d2012-02-19 19:52:38 -0800546 schedule_event(cs, D_L1STATECHANGE);
547 /* AMD interrupts on */
548 AmdIrqOn(cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
Joe Perches475be4d2012-02-19 19:52:38 -0800551 /* reads Interrupt-Register again. If there is a new interrupt-flag: restart handler */
552 irflags = rByteAMD(cs, 0x00);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 }
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
557static void
558Amd7930_l1hw(struct PStack *st, int pr, void *arg)
559{
Joe Perches475be4d2012-02-19 19:52:38 -0800560 struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 struct sk_buff *skb = arg;
562 u_long flags;
563
Joe Perches475be4d2012-02-19 19:52:38 -0800564 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 debugl1(cs, "Amd7930: l1hw called, pr: 0x%04X", pr);
566
567 switch (pr) {
Joe Perches475be4d2012-02-19 19:52:38 -0800568 case (PH_DATA | REQUEST):
569 if (cs->debug & DEB_DLOG_HEX)
570 LogFrame(cs, skb->data, skb->len);
571 if (cs->debug & DEB_DLOG_VERBOSE)
572 dlogframe(cs, skb, 0);
573 spin_lock_irqsave(&cs->lock, flags);
574 if (cs->tx_skb) {
575 skb_queue_tail(&cs->sq, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576#ifdef L2FRAME_DEBUG /* psa */
Joe Perches475be4d2012-02-19 19:52:38 -0800577 if (cs->debug & L1_DEB_LAPD)
578 Logl2Frame(cs, skb, "Amd7930: l1hw: PH_DATA Queued", 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579#endif
Joe Perches475be4d2012-02-19 19:52:38 -0800580 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 cs->tx_skb = skb;
582 cs->tx_cnt = 0;
Joe Perches475be4d2012-02-19 19:52:38 -0800583 cs->dc.amd7930.tx_xmtlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584#ifdef L2FRAME_DEBUG /* psa */
585 if (cs->debug & L1_DEB_LAPD)
Joe Perches475be4d2012-02-19 19:52:38 -0800586 Logl2Frame(cs, skb, "Amd7930: l1hw: PH_DATA", 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587#endif
588 Amd7930_fill_Dfifo(cs);
Joe Perches475be4d2012-02-19 19:52:38 -0800589 }
590 spin_unlock_irqrestore(&cs->lock, flags);
591 break;
592 case (PH_PULL | INDICATION):
593 spin_lock_irqsave(&cs->lock, flags);
594 if (cs->tx_skb) {
595 if (cs->debug & L1_DEB_WARN)
596 debugl1(cs, "Amd7930: l1hw: l2l1 tx_skb exist this shouldn't happen");
597 skb_queue_tail(&cs->sq, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 spin_unlock_irqrestore(&cs->lock, flags);
599 break;
Joe Perches475be4d2012-02-19 19:52:38 -0800600 }
601 if (cs->debug & DEB_DLOG_HEX)
602 LogFrame(cs, skb->data, skb->len);
603 if (cs->debug & DEB_DLOG_VERBOSE)
604 dlogframe(cs, skb, 0);
605 cs->tx_skb = skb;
606 cs->tx_cnt = 0;
607 cs->dc.amd7930.tx_xmtlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608#ifdef L2FRAME_DEBUG /* psa */
Joe Perches475be4d2012-02-19 19:52:38 -0800609 if (cs->debug & L1_DEB_LAPD)
610 Logl2Frame(cs, skb, "Amd7930: l1hw: PH_DATA_PULLED", 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611#endif
Joe Perches475be4d2012-02-19 19:52:38 -0800612 Amd7930_fill_Dfifo(cs);
613 spin_unlock_irqrestore(&cs->lock, flags);
614 break;
615 case (PH_PULL | REQUEST):
616#ifdef L2FRAME_DEBUG /* psa */
617 if (cs->debug & L1_DEB_LAPD)
618 debugl1(cs, "Amd7930: l1hw: -> PH_REQUEST_PULL, skb: %s", (cs->tx_skb) ? "yes" : "no");
619#endif
620 if (!cs->tx_skb) {
621 test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
622 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
623 } else
624 test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
625 break;
626 case (HW_RESET | REQUEST):
627 spin_lock_irqsave(&cs->lock, flags);
628 if ((cs->dc.amd7930.ph_state == 8)) {
629 /* b-channels off, PH-AR cleared
630 * change to F3 */
631 Amd7930_ph_command(cs, 0x20, "HW_RESET REQEST"); //LMR1 bit 5
632 spin_unlock_irqrestore(&cs->lock, flags);
633 } else {
634 Amd7930_ph_command(cs, 0x40, "HW_RESET REQUEST");
635 cs->dc.amd7930.ph_state = 2;
636 spin_unlock_irqrestore(&cs->lock, flags);
637 Amd7930_new_ph(cs);
638 }
639 break;
640 case (HW_ENABLE | REQUEST):
641 cs->dc.amd7930.ph_state = 9;
642 Amd7930_new_ph(cs);
643 break;
644 case (HW_INFO3 | REQUEST):
645 // automatic
646 break;
647 case (HW_TESTLOOP | REQUEST):
648 /* not implemented yet */
649 break;
650 case (HW_DEACTIVATE | RESPONSE):
651 skb_queue_purge(&cs->rq);
652 skb_queue_purge(&cs->sq);
653 if (cs->tx_skb) {
654 dev_kfree_skb(cs->tx_skb);
655 cs->tx_skb = NULL;
656 }
657 if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
658 del_timer(&cs->dbusytimer);
659 if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
660 schedule_event(cs, D_CLEARBUSY);
661 break;
662 default:
663 if (cs->debug & L1_DEB_WARN)
664 debugl1(cs, "Amd7930: l1hw: unknown %04x", pr);
665 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 }
667}
668
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700669static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670setstack_Amd7930(struct PStack *st, struct IsdnCardState *cs)
671{
672
Joe Perches475be4d2012-02-19 19:52:38 -0800673 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 debugl1(cs, "Amd7930: setstack called");
675
Joe Perches475be4d2012-02-19 19:52:38 -0800676 st->l1.l1hw = Amd7930_l1hw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677}
678
679
Adrian Bunk672c3fd2005-06-25 14:59:18 -0700680static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681DC_Close_Amd7930(struct IsdnCardState *cs) {
Joe Perches475be4d2012-02-19 19:52:38 -0800682 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 debugl1(cs, "Amd7930: DC_Close called");
684}
685
686
687static void
688dbusy_timer_handler(struct IsdnCardState *cs)
689{
690 u_long flags;
691 struct PStack *stptr;
Joe Perches475be4d2012-02-19 19:52:38 -0800692 WORD dtcr, der;
693 BYTE dsr1, dsr2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
695
Joe Perches475be4d2012-02-19 19:52:38 -0800696 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 debugl1(cs, "Amd7930: dbusy_timer expired!");
698
699 if (test_bit(FLG_DBUSY_TIMER, &cs->HW_Flags)) {
700 spin_lock_irqsave(&cs->lock, flags);
Joe Perches475be4d2012-02-19 19:52:38 -0800701 /* D Transmit Byte Count Register:
702 * Counts down packet's number of Bytes, 0 if packet ready */
703 dtcr = rWordAMD(cs, 0x85);
704 dsr1 = rByteAMD(cs, 0x02);
705 dsr2 = rByteAMD(cs, 0x07);
706 der = rWordAMD(cs, 0x03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Joe Perches475be4d2012-02-19 19:52:38 -0800708 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 debugl1(cs, "Amd7930: dbusy_timer_handler: DSR1=0x%02X, DSR2=0x%02X, DER=0x%04X, cs->tx_skb->len=%u, tx_stat=%u, dtcr=%u, cs->tx_cnt=%u", dsr1, dsr2, der, cs->tx_skb->len, cs->dc.amd7930.tx_xmtlen, dtcr, cs->tx_cnt);
710
711 if ((cs->dc.amd7930.tx_xmtlen - dtcr) < cs->tx_cnt) { /* D-Channel Busy */
712 test_and_set_bit(FLG_L1_DBUSY, &cs->HW_Flags);
713 stptr = cs->stlist;
714 spin_unlock_irqrestore(&cs->lock, flags);
715 while (stptr != NULL) {
716 stptr->l1.l1l2(stptr, PH_PAUSE | INDICATION, NULL);
717 stptr = stptr->next;
718 }
719
720 } else {
721 /* discard frame; reset transceiver */
722 test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags);
723 if (cs->tx_skb) {
724 dev_kfree_skb_any(cs->tx_skb);
725 cs->tx_cnt = 0;
726 cs->tx_skb = NULL;
Joe Perches475be4d2012-02-19 19:52:38 -0800727 cs->dc.amd7930.tx_xmtlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 } else {
729 printk(KERN_WARNING "HiSax: Amd7930: D-Channel Busy no skb\n");
730 debugl1(cs, "Amd7930: D-Channel Busy no skb");
731
732 }
733 /* Transmitter reset, abort transmit */
734 wByteAMD(cs, 0x21, 0x82);
735 wByteAMD(cs, 0x21, 0x02);
736 spin_unlock_irqrestore(&cs->lock, flags);
David Howells7d12e782006-10-05 14:55:46 +0100737 cs->irq_func(cs->irq, cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Joe Perches475be4d2012-02-19 19:52:38 -0800739 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 debugl1(cs, "Amd7930: dbusy_timer_handler: Transmitter reset");
741 }
742 }
743}
744
745
746
Sam Ravnborg054b0e22008-02-07 18:20:29 -0800747void Amd7930_init(struct IsdnCardState *cs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
Joe Perches475be4d2012-02-19 19:52:38 -0800749 WORD *ptr;
750 BYTE cmd, cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Joe Perches475be4d2012-02-19 19:52:38 -0800752 if (cs->debug & L1_DEB_ISAC)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 debugl1(cs, "Amd7930: initamd called");
754
Joe Perches475be4d2012-02-19 19:52:38 -0800755 cs->dc.amd7930.tx_xmtlen = 0;
756 cs->dc.amd7930.old_state = 0;
757 cs->dc.amd7930.lmr1 = 0x40;
758 cs->dc.amd7930.ph_command = Amd7930_ph_command;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 cs->setstack_d = setstack_Amd7930;
760 cs->DC_Close = DC_Close_Amd7930;
761
762 /* AMD Initialisation */
763 for (ptr = initAMD; *ptr != 0xFFFF; ) {
764 cmd = LOBYTE(*ptr);
765
Joe Perches475be4d2012-02-19 19:52:38 -0800766 /* read */
767 if (*ptr++ >= 0x100) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 if (cmd < 8)
Joe Perches475be4d2012-02-19 19:52:38 -0800769 /* reset register */
770 rByteAMD(cs, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 else {
772 wByteAMD(cs, 0x00, cmd);
773 for (cnt = *ptr++; cnt > 0; cnt--)
774 rByteAMD(cs, 0x01);
775 }
776 }
Joe Perches475be4d2012-02-19 19:52:38 -0800777 /* write */
778 else if (cmd < 8)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 wByteAMD(cs, cmd, LOBYTE(*ptr++));
780
781 else {
782 wByteAMD(cs, 0x00, cmd);
783 for (cnt = *ptr++; cnt > 0; cnt--)
784 wByteAMD(cs, 0x01, LOBYTE(*ptr++));
785 }
786 }
787}
788
789void __devinit
790setup_Amd7930(struct IsdnCardState *cs)
791{
Joe Perches475be4d2012-02-19 19:52:38 -0800792 INIT_WORK(&cs->tqueue, Amd7930_bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 cs->dbusytimer.function = (void *) dbusy_timer_handler;
794 cs->dbusytimer.data = (long) cs;
795 init_timer(&cs->dbusytimer);
796}