1 /* $Id: act2000_isa.c,v 1.11.6.3 2001/09/23 22:24:32 kai Exp $
2 *
3 * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000 (ISA-Version).
4 *
5 * Author Fritz Elfert
6 * Copyright by Fritz Elfert <fritz@isdn4linux.de>
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 * Thanks to Friedemann Baitinger and IBM Germany
12 *
13 */
14
15 #include "act2000.h"
16 #include "act2000_isa.h"
17 #include "capi.h"
18
19 /*
20 * Reset Controller, then try to read the Card's signature.
21 + Return:
22 * 1 = Signature found.
23 * 0 = Signature not found.
24 */
25 static int
26 act2000_isa_reset(unsigned short portbase)
27 {
28 unsigned char reg;
29 int i;
30 int found;
31 int serial = 0;
32
33 found = 0;
34 if ((reg = inb(portbase + ISA_COR)) != 0xff) {
35 outb(reg | ISA_COR_RESET, portbase + ISA_COR);
36 mdelay(10);
37 outb(reg, portbase + ISA_COR);
38 mdelay(10);
39
40 for (i = 0; i < 16; i++) {
41 if (inb(portbase + ISA_ISR) & ISA_ISR_SERIAL)
42 serial |= 0x10000;
43 serial >>= 1;
44 }
45 if (serial == ISA_SER_ID)
46 found++;
47 }
48 return found;
49 }
50
51 int
52 act2000_isa_detect(unsigned short portbase)
53 {
54 int ret = 0;
55
56 if (request_region(portbase, ACT2000_PORTLEN, "act2000isa")) {
57 ret = act2000_isa_reset(portbase);
58 release_region(portbase, ISA_REGION);
59 }
60 return ret;
61 }
62
63 static irqreturn_t
64 act2000_isa_interrupt(int dummy, void *dev_id)
65 {
66 act2000_card *card = dev_id;
67 u_char istatus;
68
69 istatus = (inb(ISA_PORT_ISR) & 0x07);
70 if (istatus & ISA_ISR_OUT) {
71 /* RX fifo has data */
72 istatus &= ISA_ISR_OUT_MASK;
73 outb(0, ISA_PORT_SIS);
74 act2000_isa_receive(card);
75 outb(ISA_SIS_INT, ISA_PORT_SIS);
76 }
77 if (istatus & ISA_ISR_ERR) {
78 /* Error Interrupt */
79 istatus &= ISA_ISR_ERR_MASK;
80 printk(KERN_WARNING "act2000: errIRQ\n");
81 }
82 if (istatus)
83 printk(KERN_DEBUG "act2000: ?IRQ %d %02x\n", card->irq, istatus);
84 return IRQ_HANDLED;
85 }
86
87 static void
88 act2000_isa_select_irq(act2000_card * card)
89 {
90 unsigned char reg;
91
92 reg = (inb(ISA_PORT_COR) & ~ISA_COR_IRQOFF) | ISA_COR_PERR;
93 switch (card->irq) {
94 case 3:
95 reg = ISA_COR_IRQ03;
96 break;
97 case 5:
98 reg = ISA_COR_IRQ05;
99 break;
100 case 7:
101 reg = ISA_COR_IRQ07;
102 break;
103 case 10:
104 reg = ISA_COR_IRQ10;
105 break;
106 case 11:
107 reg = ISA_COR_IRQ11;
108 break;
109 case 12:
110 reg = ISA_COR_IRQ12;
111 break;
112 case 15:
113 reg = ISA_COR_IRQ15;
114 break;
115 }
116 outb(reg, ISA_PORT_COR);
117 }
118
119 static void
120 act2000_isa_enable_irq(act2000_card * card)
121 {
122 act2000_isa_select_irq(card);
123 /* Enable READ irq */
124 outb(ISA_SIS_INT, ISA_PORT_SIS);
125 }
126
127 /*
128 * Install interrupt handler, enable irq on card.
129 * If irq is -1, choose next free irq, else irq is given explicitly.
130 */
131 int
132 act2000_isa_config_irq(act2000_card * card, short irq)
133 {
134 int old_irq;
135
136 if (card->flags & ACT2000_FLAGS_IVALID) {
137 free_irq(card->irq, card);
138 }
139 card->flags &= ~ACT2000_FLAGS_IVALID;
140 outb(ISA_COR_IRQOFF, ISA_PORT_COR);
141 if (!irq)
142 return 0;
143
144 old_irq = card->irq;
145 card->irq = irq;
146 if (request_irq(irq, &act2000_isa_interrupt, 0, card->regname, card)) {
147 card->irq = old_irq;
148 card->flags |= ACT2000_FLAGS_IVALID;
149 printk(KERN_WARNING
150 "act2000: Could not request irq %d\n",irq);
151 return -EBUSY;
152 } else {
153 act2000_isa_select_irq(card);
154 /* Disable READ and WRITE irq */
155 outb(0, ISA_PORT_SIS);
156 outb(0, ISA_PORT_SOS);
157 }
158 return 0;
159 }
160
161 int
162 act2000_isa_config_port(act2000_card * card, unsigned short portbase)
163 {
164 if (card->flags & ACT2000_FLAGS_PVALID) {
165 release_region(card->port, ISA_REGION);
166 card->flags &= ~ACT2000_FLAGS_PVALID;
167 }
168 if (request_region(portbase, ACT2000_PORTLEN, card->regname) == NULL)
169 return -EBUSY;
170 else {
171 card->port = portbase;
172 card->flags |= ACT2000_FLAGS_PVALID;
173 return 0;
174 }
175 }
176
177 /*
178 * Release ressources, used by an adaptor.
179 */
180 void
181 act2000_isa_release(act2000_card * card)
182 {
183 unsigned long flags;
184
185 spin_lock_irqsave(&card->lock, flags);
186 if (card->flags & ACT2000_FLAGS_IVALID)
187 free_irq(card->irq, card);
188
189 card->flags &= ~ACT2000_FLAGS_IVALID;
190 if (card->flags & ACT2000_FLAGS_PVALID)
191 release_region(card->port, ISA_REGION);
192 card->flags &= ~ACT2000_FLAGS_PVALID;
193 spin_unlock_irqrestore(&card->lock, flags);
194 }
195
196 static int
197 act2000_isa_writeb(act2000_card * card, u_char data)
198 {
199 u_char timeout = 40;
200
201 while (timeout) {
202 if (inb(ISA_PORT_SOS) & ISA_SOS_READY) {
203 outb(data, ISA_PORT_SDO);
204 return 0;
205 } else {
206 timeout--;
207 udelay(10);
208 }
209 }
210 return 1;
211 }
212
213 static int
214 act2000_isa_readb(act2000_card * card, u_char * data)
215 {
216 u_char timeout = 40;
217
218 while (timeout) {
219 if (inb(ISA_PORT_SIS) & ISA_SIS_READY) {
220 *data = inb(ISA_PORT_SDI);
221 return 0;
222 } else {
223 timeout--;
224 udelay(10);
225 }
226 }
227 return 1;
228 }
229
230 void
231 act2000_isa_receive(act2000_card *card)
232 {
233 u_char c;
234
235 if (test_and_set_bit(ACT2000_LOCK_RX, (void *) &card->ilock) != 0)
236 return;
237 while (!act2000_isa_readb(card, &c)) {
238 if (card->idat.isa.rcvidx < 8) {
239 card->idat.isa.rcvhdr[card->idat.isa.rcvidx++] = c;
240 if (card->idat.isa.rcvidx == 8) {
241 int valid = actcapi_chkhdr(card, (actcapi_msghdr *)&card->idat.isa.rcvhdr);
242
243 if (valid) {
244 card->idat.isa.rcvlen = ((actcapi_msghdr *)&card->idat.isa.rcvhdr)->len;
245 card->idat.isa.rcvskb = dev_alloc_skb(card->idat.isa.rcvlen);
246 if (card->idat.isa.rcvskb == NULL) {
247 card->idat.isa.rcvignore = 1;
248 printk(KERN_WARNING
249 "act2000_isa_receive: no memory\n");
250 test_and_clear_bit(ACT2000_LOCK_RX, (void *) &card->ilock);
251 return;
252 }
253 memcpy(skb_put(card->idat.isa.rcvskb, 8), card->idat.isa.rcvhdr, 8);
254 card->idat.isa.rcvptr = skb_put(card->idat.isa.rcvskb, card->idat.isa.rcvlen - 8);
255 } else {
256 card->idat.isa.rcvidx = 0;
257 printk(KERN_WARNING
258 "act2000_isa_receive: Invalid CAPI msg\n");
259 {
260 int i; __u8 *p; __u8 *c; __u8 tmp[30];
261 for (i = 0, p = (__u8 *)&card->idat.isa.rcvhdr, c = tmp; i < 8; i++)
262 c += sprintf(c, "%02x ", *(p++));
263 printk(KERN_WARNING "act2000_isa_receive: %s\n", tmp);
264 }
265 }
266 }
267 } else {
268 if (!card->idat.isa.rcvignore)
269 *card->idat.isa.rcvptr++ = c;
270 if (++card->idat.isa.rcvidx >= card->idat.isa.rcvlen) {
271 if (!card->idat.isa.rcvignore) {
272 skb_queue_tail(&card->rcvq, card->idat.isa.rcvskb);
273 act2000_schedule_rx(card);
274 }
275 card->idat.isa.rcvidx = 0;
276 card->idat.isa.rcvlen = 8;
277 card->idat.isa.rcvignore = 0;
278 card->idat.isa.rcvskb = NULL;
279 card->idat.isa.rcvptr = card->idat.isa.rcvhdr;
280 }
281 }
282 }
283 if (!(card->flags & ACT2000_FLAGS_IVALID)) {
284 /* In polling mode, schedule myself */
285 if ((card->idat.isa.rcvidx) &&
286 (card->idat.isa.rcvignore ||
287 (card->idat.isa.rcvidx < card->idat.isa.rcvlen)))
288 act2000_schedule_poll(card);
289 }
290 test_and_clear_bit(ACT2000_LOCK_RX, (void *) &card->ilock);
291 }
292
293 void
294 act2000_isa_send(act2000_card * card)
295 {
296 unsigned long flags;
297 struct sk_buff *skb;
298 actcapi_msg *msg;
299 int l;
300
301 if (test_and_set_bit(ACT2000_LOCK_TX, (void *) &card->ilock) != 0)
302 return;
303 while (1) {
304 spin_lock_irqsave(&card->lock, flags);
305 if (!(card->sbuf)) {
306 if ((card->sbuf = skb_dequeue(&card->sndq))) {
307 card->ack_msg = card->sbuf->data;
308 msg = (actcapi_msg *)card->sbuf->data;
309 if ((msg->hdr.cmd.cmd == 0x86) &&
310 (msg->hdr.cmd.subcmd == 0) ) {
311 /* Save flags in message */
312 card->need_b3ack = msg->msg.data_b3_req.flags;
313 msg->msg.data_b3_req.flags = 0;
314 }
315 }
316 }
317 spin_unlock_irqrestore(&card->lock, flags);
318 if (!(card->sbuf)) {
319 /* No more data to send */
320 test_and_clear_bit(ACT2000_LOCK_TX, (void *) &card->ilock);
321 return;
322 }
323 skb = card->sbuf;
324 l = 0;
325 while (skb->len) {
326 if (act2000_isa_writeb(card, *(skb->data))) {
327 /* Fifo is full, but more data to send */
328 test_and_clear_bit(ACT2000_LOCK_TX, (void *) &card->ilock);
329 /* Schedule myself */
330 act2000_schedule_tx(card);
331 return;
332 }
333 skb_pull(skb, 1);
334 l++;
335 }
336 msg = (actcapi_msg *)card->ack_msg;
337 if ((msg->hdr.cmd.cmd == 0x86) &&
338 (msg->hdr.cmd.subcmd == 0) ) {
339 /*
340 * If it's user data, reset data-ptr
341 * and put skb into ackq.
342 */
343 skb->data = card->ack_msg;
344 /* Restore flags in message */
345 msg->msg.data_b3_req.flags = card->need_b3ack;
346 skb_queue_tail(&card->ackq, skb);
347 } else
348 dev_kfree_skb(skb);
349 card->sbuf = NULL;
350 }
351 }
352
353 /*
354 * Get firmware ID, check for 'ISDN' signature.
355 */
356 static int
357 act2000_isa_getid(act2000_card * card)
358 {
359
360 act2000_fwid fid;
361 u_char *p = (u_char *) & fid;
362 int count = 0;
363
364 while (1) {
365 if (count > 510)
366 return -EPROTO;
367 if (act2000_isa_readb(card, p++))
368 break;
369 count++;
370 }
371 if (count <= 20) {
372 printk(KERN_WARNING "act2000: No Firmware-ID!\n");
373 return -ETIME;
374 }
375 *p = '\0';
376 fid.revlen[0] = '\0';
377 if (strcmp(fid.isdn, "ISDN")) {
378 printk(KERN_WARNING "act2000: Wrong Firmware-ID!\n");
379 return -EPROTO;
380 }
381 if ((p = strchr(fid.revision, '\n')))
382 *p = '\0';
383 printk(KERN_INFO "act2000: Firmware-ID: %s\n", fid.revision);
384 if (card->flags & ACT2000_FLAGS_IVALID) {
385 printk(KERN_DEBUG "Enabling Interrupts ...\n");
386 act2000_isa_enable_irq(card);
387 }
388 return 0;
389 }
390
391 /*
392 * Download microcode into card, check Firmware signature.
393 */
394 int
395 act2000_isa_download(act2000_card * card, act2000_ddef __user * cb)
396 {
397 unsigned int length;
398 int l;
399 int c;
400 long timeout;
401 u_char *b;
402 u_char __user *p;
403 u_char *buf;
404 act2000_ddef cblock;
405
406 if (!act2000_isa_reset(card->port))
407 return -ENXIO;
408 msleep_interruptible(500);
409 if (copy_from_user(&cblock, cb, sizeof(cblock)))
410 return -EFAULT;
411 length = cblock.length;
412 p = cblock.buffer;
413 if (!access_ok(VERIFY_READ, p, length))
414 return -EFAULT;
415 buf = kmalloc(1024, GFP_KERNEL);
416 if (!buf)
417 return -ENOMEM;
418 timeout = 0;
419 while (length) {
420 l = (length > 1024) ? 1024 : length;
421 c = 0;
422 b = buf;
423 if (copy_from_user(buf, p, l)) {
424 kfree(buf);
425 return -EFAULT;
426 }
427 while (c < l) {
428 if (act2000_isa_writeb(card, *b++)) {
429 printk(KERN_WARNING
430 "act2000: loader timed out"
431 " len=%d c=%d\n", length, c);
432 kfree(buf);
433 return -ETIME;
434 }
435 c++;
436 }
437 length -= l;
438 p += l;
439 }
440 kfree(buf);
441 msleep_interruptible(500);
442 return (act2000_isa_getid(card));
443 }
444
|
This page was automatically generated by the
LXR engine.
|