Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
act2000_isa.c
Go to the documentation of this file.
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 <[email protected]>
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 *t; __u8 tmp[30];
261  for (i = 0, p = (__u8 *)&card->idat.isa.rcvhdr, t = tmp; i < 8; i++)
262  t += sprintf(t, "%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 }
Generated on Thu Jan 10 2013 13:40:52 for Linux Kernel by   doxygen 1.8.2