| Linux kernel & device driver programming |
| [ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] |
1 /* 1 /*
2 * PCBIT-D low-layer interface 2 * PCBIT-D low-layer interface
3 * 3 *
4 * Copyright (C) 1996 Universidade de Lisboa 4 * Copyright (C) 1996 Universidade de Lisboa
5 * 5 *
6 * Written by Pedro Roque Marques (roque@di.fc 6 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
7 * 7 *
8 * This software may be used and distributed a 8 * This software may be used and distributed according to the terms of
9 * the GNU General Public License, incorporate 9 * the GNU General Public License, incorporated herein by reference.
10 */ 10 */
11 11
12 /* 12 /*
13 * 19991203 - Fernando Carvalho - takion@super 13 * 19991203 - Fernando Carvalho - takion@superbofh.org
14 * Hacked to compile with egcs and run with cu 14 * Hacked to compile with egcs and run with current version of isdn modules
15 */ 15 */
16 16
17 /* 17 /*
18 * Based on documentation provided by I 18 * Based on documentation provided by Inesc:
19 * - "Interface com bus do PC para o PC 19 * - "Interface com bus do PC para o PCBIT e PCBIT-D", Inesc, Jan 93
20 */ 20 */
21 21
22 /* 22 /*
23 * TODO: better handling of errors 23 * TODO: better handling of errors
24 * re-write/remove debug printks 24 * re-write/remove debug printks
25 */ 25 */
26 26
27 #include <linux/string.h> 27 #include <linux/string.h>
28 #include <linux/kernel.h> 28 #include <linux/kernel.h>
29 #include <linux/types.h> 29 #include <linux/types.h>
30 #include <linux/slab.h> 30 #include <linux/slab.h>
31 #include <linux/interrupt.h> 31 #include <linux/interrupt.h>
32 #include <linux/workqueue.h> 32 #include <linux/workqueue.h>
33 #include <linux/mm.h> 33 #include <linux/mm.h>
34 #include <linux/skbuff.h> 34 #include <linux/skbuff.h>
35 35
36 #include <linux/isdnif.h> 36 #include <linux/isdnif.h>
37 37
38 #include <asm/system.h> 38 #include <asm/system.h>
39 #include <asm/io.h> 39 #include <asm/io.h>
40 40
41 41
42 #include "pcbit.h" 42 #include "pcbit.h"
43 #include "layer2.h" 43 #include "layer2.h"
44 #include "edss1.h" 44 #include "edss1.h"
45 45
46 #undef DEBUG_FRAG 46 #undef DEBUG_FRAG
47 47
48 48
49 /* 49 /*
50 * Prototypes 50 * Prototypes
51 */ 51 */
52 52
53 static void pcbit_transmit(struct pcbit_dev *d 53 static void pcbit_transmit(struct pcbit_dev *dev);
54 54
55 static void pcbit_recv_ack(struct pcbit_dev *d 55 static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack);
56 56
57 static void pcbit_l2_error(struct pcbit_dev *d 57 static void pcbit_l2_error(struct pcbit_dev *dev);
58 static void pcbit_l2_active_conf(struct pcbit_ 58 static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info);
59 static void pcbit_l2_err_recover(unsigned long 59 static void pcbit_l2_err_recover(unsigned long data);
60 60
61 static void pcbit_firmware_bug(struct pcbit_de 61 static void pcbit_firmware_bug(struct pcbit_dev *dev);
62 62
63 static __inline__ void 63 static __inline__ void
64 pcbit_sched_delivery(struct pcbit_dev *dev) 64 pcbit_sched_delivery(struct pcbit_dev *dev)
65 { 65 {
66 schedule_work(&dev->qdelivery); 66 schedule_work(&dev->qdelivery);
67 } 67 }
68 68
69 69
70 /* 70 /*
71 * Called from layer3 71 * Called from layer3
72 */ 72 */
73 73
74 int 74 int
75 pcbit_l2_write(struct pcbit_dev *dev, ulong ms 75 pcbit_l2_write(struct pcbit_dev *dev, ulong msg, ushort refnum,
76 struct sk_buff *skb, unsigned s 76 struct sk_buff *skb, unsigned short hdr_len)
77 { 77 {
78 struct frame_buf *frame, 78 struct frame_buf *frame,
79 *ptr; 79 *ptr;
80 unsigned long flags; 80 unsigned long flags;
81 81
82 if (dev->l2_state != L2_RUNNING && dev 82 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
83 dev_kfree_skb(skb); 83 dev_kfree_skb(skb);
84 return -1; 84 return -1;
85 } 85 }
86 if ((frame = kmalloc(sizeof(struct fra 86 if ((frame = kmalloc(sizeof(struct frame_buf),
87 87 GFP_ATOMIC)) == NULL) {
88 printk(KERN_WARNING "pcbit_2_w 88 printk(KERN_WARNING "pcbit_2_write: kmalloc failed\n");
89 dev_kfree_skb(skb); 89 dev_kfree_skb(skb);
90 return -1; 90 return -1;
91 } 91 }
92 frame->msg = msg; 92 frame->msg = msg;
93 frame->refnum = refnum; 93 frame->refnum = refnum;
94 frame->copied = 0; 94 frame->copied = 0;
95 frame->hdr_len = hdr_len; 95 frame->hdr_len = hdr_len;
96 96
97 if (skb) 97 if (skb)
98 frame->dt_len = skb->len - hdr 98 frame->dt_len = skb->len - hdr_len;
99 else 99 else
100 frame->dt_len = 0; 100 frame->dt_len = 0;
101 101
102 frame->skb = skb; 102 frame->skb = skb;
103 103
104 frame->next = NULL; 104 frame->next = NULL;
105 105
106 spin_lock_irqsave(&dev->lock, flags); 106 spin_lock_irqsave(&dev->lock, flags);
107 107
108 if (dev->write_queue == NULL) { 108 if (dev->write_queue == NULL) {
109 dev->write_queue = frame; 109 dev->write_queue = frame;
110 spin_unlock_irqrestore(&dev->l 110 spin_unlock_irqrestore(&dev->lock, flags);
111 pcbit_transmit(dev); 111 pcbit_transmit(dev);
112 } else { 112 } else {
113 for (ptr = dev->write_queue; p 113 for (ptr = dev->write_queue; ptr->next; ptr = ptr->next);
114 ptr->next = frame; 114 ptr->next = frame;
115 115
116 spin_unlock_irqrestore(&dev->l 116 spin_unlock_irqrestore(&dev->lock, flags);
117 } 117 }
118 return 0; 118 return 0;
119 } 119 }
120 120
121 static __inline__ void 121 static __inline__ void
122 pcbit_tx_update(struct pcbit_dev *dev, ushort 122 pcbit_tx_update(struct pcbit_dev *dev, ushort len)
123 { 123 {
124 u_char info; 124 u_char info;
125 125
126 dev->send_seq = (dev->send_seq + 1) % 126 dev->send_seq = (dev->send_seq + 1) % 8;
127 127
128 dev->fsize[dev->send_seq] = len; 128 dev->fsize[dev->send_seq] = len;
129 info = 0; 129 info = 0;
130 info |= dev->rcv_seq << 3; 130 info |= dev->rcv_seq << 3;
131 info |= dev->send_seq; 131 info |= dev->send_seq;
132 132
133 writeb(info, dev->sh_mem + BANK4); 133 writeb(info, dev->sh_mem + BANK4);
134 134
135 } 135 }
136 136
137 /* 137 /*
138 * called by interrupt service routine or by w 138 * called by interrupt service routine or by write_2
139 */ 139 */
140 140
141 static void 141 static void
142 pcbit_transmit(struct pcbit_dev *dev) 142 pcbit_transmit(struct pcbit_dev *dev)
143 { 143 {
144 struct frame_buf *frame = NULL; 144 struct frame_buf *frame = NULL;
145 unsigned char unacked; 145 unsigned char unacked;
146 int flen; /* fragment fr 146 int flen; /* fragment frame length including all headers */
147 int free; 147 int free;
148 int count, 148 int count,
149 cp_len; 149 cp_len;
150 unsigned long flags; 150 unsigned long flags;
151 unsigned short tt; 151 unsigned short tt;
152 152
153 if (dev->l2_state != L2_RUNNING && dev 153 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
154 return; 154 return;
155 155
156 unacked = (dev->send_seq + (8 - dev->u 156 unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07;
157 157
158 spin_lock_irqsave(&dev->lock, flags); 158 spin_lock_irqsave(&dev->lock, flags);
159 159
160 if (dev->free > 16 && dev->write_queue 160 if (dev->free > 16 && dev->write_queue && unacked < 7) {
161 161
162 if (!dev->w_busy) 162 if (!dev->w_busy)
163 dev->w_busy = 1; 163 dev->w_busy = 1;
164 else { 164 else {
165 spin_unlock_irqrestore 165 spin_unlock_irqrestore(&dev->lock, flags);
166 return; 166 return;
167 } 167 }
168 168
169 169
170 frame = dev->write_queue; 170 frame = dev->write_queue;
171 free = dev->free; 171 free = dev->free;
172 172
173 spin_unlock_irqrestore(&dev->l 173 spin_unlock_irqrestore(&dev->lock, flags);
174 174
175 if (frame->copied == 0) { 175 if (frame->copied == 0) {
176 176
177 /* Type 0 frame */ 177 /* Type 0 frame */
178 178
179 ulong msg; 179 ulong msg;
180 180
181 if (frame->skb) 181 if (frame->skb)
182 flen = FRAME_H 182 flen = FRAME_HDR_LEN + PREHDR_LEN + frame->skb->len;
183 else 183 else
184 flen = FRAME_H 184 flen = FRAME_HDR_LEN + PREHDR_LEN;
185 185
186 if (flen > free) 186 if (flen > free)
187 flen = free; 187 flen = free;
188 188
189 msg = frame->msg; 189 msg = frame->msg;
190 190
191 /* 191 /*
192 * Board level 2 head 192 * Board level 2 header
193 */ 193 */
194 194
195 pcbit_writew(dev, flen 195 pcbit_writew(dev, flen - FRAME_HDR_LEN);
196 196
197 pcbit_writeb(dev, GET_ 197 pcbit_writeb(dev, GET_MSG_CPU(msg));
198 198
199 pcbit_writeb(dev, GET_ 199 pcbit_writeb(dev, GET_MSG_PROC(msg));
200 200
201 /* TH */ 201 /* TH */
202 pcbit_writew(dev, fram 202 pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
203 203
204 /* TD */ 204 /* TD */
205 pcbit_writew(dev, fram 205 pcbit_writew(dev, frame->dt_len);
206 206
207 207
208 /* 208 /*
209 * Board level 3 fixe 209 * Board level 3 fixed-header
210 */ 210 */
211 211
212 /* LEN = TH */ 212 /* LEN = TH */
213 pcbit_writew(dev, fram 213 pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
214 214
215 /* XX */ 215 /* XX */
216 pcbit_writew(dev, 0); 216 pcbit_writew(dev, 0);
217 217
218 /* C + S */ 218 /* C + S */
219 pcbit_writeb(dev, GET_ 219 pcbit_writeb(dev, GET_MSG_CMD(msg));
220 pcbit_writeb(dev, GET_ 220 pcbit_writeb(dev, GET_MSG_SCMD(msg));
221 221
222 /* NUM */ 222 /* NUM */
223 pcbit_writew(dev, fram 223 pcbit_writew(dev, frame->refnum);
224 224
225 count = FRAME_HDR_LEN 225 count = FRAME_HDR_LEN + PREHDR_LEN;
226 } else { 226 } else {
227 /* Type 1 frame */ 227 /* Type 1 frame */
228 228
229 flen = 2 + (frame->skb 229 flen = 2 + (frame->skb->len - frame->copied);
230 230
231 if (flen > free) 231 if (flen > free)
232 flen = free; 232 flen = free;
233 233
234 /* TT */ 234 /* TT */
235 tt = ((ushort) (flen - 235 tt = ((ushort) (flen - 2)) | 0x8000U; /* Type 1 */
236 pcbit_writew(dev, tt); 236 pcbit_writew(dev, tt);
237 237
238 count = 2; 238 count = 2;
239 } 239 }
240 240
241 if (frame->skb) { 241 if (frame->skb) {
242 cp_len = frame->skb->l 242 cp_len = frame->skb->len - frame->copied;
243 if (cp_len > flen - co 243 if (cp_len > flen - count)
244 cp_len = flen 244 cp_len = flen - count;
245 245
246 memcpy_topcbit(dev, fr 246 memcpy_topcbit(dev, frame->skb->data + frame->copied,
247 cp_len) 247 cp_len);
248 frame->copied += cp_le 248 frame->copied += cp_len;
249 } 249 }
250 /* bookkeeping */ 250 /* bookkeeping */
251 dev->free -= flen; 251 dev->free -= flen;
252 pcbit_tx_update(dev, flen); 252 pcbit_tx_update(dev, flen);
253 253
254 spin_lock_irqsave(&dev->lock, 254 spin_lock_irqsave(&dev->lock, flags);
255 255
256 if (frame->skb == NULL || fram 256 if (frame->skb == NULL || frame->copied == frame->skb->len) {
257 257
258 dev->write_queue = fra 258 dev->write_queue = frame->next;
259 259
260 if (frame->skb != NULL 260 if (frame->skb != NULL) {
261 /* free frame 261 /* free frame */
262 dev_kfree_skb( 262 dev_kfree_skb(frame->skb);
263 } 263 }
264 kfree(frame); 264 kfree(frame);
265 } 265 }
266 dev->w_busy = 0; 266 dev->w_busy = 0;
267 spin_unlock_irqrestore(&dev->l 267 spin_unlock_irqrestore(&dev->lock, flags);
268 } else { 268 } else {
269 spin_unlock_irqrestore(&dev->l 269 spin_unlock_irqrestore(&dev->lock, flags);
270 #ifdef DEBUG 270 #ifdef DEBUG
271 printk(KERN_DEBUG "unacked %d 271 printk(KERN_DEBUG "unacked %d free %d write_queue %s\n",
272 unacked, dev->free, dev-> 272 unacked, dev->free, dev->write_queue ? "not empty" :
273 "empty"); 273 "empty");
274 #endif 274 #endif
275 } 275 }
276 } 276 }
277 277
278 278
279 /* 279 /*
280 * deliver a queued frame to the upper layer 280 * deliver a queued frame to the upper layer
281 */ 281 */
282 282
283 void 283 void
284 pcbit_deliver(struct work_struct *work) 284 pcbit_deliver(struct work_struct *work)
285 { 285 {
286 struct frame_buf *frame; 286 struct frame_buf *frame;
287 unsigned long flags, msg; 287 unsigned long flags, msg;
288 struct pcbit_dev *dev = 288 struct pcbit_dev *dev =
289 container_of(work, struct pcbi 289 container_of(work, struct pcbit_dev, qdelivery);
290 290
291 spin_lock_irqsave(&dev->lock, flags); 291 spin_lock_irqsave(&dev->lock, flags);
292 292
293 while ((frame = dev->read_queue)) { 293 while ((frame = dev->read_queue)) {
294 dev->read_queue = frame->next; 294 dev->read_queue = frame->next;
295 spin_unlock_irqrestore(&dev->l 295 spin_unlock_irqrestore(&dev->lock, flags);
296 296
297 msg = 0; 297 msg = 0;
298 SET_MSG_CPU(msg, 0); 298 SET_MSG_CPU(msg, 0);
299 SET_MSG_PROC(msg, 0); 299 SET_MSG_PROC(msg, 0);
300 SET_MSG_CMD(msg, frame->skb->d 300 SET_MSG_CMD(msg, frame->skb->data[2]);
301 SET_MSG_SCMD(msg, frame->skb-> 301 SET_MSG_SCMD(msg, frame->skb->data[3]);
302 302
303 frame->refnum = *((ushort *) f 303 frame->refnum = *((ushort *) frame->skb->data + 4);
304 frame->msg = *((ulong *) & msg 304 frame->msg = *((ulong *) & msg);
305 305
306 skb_pull(frame->skb, 6); 306 skb_pull(frame->skb, 6);
307 307
308 pcbit_l3_receive(dev, frame->m 308 pcbit_l3_receive(dev, frame->msg, frame->skb, frame->hdr_len,
309 frame->refnum 309 frame->refnum);
310 310
311 kfree(frame); 311 kfree(frame);
312 312
313 spin_lock_irqsave(&dev->lock, 313 spin_lock_irqsave(&dev->lock, flags);
314 } 314 }
315 315
316 spin_unlock_irqrestore(&dev->lock, fla 316 spin_unlock_irqrestore(&dev->lock, flags);
317 } 317 }
318 318
319 /* 319 /*
320 * Reads BANK 2 & Reassembles 320 * Reads BANK 2 & Reassembles
321 */ 321 */
322 322
323 static void 323 static void
324 pcbit_receive(struct pcbit_dev *dev) 324 pcbit_receive(struct pcbit_dev *dev)
325 { 325 {
326 unsigned short tt; 326 unsigned short tt;
327 u_char cpu, 327 u_char cpu,
328 proc; 328 proc;
329 struct frame_buf *frame = NULL; 329 struct frame_buf *frame = NULL;
330 unsigned long flags; 330 unsigned long flags;
331 u_char type1; 331 u_char type1;
332 332
333 if (dev->l2_state != L2_RUNNING && dev 333 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
334 return; 334 return;
335 335
336 tt = pcbit_readw(dev); 336 tt = pcbit_readw(dev);
337 337
338 if ((tt & 0x7fffU) > 511) { 338 if ((tt & 0x7fffU) > 511) {
339 printk(KERN_INFO "pcbit: inval 339 printk(KERN_INFO "pcbit: invalid frame length -> TT=%04x\n",
340 tt); 340 tt);
341 pcbit_l2_error(dev); 341 pcbit_l2_error(dev);
342 return; 342 return;
343 } 343 }
344 if (!(tt & 0x8000U)) { /* Type 0 */ 344 if (!(tt & 0x8000U)) { /* Type 0 */
345 type1 = 0; 345 type1 = 0;
346 346
347 if (dev->read_frame) { 347 if (dev->read_frame) {
348 printk(KERN_DEBUG "pcb 348 printk(KERN_DEBUG "pcbit_receive: Type 0 frame and read_frame != NULL\n");
349 /* discard previous qu 349 /* discard previous queued frame */
350 if (dev->read_frame->s 350 if (dev->read_frame->skb)
351 kfree_skb(dev- 351 kfree_skb(dev->read_frame->skb);
352 kfree(dev->read_frame) 352 kfree(dev->read_frame);
353 dev->read_frame = NULL 353 dev->read_frame = NULL;
354 } 354 }
355 frame = kzalloc(sizeof(struct 355 frame = kzalloc(sizeof(struct frame_buf), GFP_ATOMIC);
356 356
357 if (frame == NULL) { 357 if (frame == NULL) {
358 printk(KERN_WARNING "k 358 printk(KERN_WARNING "kmalloc failed\n");
359 return; 359 return;
360 } 360 }
361 361
362 cpu = pcbit_readb(dev); 362 cpu = pcbit_readb(dev);
363 proc = pcbit_readb(dev); 363 proc = pcbit_readb(dev);
364 364
365 365
366 if (cpu != 0x06 && cpu != 0x02 366 if (cpu != 0x06 && cpu != 0x02) {
367 printk(KERN_DEBUG "pcb 367 printk(KERN_DEBUG "pcbit: invalid cpu value\n");
368 kfree(frame); 368 kfree(frame);
369 pcbit_l2_error(dev); 369 pcbit_l2_error(dev);
370 return; 370 return;
371 } 371 }
372 /* 372 /*
373 * we discard cpu & proc on re 373 * we discard cpu & proc on receiving
374 * but we read it to update th 374 * but we read it to update the pointer
375 */ 375 */
376 376
377 frame->hdr_len = pcbit_readw(d 377 frame->hdr_len = pcbit_readw(dev);
378 frame->dt_len = pcbit_readw(de 378 frame->dt_len = pcbit_readw(dev);
379 379
380 /* 380 /*
381 * 0 sized packet 381 * 0 sized packet
382 * I don't know if they are 382 * I don't know if they are an error or not...
383 * But they are very frequen 383 * But they are very frequent
384 * Not documented 384 * Not documented
385 */ 385 */
386 386
387 if (frame->hdr_len == 0) { 387 if (frame->hdr_len == 0) {
388 kfree(frame); 388 kfree(frame);
389 #ifdef DEBUG 389 #ifdef DEBUG
390 printk(KERN_DEBUG "0 s 390 printk(KERN_DEBUG "0 sized frame\n");
391 #endif 391 #endif
392 pcbit_firmware_bug(dev 392 pcbit_firmware_bug(dev);
393 return; 393 return;
394 } 394 }
395 /* sanity check the length val 395 /* sanity check the length values */
396 if (frame->hdr_len > 1024 || f 396 if (frame->hdr_len > 1024 || frame->dt_len > 2048) {
397 #ifdef DEBUG 397 #ifdef DEBUG
398 printk(KERN_DEBUG "len 398 printk(KERN_DEBUG "length problem: ");
399 printk(KERN_DEBUG "TH= 399 printk(KERN_DEBUG "TH=%04x TD=%04x\n",
400 frame->hdr_len, 400 frame->hdr_len,
401 frame->dt_len); 401 frame->dt_len);
402 #endif 402 #endif
403 pcbit_l2_error(dev); 403 pcbit_l2_error(dev);
404 kfree(frame); 404 kfree(frame);
405 return; 405 return;
406 } 406 }
407 /* minimum frame read */ 407 /* minimum frame read */
408 408
409 frame->skb = dev_alloc_skb(fra 409 frame->skb = dev_alloc_skb(frame->hdr_len + frame->dt_len +
410 ((f 410 ((frame->hdr_len + 15) & ~15));
411 411
412 if (!frame->skb) { 412 if (!frame->skb) {
413 printk(KERN_DEBUG "pcb 413 printk(KERN_DEBUG "pcbit_receive: out of memory\n");
414 kfree(frame); 414 kfree(frame);
415 return; 415 return;
416 } 416 }
417 /* 16 byte alignment for IP */ 417 /* 16 byte alignment for IP */
418 if (frame->dt_len) 418 if (frame->dt_len)
419 skb_reserve(frame->skb 419 skb_reserve(frame->skb, (frame->hdr_len + 15) & ~15);
420 420
421 } else { 421 } else {
422 /* Type 1 */ 422 /* Type 1 */
423 type1 = 1; 423 type1 = 1;
424 tt &= 0x7fffU; 424 tt &= 0x7fffU;
425 425
426 if (!(frame = dev->read_frame) 426 if (!(frame = dev->read_frame)) {
427 printk("Type 1 frame a 427 printk("Type 1 frame and no frame queued\n");
428 /* usually after an er 428 /* usually after an error: toss frame */
429 dev->readptr += tt; 429 dev->readptr += tt;
430 if (dev->readptr > dev 430 if (dev->readptr > dev->sh_mem + BANK2 + BANKLEN)
431 dev->readptr - 431 dev->readptr -= BANKLEN;
432 return; 432 return;
433 433
434 } 434 }
435 } 435 }
436 436
437 memcpy_frompcbit(dev, skb_put(frame->s 437 memcpy_frompcbit(dev, skb_put(frame->skb, tt), tt);
438 438
439 frame->copied += tt; 439 frame->copied += tt;
440 spin_lock_irqsave(&dev->lock, flags); 440 spin_lock_irqsave(&dev->lock, flags);
441 if (frame->copied == frame->hdr_len + 441 if (frame->copied == frame->hdr_len + frame->dt_len) {
442 442
443 if (type1) { 443 if (type1) {
444 dev->read_frame = NULL 444 dev->read_frame = NULL;
445 } 445 }
446 if (dev->read_queue) { 446 if (dev->read_queue) {
447 struct frame_buf *ptr; 447 struct frame_buf *ptr;
448 for (ptr = dev->read_q 448 for (ptr = dev->read_queue; ptr->next; ptr = ptr->next);
449 ptr->next = frame; 449 ptr->next = frame;
450 } else 450 } else
451 dev->read_queue = fram 451 dev->read_queue = frame;
452 452
453 } else { 453 } else {
454 dev->read_frame = frame; 454 dev->read_frame = frame;
455 } 455 }
456 spin_unlock_irqrestore(&dev->lock, fla 456 spin_unlock_irqrestore(&dev->lock, flags);
457 } 457 }
458 458
459 /* 459 /*
460 * The board sends 0 sized frames 460 * The board sends 0 sized frames
461 * They are TDATA_CONFs that get messed up so 461 * They are TDATA_CONFs that get messed up somehow
462 * gotta send a fake acknowledgment to the up 462 * gotta send a fake acknowledgment to the upper layer somehow
463 */ 463 */
464 464
465 static __inline__ void 465 static __inline__ void
466 pcbit_fake_conf(struct pcbit_dev *dev, struct 466 pcbit_fake_conf(struct pcbit_dev *dev, struct pcbit_chan *chan)
467 { 467 {
468 isdn_ctrl ictl; 468 isdn_ctrl ictl;
469 469
470 if (chan->queued) { 470 if (chan->queued) {
471 chan->queued--; 471 chan->queued--;
472 472
473 ictl.driver = dev->id; 473 ictl.driver = dev->id;
474 ictl.command = ISDN_STAT_BSENT 474 ictl.command = ISDN_STAT_BSENT;
475 ictl.arg = chan->id; 475 ictl.arg = chan->id;
476 dev->dev_if->statcallb(&ictl); 476 dev->dev_if->statcallb(&ictl);
477 } 477 }
478 } 478 }
479 479
480 static void 480 static void
481 pcbit_firmware_bug(struct pcbit_dev *dev) 481 pcbit_firmware_bug(struct pcbit_dev *dev)
482 { 482 {
483 struct pcbit_chan *chan; 483 struct pcbit_chan *chan;
484 484
485 chan = dev->b1; 485 chan = dev->b1;
486 486
487 if (chan->fsm_state == ST_ACTIVE) { 487 if (chan->fsm_state == ST_ACTIVE) {
488 pcbit_fake_conf(dev, chan); 488 pcbit_fake_conf(dev, chan);
489 } 489 }
490 chan = dev->b2; 490 chan = dev->b2;
491 491
492 if (chan->fsm_state == ST_ACTIVE) { 492 if (chan->fsm_state == ST_ACTIVE) {
493 pcbit_fake_conf(dev, chan); 493 pcbit_fake_conf(dev, chan);
494 } 494 }
495 } 495 }
496 496
497 irqreturn_t 497 irqreturn_t
498 pcbit_irq_handler(int interrupt, void *devptr) 498 pcbit_irq_handler(int interrupt, void *devptr)
499 { 499 {
500 struct pcbit_dev *dev; 500 struct pcbit_dev *dev;
501 u_char info, 501 u_char info,
502 ack_seq, 502 ack_seq,
503 read_seq; 503 read_seq;
504 504
505 dev = (struct pcbit_dev *) devptr; 505 dev = (struct pcbit_dev *) devptr;
506 506
507 if (!dev) { 507 if (!dev) {
508 printk(KERN_WARNING "pcbit_irq 508 printk(KERN_WARNING "pcbit_irq_handler: wrong device\n");
509 return IRQ_NONE; 509 return IRQ_NONE;
510 } 510 }
511 if (dev->interrupt) { 511 if (dev->interrupt) {
512 printk(KERN_DEBUG "pcbit: reen 512 printk(KERN_DEBUG "pcbit: reentering interrupt hander\n");
513 return IRQ_HANDLED; 513 return IRQ_HANDLED;
514 } 514 }
515 dev->interrupt = 1; 515 dev->interrupt = 1;
516 516
517 info = readb(dev->sh_mem + BANK3); 517 info = readb(dev->sh_mem + BANK3);
518 518
519 if (dev->l2_state == L2_STARTING || de 519 if (dev->l2_state == L2_STARTING || dev->l2_state == L2_ERROR) {
520 pcbit_l2_active_conf(dev, info 520 pcbit_l2_active_conf(dev, info);
521 dev->interrupt = 0; 521 dev->interrupt = 0;
522 return IRQ_HANDLED; 522 return IRQ_HANDLED;
523 } 523 }
524 if (info & 0x40U) { /* E bit set * 524 if (info & 0x40U) { /* E bit set */
525 #ifdef DEBUG 525 #ifdef DEBUG
526 printk(KERN_DEBUG "pcbit_irq_h 526 printk(KERN_DEBUG "pcbit_irq_handler: E bit on\n");
527 #endif 527 #endif
528 pcbit_l2_error(dev); 528 pcbit_l2_error(dev);
529 dev->interrupt = 0; 529 dev->interrupt = 0;
530 return IRQ_HANDLED; 530 return IRQ_HANDLED;
531 } 531 }
532 if (dev->l2_state != L2_RUNNING && dev 532 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
533 dev->interrupt = 0; 533 dev->interrupt = 0;
534 return IRQ_HANDLED; 534 return IRQ_HANDLED;
535 } 535 }
536 ack_seq = (info >> 3) & 0x07U; 536 ack_seq = (info >> 3) & 0x07U;
537 read_seq = (info & 0x07U); 537 read_seq = (info & 0x07U);
538 538
539 dev->interrupt = 0; 539 dev->interrupt = 0;
540 540
541 if (read_seq != dev->rcv_seq) { 541 if (read_seq != dev->rcv_seq) {
542 while (read_seq != dev->rcv_se 542 while (read_seq != dev->rcv_seq) {
543 pcbit_receive(dev); 543 pcbit_receive(dev);
544 dev->rcv_seq = (dev->r 544 dev->rcv_seq = (dev->rcv_seq + 1) % 8;
545 } 545 }
546 pcbit_sched_delivery(dev); 546 pcbit_sched_delivery(dev);
547 } 547 }
548 if (ack_seq != dev->unack_seq) { 548 if (ack_seq != dev->unack_seq) {
549 pcbit_recv_ack(dev, ack_seq); 549 pcbit_recv_ack(dev, ack_seq);
550 } 550 }
551 info = dev->rcv_seq << 3; 551 info = dev->rcv_seq << 3;
552 info |= dev->send_seq; 552 info |= dev->send_seq;
553 553
554 writeb(info, dev->sh_mem + BANK4); 554 writeb(info, dev->sh_mem + BANK4);
555 return IRQ_HANDLED; 555 return IRQ_HANDLED;
556 } 556 }
557 557
558 558
559 static void 559 static void
560 pcbit_l2_active_conf(struct pcbit_dev *dev, u_ 560 pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info)
561 { 561 {
562 u_char state; 562 u_char state;
563 563
564 state = dev->l2_state; 564 state = dev->l2_state;
565 565
566 #ifdef DEBUG 566 #ifdef DEBUG
567 printk(KERN_DEBUG "layer2_active_confi 567 printk(KERN_DEBUG "layer2_active_confirm\n");
568 #endif 568 #endif
569 569
570 570
571 if (info & 0x80U) { 571 if (info & 0x80U) {
572 dev->rcv_seq = info & 0x07U; 572 dev->rcv_seq = info & 0x07U;
573 dev->l2_state = L2_RUNNING; 573 dev->l2_state = L2_RUNNING;
574 } else 574 } else
575 dev->l2_state = L2_DOWN; 575 dev->l2_state = L2_DOWN;
576 576
577 if (state == L2_STARTING) 577 if (state == L2_STARTING)
578 wake_up_interruptible(&dev->se 578 wake_up_interruptible(&dev->set_running_wq);
579 579
580 if (state == L2_ERROR && dev->l2_state 580 if (state == L2_ERROR && dev->l2_state == L2_RUNNING) {
581 pcbit_transmit(dev); 581 pcbit_transmit(dev);
582 } 582 }
583 } 583 }
584 584
585 static void 585 static void
586 pcbit_l2_err_recover(unsigned long data) 586 pcbit_l2_err_recover(unsigned long data)
587 { 587 {
588 588
589 struct pcbit_dev *dev; 589 struct pcbit_dev *dev;
590 struct frame_buf *frame; 590 struct frame_buf *frame;
591 591
592 dev = (struct pcbit_dev *) data; 592 dev = (struct pcbit_dev *) data;
593 593
594 del_timer(&dev->error_recover_timer); 594 del_timer(&dev->error_recover_timer);
595 if (dev->w_busy || dev->r_busy) { 595 if (dev->w_busy || dev->r_busy) {
596 init_timer(&dev->error_recover 596 init_timer(&dev->error_recover_timer);
597 dev->error_recover_timer.expir 597 dev->error_recover_timer.expires = jiffies + ERRTIME;
598 add_timer(&dev->error_recover_ 598 add_timer(&dev->error_recover_timer);
599 return; 599 return;
600 } 600 }
601 dev->w_busy = dev->r_busy = 1; 601 dev->w_busy = dev->r_busy = 1;
602 602
603 if (dev->read_frame) { 603 if (dev->read_frame) {
604 if (dev->read_frame->skb) 604 if (dev->read_frame->skb)
605 kfree_skb(dev->read_fr 605 kfree_skb(dev->read_frame->skb);
606 kfree(dev->read_frame); 606 kfree(dev->read_frame);
607 dev->read_frame = NULL; 607 dev->read_frame = NULL;
608 } 608 }
609 if (dev->write_queue) { 609 if (dev->write_queue) {
610 frame = dev->write_queue; 610 frame = dev->write_queue;
611 #ifdef FREE_ON_ERROR 611 #ifdef FREE_ON_ERROR
612 dev->write_queue = dev->write_ 612 dev->write_queue = dev->write_queue->next;
613 613
614 if (frame->skb) { 614 if (frame->skb) {
615 dev_kfree_skb(frame->s 615 dev_kfree_skb(frame->skb);
616 } 616 }
617 kfree(frame); 617 kfree(frame);
618 #else 618 #else
619 frame->copied = 0; 619 frame->copied = 0;
620 #endif 620 #endif
621 } 621 }
622 dev->rcv_seq = dev->send_seq = dev->un 622 dev->rcv_seq = dev->send_seq = dev->unack_seq = 0;
623 dev->free = 511; 623 dev->free = 511;
624 dev->l2_state = L2_ERROR; 624 dev->l2_state = L2_ERROR;
625 625
626 /* this is an hack... */ 626 /* this is an hack... */
627 pcbit_firmware_bug(dev); 627 pcbit_firmware_bug(dev);
628 628
629 dev->writeptr = dev->sh_mem; 629 dev->writeptr = dev->sh_mem;
630 dev->readptr = dev->sh_mem + BANK2; 630 dev->readptr = dev->sh_mem + BANK2;
631 631
632 writeb((0x80U | ((dev->rcv_seq & 0x07) 632 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
633 dev->sh_mem + BANK4); 633 dev->sh_mem + BANK4);
634 dev->w_busy = dev->r_busy = 0; 634 dev->w_busy = dev->r_busy = 0;
635 635
636 } 636 }
637 637
638 static void 638 static void
639 pcbit_l2_error(struct pcbit_dev *dev) 639 pcbit_l2_error(struct pcbit_dev *dev)
640 { 640 {
641 if (dev->l2_state == L2_RUNNING) { 641 if (dev->l2_state == L2_RUNNING) {
642 642
643 printk(KERN_INFO "pcbit: layer 643 printk(KERN_INFO "pcbit: layer 2 error\n");
644 644
645 #ifdef DEBUG 645 #ifdef DEBUG
646 log_state(dev); 646 log_state(dev);
647 #endif 647 #endif
648 648
649 dev->l2_state = L2_DOWN; 649 dev->l2_state = L2_DOWN;
650 650
651 init_timer(&dev->error_recover 651 init_timer(&dev->error_recover_timer);
652 dev->error_recover_timer.funct 652 dev->error_recover_timer.function = &pcbit_l2_err_recover;
653 dev->error_recover_timer.data 653 dev->error_recover_timer.data = (ulong) dev;
654 dev->error_recover_timer.expir 654 dev->error_recover_timer.expires = jiffies + ERRTIME;
655 add_timer(&dev->error_recover_ 655 add_timer(&dev->error_recover_timer);
656 } 656 }
657 } 657 }
658 658
659 /* 659 /*
660 * Description: 660 * Description:
661 * if board acks frames 661 * if board acks frames
662 * update dev->free 662 * update dev->free
663 * call pcbit_transmit to write possible que 663 * call pcbit_transmit to write possible queued frames
664 */ 664 */
665 665
666 static void 666 static void
667 pcbit_recv_ack(struct pcbit_dev *dev, unsigned 667 pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack)
668 { 668 {
669 int i, 669 int i,
670 count; 670 count;
671 int unacked; 671 int unacked;
672 672
673 unacked = (dev->send_seq + (8 - dev->u 673 unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07;
674 674
675 /* dev->unack_seq < ack <= dev->send_s 675 /* dev->unack_seq < ack <= dev->send_seq; */
676 676
677 if (unacked) { 677 if (unacked) {
678 678
679 if (dev->send_seq > dev->unack 679 if (dev->send_seq > dev->unack_seq) {
680 if (ack <= dev->unack_ 680 if (ack <= dev->unack_seq || ack > dev->send_seq) {
681 printk(KERN_DE 681 printk(KERN_DEBUG
682 "layer 2 682 "layer 2 ack unacceptable - dev %d",
683 dev->id 683 dev->id);
684 684
685 pcbit_l2_error 685 pcbit_l2_error(dev);
686 } else if (ack > dev-> 686 } else if (ack > dev->send_seq && ack <= dev->unack_seq) {
687 printk(KERN_DE 687 printk(KERN_DEBUG
688 "layer 2 688 "layer 2 ack unacceptable - dev %d",
689 dev->id 689 dev->id);
690 pcbit_l2_error 690 pcbit_l2_error(dev);
691 } 691 }
692 } 692 }
693 /* ack is acceptable */ 693 /* ack is acceptable */
694 694
695 695
696 i = dev->unack_seq; 696 i = dev->unack_seq;
697 697
698 do { 698 do {
699 dev->unack_seq = i = ( 699 dev->unack_seq = i = (i + 1) % 8;
700 dev->free += dev->fsiz 700 dev->free += dev->fsize[i];
701 } while (i != ack); 701 } while (i != ack);
702 702
703 count = 0; 703 count = 0;
704 while (count < 7 && dev->write 704 while (count < 7 && dev->write_queue) {
705 u8 lsend_seq = dev->se 705 u8 lsend_seq = dev->send_seq;
706 706
707 pcbit_transmit(dev); 707 pcbit_transmit(dev);
708 708
709 if (dev->send_seq == l 709 if (dev->send_seq == lsend_seq)
710 break; 710 break;
711 count++; 711 count++;
712 } 712 }
713 } else 713 } else
714 printk(KERN_DEBUG "recv_ack: u 714 printk(KERN_DEBUG "recv_ack: unacked = 0\n");
715 } 715 }
716 716
| This page was automatically generated by the LXR engine. |