IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
[linux-2.6.git] / drivers / atm / ambassador.c
1 /*
2   Madge Ambassador ATM Adapter driver.
3   Copyright (C) 1995-1999  Madge Networks Ltd.
4
5   This program is free software; you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation; either version 2 of the License, or
8   (at your option) any later version.
9
10   This program is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU General Public License for more details.
14
15   You should have received a copy of the GNU General Public License
16   along with this program; if not, write to the Free Software
17   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
19   The GNU GPL is contained in /usr/doc/copyright/GPL on a Debian
20   system and in the file COPYING in the Linux kernel source.
21 */
22
23 /* * dedicated to the memory of Graham Gordon 1971-1998 * */
24
25 #include <linux/module.h>
26 #include <linux/types.h>
27 #include <linux/pci.h>
28 #include <linux/kernel.h>
29 #include <linux/init.h>
30 #include <linux/ioport.h>
31 #include <linux/atmdev.h>
32 #include <linux/delay.h>
33 #include <linux/interrupt.h>
34 #include <linux/poison.h>
35
36 #include <asm/atomic.h>
37 #include <asm/io.h>
38 #include <asm/byteorder.h>
39
40 #include "ambassador.h"
41
42 #define maintainer_string "Giuliano Procida at Madge Networks <gprocida@madge.com>"
43 #define description_string "Madge ATM Ambassador driver"
44 #define version_string "1.2.4"
45
46 static inline void __init show_version (void) {
47   printk ("%s version %s\n", description_string, version_string);
48 }
49
50 /*
51   
52   Theory of Operation
53   
54   I Hardware, detection, initialisation and shutdown.
55   
56   1. Supported Hardware
57   
58   This driver is for the PCI ATMizer-based Ambassador card (except
59   very early versions). It is not suitable for the similar EISA "TR7"
60   card. Commercially, both cards are known as Collage Server ATM
61   adapters.
62   
63   The loader supports image transfer to the card, image start and few
64   other miscellaneous commands.
65   
66   Only AAL5 is supported with vpi = 0 and vci in the range 0 to 1023.
67   
68   The cards are big-endian.
69   
70   2. Detection
71   
72   Standard PCI stuff, the early cards are detected and rejected.
73   
74   3. Initialisation
75   
76   The cards are reset and the self-test results are checked. The
77   microcode image is then transferred and started. This waits for a
78   pointer to a descriptor containing details of the host-based queues
79   and buffers and various parameters etc. Once they are processed
80   normal operations may begin. The BIA is read using a microcode
81   command.
82   
83   4. Shutdown
84   
85   This may be accomplished either by a card reset or via the microcode
86   shutdown command. Further investigation required.
87   
88   5. Persistent state
89   
90   The card reset does not affect PCI configuration (good) or the
91   contents of several other "shared run-time registers" (bad) which
92   include doorbell and interrupt control as well as EEPROM and PCI
93   control. The driver must be careful when modifying these registers
94   not to touch bits it does not use and to undo any changes at exit.
95   
96   II Driver software
97   
98   0. Generalities
99   
100   The adapter is quite intelligent (fast) and has a simple interface
101   (few features). VPI is always zero, 1024 VCIs are supported. There
102   is limited cell rate support. UBR channels can be capped and ABR
103   (explicit rate, but not EFCI) is supported. There is no CBR or VBR
104   support.
105   
106   1. Driver <-> Adapter Communication
107   
108   Apart from the basic loader commands, the driver communicates
109   through three entities: the command queue (CQ), the transmit queue
110   pair (TXQ) and the receive queue pairs (RXQ). These three entities
111   are set up by the host and passed to the microcode just after it has
112   been started.
113   
114   All queues are host-based circular queues. They are contiguous and
115   (due to hardware limitations) have some restrictions as to their
116   locations in (bus) memory. They are of the "full means the same as
117   empty so don't do that" variety since the adapter uses pointers
118   internally.
119   
120   The queue pairs work as follows: one queue is for supply to the
121   adapter, items in it are pending and are owned by the adapter; the
122   other is the queue for return from the adapter, items in it have
123   been dealt with by the adapter. The host adds items to the supply
124   (TX descriptors and free RX buffer descriptors) and removes items
125   from the return (TX and RX completions). The adapter deals with out
126   of order completions.
127   
128   Interrupts (card to host) and the doorbell (host to card) are used
129   for signalling.
130   
131   1. CQ
132   
133   This is to communicate "open VC", "close VC", "get stats" etc. to
134   the adapter. At most one command is retired every millisecond by the
135   card. There is no out of order completion or notification. The
136   driver needs to check the return code of the command, waiting as
137   appropriate.
138   
139   2. TXQ
140   
141   TX supply items are of variable length (scatter gather support) and
142   so the queue items are (more or less) pointers to the real thing.
143   Each TX supply item contains a unique, host-supplied handle (the skb
144   bus address seems most sensible as this works for Alphas as well,
145   there is no need to do any endian conversions on the handles).
146   
147   TX return items consist of just the handles above.
148   
149   3. RXQ (up to 4 of these with different lengths and buffer sizes)
150   
151   RX supply items consist of a unique, host-supplied handle (the skb
152   bus address again) and a pointer to the buffer data area.
153   
154   RX return items consist of the handle above, the VC, length and a
155   status word. This just screams "oh so easy" doesn't it?
156
157   Note on RX pool sizes:
158    
159   Each pool should have enough buffers to handle a back-to-back stream
160   of minimum sized frames on a single VC. For example:
161   
162     frame spacing = 3us (about right)
163     
164     delay = IRQ lat + RX handling + RX buffer replenish = 20 (us)  (a guess)
165     
166     min number of buffers for one VC = 1 + delay/spacing (buffers)
167
168     delay/spacing = latency = (20+2)/3 = 7 (buffers)  (rounding up)
169     
170   The 20us delay assumes that there is no need to sleep; if we need to
171   sleep to get buffers we are going to drop frames anyway.
172   
173   In fact, each pool should have enough buffers to support the
174   simultaneous reassembly of a separate frame on each VC and cope with
175   the case in which frames complete in round robin cell fashion on
176   each VC.
177   
178   Only one frame can complete at each cell arrival, so if "n" VCs are
179   open, the worst case is to have them all complete frames together
180   followed by all starting new frames together.
181   
182     desired number of buffers = n + delay/spacing
183     
184   These are the extreme requirements, however, they are "n+k" for some
185   "k" so we have only the constant to choose. This is the argument
186   rx_lats which current defaults to 7.
187   
188   Actually, "n ? n+k : 0" is better and this is what is implemented,
189   subject to the limit given by the pool size.
190   
191   4. Driver locking
192   
193   Simple spinlocks are used around the TX and RX queue mechanisms.
194   Anyone with a faster, working method is welcome to implement it.
195   
196   The adapter command queue is protected with a spinlock. We always
197   wait for commands to complete.
198   
199   A more complex form of locking is used around parts of the VC open
200   and close functions. There are three reasons for a lock: 1. we need
201   to do atomic rate reservation and release (not used yet), 2. Opening
202   sometimes involves two adapter commands which must not be separated
203   by another command on the same VC, 3. the changes to RX pool size
204   must be atomic. The lock needs to work over context switches, so we
205   use a semaphore.
206   
207   III Hardware Features and Microcode Bugs
208   
209   1. Byte Ordering
210   
211   *%^"$&%^$*&^"$(%^$#&^%$(&#%$*(&^#%!"!"!*!
212   
213   2. Memory access
214   
215   All structures that are not accessed using DMA must be 4-byte
216   aligned (not a problem) and must not cross 4MB boundaries.
217   
218   There is a DMA memory hole at E0000000-E00000FF (groan).
219   
220   TX fragments (DMA read) must not cross 4MB boundaries (would be 16MB
221   but for a hardware bug).
222   
223   RX buffers (DMA write) must not cross 16MB boundaries and must
224   include spare trailing bytes up to the next 4-byte boundary; they
225   will be written with rubbish.
226   
227   The PLX likes to prefetch; if reading up to 4 u32 past the end of
228   each TX fragment is not a problem, then TX can be made to go a
229   little faster by passing a flag at init that disables a prefetch
230   workaround. We do not pass this flag. (new microcode only)
231   
232   Now we:
233   . Note that alloc_skb rounds up size to a 16byte boundary.  
234   . Ensure all areas do not traverse 4MB boundaries.
235   . Ensure all areas do not start at a E00000xx bus address.
236   (I cannot be certain, but this may always hold with Linux)
237   . Make all failures cause a loud message.
238   . Discard non-conforming SKBs (causes TX failure or RX fill delay).
239   . Discard non-conforming TX fragment descriptors (the TX fails).
240   In the future we could:
241   . Allow RX areas that traverse 4MB (but not 16MB) boundaries.
242   . Segment TX areas into some/more fragments, when necessary.
243   . Relax checks for non-DMA items (ignore hole).
244   . Give scatter-gather (iovec) requirements using ???. (?)
245   
246   3. VC close is broken (only for new microcode)
247   
248   The VC close adapter microcode command fails to do anything if any
249   frames have been received on the VC but none have been transmitted.
250   Frames continue to be reassembled and passed (with IRQ) to the
251   driver.
252   
253   IV To Do List
254   
255   . Fix bugs!
256   
257   . Timer code may be broken.
258   
259   . Deal with buggy VC close (somehow) in microcode 12.
260   
261   . Handle interrupted and/or non-blocking writes - is this a job for
262     the protocol layer?
263   
264   . Add code to break up TX fragments when they span 4MB boundaries.
265   
266   . Add SUNI phy layer (need to know where SUNI lives on card).
267   
268   . Implement a tx_alloc fn to (a) satisfy TX alignment etc. and (b)
269     leave extra headroom space for Ambassador TX descriptors.
270   
271   . Understand these elements of struct atm_vcc: recvq (proto?),
272     sleep, callback, listenq, backlog_quota, reply and user_back.
273   
274   . Adjust TX/RX skb allocation to favour IP with LANE/CLIP (configurable).
275   
276   . Impose a TX-pending limit (2?) on each VC, help avoid TX q overflow.
277   
278   . Decide whether RX buffer recycling is or can be made completely safe;
279     turn it back on. It looks like Werner is going to axe this.
280   
281   . Implement QoS changes on open VCs (involves extracting parts of VC open
282     and close into separate functions and using them to make changes).
283   
284   . Hack on command queue so that someone can issue multiple commands and wait
285     on the last one (OR only "no-op" or "wait" commands are waited for).
286   
287   . Eliminate need for while-schedule around do_command.
288   
289 */
290
291 /********** microcode **********/
292
293 #ifdef AMB_NEW_MICROCODE
294 #define UCODE(x) UCODE2(atmsar12.x)
295 #else
296 #define UCODE(x) UCODE2(atmsar11.x)
297 #endif
298 #define UCODE2(x) #x
299
300 static u32 __devinitdata ucode_start =
301 #include UCODE(start)
302 ;
303
304 static region __devinitdata ucode_regions[] = {
305 #include UCODE(regions)
306   { 0, 0 }
307 };
308
309 static u32 __devinitdata ucode_data[] = {
310 #include UCODE(data)
311   0xdeadbeef
312 };
313
314 static void do_housekeeping (unsigned long arg);
315 /********** globals **********/
316
317 static unsigned short debug = 0;
318 static unsigned int cmds = 8;
319 static unsigned int txs = 32;
320 static unsigned int rxs[NUM_RX_POOLS] = { 64, 64, 64, 64 };
321 static unsigned int rxs_bs[NUM_RX_POOLS] = { 4080, 12240, 36720, 65535 };
322 static unsigned int rx_lats = 7;
323 static unsigned char pci_lat = 0;
324
325 static const unsigned long onegigmask = -1 << 30;
326
327 /********** access to adapter **********/
328
329 static inline void wr_plain (const amb_dev * dev, size_t addr, u32 data) {
330   PRINTD (DBG_FLOW|DBG_REGS, "wr: %08zx <- %08x", addr, data);
331 #ifdef AMB_MMIO
332   dev->membase[addr / sizeof(u32)] = data;
333 #else
334   outl (data, dev->iobase + addr);
335 #endif
336 }
337
338 static inline u32 rd_plain (const amb_dev * dev, size_t addr) {
339 #ifdef AMB_MMIO
340   u32 data = dev->membase[addr / sizeof(u32)];
341 #else
342   u32 data = inl (dev->iobase + addr);
343 #endif
344   PRINTD (DBG_FLOW|DBG_REGS, "rd: %08zx -> %08x", addr, data);
345   return data;
346 }
347
348 static inline void wr_mem (const amb_dev * dev, size_t addr, u32 data) {
349   __be32 be = cpu_to_be32 (data);
350   PRINTD (DBG_FLOW|DBG_REGS, "wr: %08zx <- %08x b[%08x]", addr, data, be);
351 #ifdef AMB_MMIO
352   dev->membase[addr / sizeof(u32)] = be;
353 #else
354   outl (be, dev->iobase + addr);
355 #endif
356 }
357
358 static inline u32 rd_mem (const amb_dev * dev, size_t addr) {
359 #ifdef AMB_MMIO
360   __be32 be = dev->membase[addr / sizeof(u32)];
361 #else
362   __be32 be = inl (dev->iobase + addr);
363 #endif
364   u32 data = be32_to_cpu (be);
365   PRINTD (DBG_FLOW|DBG_REGS, "rd: %08zx -> %08x b[%08x]", addr, data, be);
366   return data;
367 }
368
369 /********** dump routines **********/
370
371 static inline void dump_registers (const amb_dev * dev) {
372 #ifdef DEBUG_AMBASSADOR
373   if (debug & DBG_REGS) {
374     size_t i;
375     PRINTD (DBG_REGS, "reading PLX control: ");
376     for (i = 0x00; i < 0x30; i += sizeof(u32))
377       rd_mem (dev, i);
378     PRINTD (DBG_REGS, "reading mailboxes: ");
379     for (i = 0x40; i < 0x60; i += sizeof(u32))
380       rd_mem (dev, i);
381     PRINTD (DBG_REGS, "reading doorb irqev irqen reset:");
382     for (i = 0x60; i < 0x70; i += sizeof(u32))
383       rd_mem (dev, i);
384   }
385 #else
386   (void) dev;
387 #endif
388   return;
389 }
390
391 static inline void dump_loader_block (volatile loader_block * lb) {
392 #ifdef DEBUG_AMBASSADOR
393   unsigned int i;
394   PRINTDB (DBG_LOAD, "lb @ %p; res: %d, cmd: %d, pay:",
395            lb, be32_to_cpu (lb->result), be32_to_cpu (lb->command));
396   for (i = 0; i < MAX_COMMAND_DATA; ++i)
397     PRINTDM (DBG_LOAD, " %08x", be32_to_cpu (lb->payload.data[i]));
398   PRINTDE (DBG_LOAD, ", vld: %08x", be32_to_cpu (lb->valid));
399 #else
400   (void) lb;
401 #endif
402   return;
403 }
404
405 static inline void dump_command (command * cmd) {
406 #ifdef DEBUG_AMBASSADOR
407   unsigned int i;
408   PRINTDB (DBG_CMD, "cmd @ %p, req: %08x, pars:",
409            cmd, /*be32_to_cpu*/ (cmd->request));
410   for (i = 0; i < 3; ++i)
411     PRINTDM (DBG_CMD, " %08x", /*be32_to_cpu*/ (cmd->args.par[i]));
412   PRINTDE (DBG_CMD, "");
413 #else
414   (void) cmd;
415 #endif
416   return;
417 }
418
419 static inline void dump_skb (char * prefix, unsigned int vc, struct sk_buff * skb) {
420 #ifdef DEBUG_AMBASSADOR
421   unsigned int i;
422   unsigned char * data = skb->data;
423   PRINTDB (DBG_DATA, "%s(%u) ", prefix, vc);
424   for (i=0; i<skb->len && i < 256;i++)
425     PRINTDM (DBG_DATA, "%02x ", data[i]);
426   PRINTDE (DBG_DATA,"");
427 #else
428   (void) prefix;
429   (void) vc;
430   (void) skb;
431 #endif
432   return;
433 }
434
435 /********** check memory areas for use by Ambassador **********/
436
437 /* see limitations under Hardware Features */
438
439 static inline int check_area (void * start, size_t length) {
440   // assumes length > 0
441   const u32 fourmegmask = -1 << 22;
442   const u32 twofivesixmask = -1 << 8;
443   const u32 starthole = 0xE0000000;
444   u32 startaddress = virt_to_bus (start);
445   u32 lastaddress = startaddress+length-1;
446   if ((startaddress ^ lastaddress) & fourmegmask ||
447       (startaddress & twofivesixmask) == starthole) {
448     PRINTK (KERN_ERR, "check_area failure: [%x,%x] - mail maintainer!",
449             startaddress, lastaddress);
450     return -1;
451   } else {
452     return 0;
453   }
454 }
455
456 /********** free an skb (as per ATM device driver documentation) **********/
457
458 static inline void amb_kfree_skb (struct sk_buff * skb) {
459   if (ATM_SKB(skb)->vcc->pop) {
460     ATM_SKB(skb)->vcc->pop (ATM_SKB(skb)->vcc, skb);
461   } else {
462     dev_kfree_skb_any (skb);
463   }
464 }
465
466 /********** TX completion **********/
467
468 static inline void tx_complete (amb_dev * dev, tx_out * tx) {
469   tx_simple * tx_descr = bus_to_virt (tx->handle);
470   struct sk_buff * skb = tx_descr->skb;
471   
472   PRINTD (DBG_FLOW|DBG_TX, "tx_complete %p %p", dev, tx);
473   
474   // VC layer stats
475   atomic_inc(&ATM_SKB(skb)->vcc->stats->tx);
476   
477   // free the descriptor
478   kfree (tx_descr);
479   
480   // free the skb
481   amb_kfree_skb (skb);
482   
483   dev->stats.tx_ok++;
484   return;
485 }
486
487 /********** RX completion **********/
488
489 static void rx_complete (amb_dev * dev, rx_out * rx) {
490   struct sk_buff * skb = bus_to_virt (rx->handle);
491   u16 vc = be16_to_cpu (rx->vc);
492   // unused: u16 lec_id = be16_to_cpu (rx->lec_id);
493   u16 status = be16_to_cpu (rx->status);
494   u16 rx_len = be16_to_cpu (rx->length);
495   
496   PRINTD (DBG_FLOW|DBG_RX, "rx_complete %p %p (len=%hu)", dev, rx, rx_len);
497   
498   // XXX move this in and add to VC stats ???
499   if (!status) {
500     struct atm_vcc * atm_vcc = dev->rxer[vc];
501     dev->stats.rx.ok++;
502     
503     if (atm_vcc) {
504       
505       if (rx_len <= atm_vcc->qos.rxtp.max_sdu) {
506         
507         if (atm_charge (atm_vcc, skb->truesize)) {
508           
509           // prepare socket buffer
510           ATM_SKB(skb)->vcc = atm_vcc;
511           skb_put (skb, rx_len);
512           
513           dump_skb ("<<<", vc, skb);
514           
515           // VC layer stats
516           atomic_inc(&atm_vcc->stats->rx);
517           __net_timestamp(skb);
518           // end of our responsability
519           atm_vcc->push (atm_vcc, skb);
520           return;
521           
522         } else {
523           // someone fix this (message), please!
524           PRINTD (DBG_INFO|DBG_RX, "dropped thanks to atm_charge (vc %hu, truesize %u)", vc, skb->truesize);
525           // drop stats incremented in atm_charge
526         }
527         
528       } else {
529         PRINTK (KERN_INFO, "dropped over-size frame");
530         // should we count this?
531         atomic_inc(&atm_vcc->stats->rx_drop);
532       }
533       
534     } else {
535       PRINTD (DBG_WARN|DBG_RX, "got frame but RX closed for channel %hu", vc);
536       // this is an adapter bug, only in new version of microcode
537     }
538     
539   } else {
540     dev->stats.rx.error++;
541     if (status & CRC_ERR)
542       dev->stats.rx.badcrc++;
543     if (status & LEN_ERR)
544       dev->stats.rx.toolong++;
545     if (status & ABORT_ERR)
546       dev->stats.rx.aborted++;
547     if (status & UNUSED_ERR)
548       dev->stats.rx.unused++;
549   }
550   
551   dev_kfree_skb_any (skb);
552   return;
553 }
554
555 /*
556   
557   Note on queue handling.
558   
559   Here "give" and "take" refer to queue entries and a queue (pair)
560   rather than frames to or from the host or adapter. Empty frame
561   buffers are given to the RX queue pair and returned unused or
562   containing RX frames. TX frames (well, pointers to TX fragment
563   lists) are given to the TX queue pair, completions are returned.
564   
565 */
566
567 /********** command queue **********/
568
569 // I really don't like this, but it's the best I can do at the moment
570
571 // also, the callers are responsible for byte order as the microcode
572 // sometimes does 16-bit accesses (yuk yuk yuk)
573
574 static int command_do (amb_dev * dev, command * cmd) {
575   amb_cq * cq = &dev->cq;
576   volatile amb_cq_ptrs * ptrs = &cq->ptrs;
577   command * my_slot;
578   
579   PRINTD (DBG_FLOW|DBG_CMD, "command_do %p", dev);
580   
581   if (test_bit (dead, &dev->flags))
582     return 0;
583   
584   spin_lock (&cq->lock);
585   
586   // if not full...
587   if (cq->pending < cq->maximum) {
588     // remember my slot for later
589     my_slot = ptrs->in;
590     PRINTD (DBG_CMD, "command in slot %p", my_slot);
591     
592     dump_command (cmd);
593     
594     // copy command in
595     *ptrs->in = *cmd;
596     cq->pending++;
597     ptrs->in = NEXTQ (ptrs->in, ptrs->start, ptrs->limit);
598     
599     // mail the command
600     wr_mem (dev, offsetof(amb_mem, mb.adapter.cmd_address), virt_to_bus (ptrs->in));
601     
602     if (cq->pending > cq->high)
603       cq->high = cq->pending;
604     spin_unlock (&cq->lock);
605     
606     // these comments were in a while-loop before, msleep removes the loop
607     // go to sleep
608     // PRINTD (DBG_CMD, "wait: sleeping %lu for command", timeout);
609     msleep(cq->pending);
610     
611     // wait for my slot to be reached (all waiters are here or above, until...)
612     while (ptrs->out != my_slot) {
613       PRINTD (DBG_CMD, "wait: command slot (now at %p)", ptrs->out);
614       set_current_state(TASK_UNINTERRUPTIBLE);
615       schedule();
616     }
617     
618     // wait on my slot (... one gets to its slot, and... )
619     while (ptrs->out->request != cpu_to_be32 (SRB_COMPLETE)) {
620       PRINTD (DBG_CMD, "wait: command slot completion");
621       set_current_state(TASK_UNINTERRUPTIBLE);
622       schedule();
623     }
624     
625     PRINTD (DBG_CMD, "command complete");
626     // update queue (... moves the queue along to the next slot)
627     spin_lock (&cq->lock);
628     cq->pending--;
629     // copy command out
630     *cmd = *ptrs->out;
631     ptrs->out = NEXTQ (ptrs->out, ptrs->start, ptrs->limit);
632     spin_unlock (&cq->lock);
633     
634     return 0;
635   } else {
636     cq->filled++;
637     spin_unlock (&cq->lock);
638     return -EAGAIN;
639   }
640   
641 }
642
643 /********** TX queue pair **********/
644
645 static inline int tx_give (amb_dev * dev, tx_in * tx) {
646   amb_txq * txq = &dev->txq;
647   unsigned long flags;
648   
649   PRINTD (DBG_FLOW|DBG_TX, "tx_give %p", dev);
650
651   if (test_bit (dead, &dev->flags))
652     return 0;
653   
654   spin_lock_irqsave (&txq->lock, flags);
655   
656   if (txq->pending < txq->maximum) {
657     PRINTD (DBG_TX, "TX in slot %p", txq->in.ptr);
658
659     *txq->in.ptr = *tx;
660     txq->pending++;
661     txq->in.ptr = NEXTQ (txq->in.ptr, txq->in.start, txq->in.limit);
662     // hand over the TX and ring the bell
663     wr_mem (dev, offsetof(amb_mem, mb.adapter.tx_address), virt_to_bus (txq->in.ptr));
664     wr_mem (dev, offsetof(amb_mem, doorbell), TX_FRAME);
665     
666     if (txq->pending > txq->high)
667       txq->high = txq->pending;
668     spin_unlock_irqrestore (&txq->lock, flags);
669     return 0;
670   } else {
671     txq->filled++;
672     spin_unlock_irqrestore (&txq->lock, flags);
673     return -EAGAIN;
674   }
675 }
676
677 static inline int tx_take (amb_dev * dev) {
678   amb_txq * txq = &dev->txq;
679   unsigned long flags;
680   
681   PRINTD (DBG_FLOW|DBG_TX, "tx_take %p", dev);
682   
683   spin_lock_irqsave (&txq->lock, flags);
684   
685   if (txq->pending && txq->out.ptr->handle) {
686     // deal with TX completion
687     tx_complete (dev, txq->out.ptr);
688     // mark unused again
689     txq->out.ptr->handle = 0;
690     // remove item
691     txq->pending--;
692     txq->out.ptr = NEXTQ (txq->out.ptr, txq->out.start, txq->out.limit);
693     
694     spin_unlock_irqrestore (&txq->lock, flags);
695     return 0;
696   } else {
697     
698     spin_unlock_irqrestore (&txq->lock, flags);
699     return -1;
700   }
701 }
702
703 /********** RX queue pairs **********/
704
705 static inline int rx_give (amb_dev * dev, rx_in * rx, unsigned char pool) {
706   amb_rxq * rxq = &dev->rxq[pool];
707   unsigned long flags;
708   
709   PRINTD (DBG_FLOW|DBG_RX, "rx_give %p[%hu]", dev, pool);
710   
711   spin_lock_irqsave (&rxq->lock, flags);
712   
713   if (rxq->pending < rxq->maximum) {
714     PRINTD (DBG_RX, "RX in slot %p", rxq->in.ptr);
715
716     *rxq->in.ptr = *rx;
717     rxq->pending++;
718     rxq->in.ptr = NEXTQ (rxq->in.ptr, rxq->in.start, rxq->in.limit);
719     // hand over the RX buffer
720     wr_mem (dev, offsetof(amb_mem, mb.adapter.rx_address[pool]), virt_to_bus (rxq->in.ptr));
721     
722     spin_unlock_irqrestore (&rxq->lock, flags);
723     return 0;
724   } else {
725     spin_unlock_irqrestore (&rxq->lock, flags);
726     return -1;
727   }
728 }
729
730 static inline int rx_take (amb_dev * dev, unsigned char pool) {
731   amb_rxq * rxq = &dev->rxq[pool];
732   unsigned long flags;
733   
734   PRINTD (DBG_FLOW|DBG_RX, "rx_take %p[%hu]", dev, pool);
735   
736   spin_lock_irqsave (&rxq->lock, flags);
737   
738   if (rxq->pending && (rxq->out.ptr->status || rxq->out.ptr->length)) {
739     // deal with RX completion
740     rx_complete (dev, rxq->out.ptr);
741     // mark unused again
742     rxq->out.ptr->status = 0;
743     rxq->out.ptr->length = 0;
744     // remove item
745     rxq->pending--;
746     rxq->out.ptr = NEXTQ (rxq->out.ptr, rxq->out.start, rxq->out.limit);
747     
748     if (rxq->pending < rxq->low)
749       rxq->low = rxq->pending;
750     spin_unlock_irqrestore (&rxq->lock, flags);
751     return 0;
752   } else {
753     if (!rxq->pending && rxq->buffers_wanted)
754       rxq->emptied++;
755     spin_unlock_irqrestore (&rxq->lock, flags);
756     return -1;
757   }
758 }
759
760 /********** RX Pool handling **********/
761
762 /* pre: buffers_wanted = 0, post: pending = 0 */
763 static inline void drain_rx_pool (amb_dev * dev, unsigned char pool) {
764   amb_rxq * rxq = &dev->rxq[pool];
765   
766   PRINTD (DBG_FLOW|DBG_POOL, "drain_rx_pool %p %hu", dev, pool);
767   
768   if (test_bit (dead, &dev->flags))
769     return;
770   
771   /* we are not quite like the fill pool routines as we cannot just
772      remove one buffer, we have to remove all of them, but we might as
773      well pretend... */
774   if (rxq->pending > rxq->buffers_wanted) {
775     command cmd;
776     cmd.request = cpu_to_be32 (SRB_FLUSH_BUFFER_Q);
777     cmd.args.flush.flags = cpu_to_be32 (pool << SRB_POOL_SHIFT);
778     while (command_do (dev, &cmd))
779       schedule();
780     /* the pool may also be emptied via the interrupt handler */
781     while (rxq->pending > rxq->buffers_wanted)
782       if (rx_take (dev, pool))
783         schedule();
784   }
785   
786   return;
787 }
788
789 static void drain_rx_pools (amb_dev * dev) {
790   unsigned char pool;
791   
792   PRINTD (DBG_FLOW|DBG_POOL, "drain_rx_pools %p", dev);
793   
794   for (pool = 0; pool < NUM_RX_POOLS; ++pool)
795     drain_rx_pool (dev, pool);
796 }
797
798 static inline void fill_rx_pool (amb_dev * dev, unsigned char pool,
799                                  gfp_t priority)
800 {
801   rx_in rx;
802   amb_rxq * rxq;
803   
804   PRINTD (DBG_FLOW|DBG_POOL, "fill_rx_pool %p %hu %x", dev, pool, priority);
805   
806   if (test_bit (dead, &dev->flags))
807     return;
808   
809   rxq = &dev->rxq[pool];
810   while (rxq->pending < rxq->maximum && rxq->pending < rxq->buffers_wanted) {
811     
812     struct sk_buff * skb = alloc_skb (rxq->buffer_size, priority);
813     if (!skb) {
814       PRINTD (DBG_SKB|DBG_POOL, "failed to allocate skb for RX pool %hu", pool);
815       return;
816     }
817     if (check_area (skb->data, skb->truesize)) {
818       dev_kfree_skb_any (skb);
819       return;
820     }
821     // cast needed as there is no %? for pointer differences
822     PRINTD (DBG_SKB, "allocated skb at %p, head %p, area %li",
823             skb, skb->head, (long) (skb->end - skb->head));
824     rx.handle = virt_to_bus (skb);
825     rx.host_address = cpu_to_be32 (virt_to_bus (skb->data));
826     if (rx_give (dev, &rx, pool))
827       dev_kfree_skb_any (skb);
828     
829   }
830   
831   return;
832 }
833
834 // top up all RX pools (can also be called as a bottom half)
835 static void fill_rx_pools (amb_dev * dev) {
836   unsigned char pool;
837   
838   PRINTD (DBG_FLOW|DBG_POOL, "fill_rx_pools %p", dev);
839   
840   for (pool = 0; pool < NUM_RX_POOLS; ++pool)
841     fill_rx_pool (dev, pool, GFP_ATOMIC);
842   
843   return;
844 }
845
846 /********** enable host interrupts **********/
847
848 static inline void interrupts_on (amb_dev * dev) {
849   wr_plain (dev, offsetof(amb_mem, interrupt_control),
850             rd_plain (dev, offsetof(amb_mem, interrupt_control))
851             | AMB_INTERRUPT_BITS);
852 }
853
854 /********** disable host interrupts **********/
855
856 static inline void interrupts_off (amb_dev * dev) {
857   wr_plain (dev, offsetof(amb_mem, interrupt_control),
858             rd_plain (dev, offsetof(amb_mem, interrupt_control))
859             &~ AMB_INTERRUPT_BITS);
860 }
861
862 /********** interrupt handling **********/
863
864 static irqreturn_t interrupt_handler(int irq, void *dev_id) {
865   amb_dev * dev = (amb_dev *) dev_id;
866   
867   PRINTD (DBG_IRQ|DBG_FLOW, "interrupt_handler: %p", dev_id);
868   
869   if (!dev_id) {
870     PRINTD (DBG_IRQ|DBG_ERR, "irq with NULL dev_id: %d", irq);
871     return IRQ_NONE;
872   }
873   
874   {
875     u32 interrupt = rd_plain (dev, offsetof(amb_mem, interrupt));
876   
877     // for us or someone else sharing the same interrupt
878     if (!interrupt) {
879       PRINTD (DBG_IRQ, "irq not for me: %d", irq);
880       return IRQ_NONE;
881     }
882     
883     // definitely for us
884     PRINTD (DBG_IRQ, "FYI: interrupt was %08x", interrupt);
885     wr_plain (dev, offsetof(amb_mem, interrupt), -1);
886   }
887   
888   {
889     unsigned int irq_work = 0;
890     unsigned char pool;
891     for (pool = 0; pool < NUM_RX_POOLS; ++pool)
892       while (!rx_take (dev, pool))
893         ++irq_work;
894     while (!tx_take (dev))
895       ++irq_work;
896   
897     if (irq_work) {
898 #ifdef FILL_RX_POOLS_IN_BH
899       schedule_work (&dev->bh);
900 #else
901       fill_rx_pools (dev);
902 #endif
903
904       PRINTD (DBG_IRQ, "work done: %u", irq_work);
905     } else {
906       PRINTD (DBG_IRQ|DBG_WARN, "no work done");
907     }
908   }
909   
910   PRINTD (DBG_IRQ|DBG_FLOW, "interrupt_handler done: %p", dev_id);
911   return IRQ_HANDLED;
912 }
913
914 /********** make rate (not quite as much fun as Horizon) **********/
915
916 static int make_rate (unsigned int rate, rounding r,
917                       u16 * bits, unsigned int * actual) {
918   unsigned char exp = -1; // hush gcc
919   unsigned int man = -1;  // hush gcc
920   
921   PRINTD (DBG_FLOW|DBG_QOS, "make_rate %u", rate);
922   
923   // rates in cells per second, ITU format (nasty 16-bit floating-point)
924   // given 5-bit e and 9-bit m:
925   // rate = EITHER (1+m/2^9)*2^e    OR 0
926   // bits = EITHER 1<<14 | e<<9 | m OR 0
927   // (bit 15 is "reserved", bit 14 "non-zero")
928   // smallest rate is 0 (special representation)
929   // largest rate is (1+511/512)*2^31 = 4290772992 (< 2^32-1)
930   // smallest non-zero rate is (1+0/512)*2^0 = 1 (> 0)
931   // simple algorithm:
932   // find position of top bit, this gives e
933   // remove top bit and shift (rounding if feeling clever) by 9-e
934   
935   // ucode bug: please don't set bit 14! so 0 rate not representable
936   
937   if (rate > 0xffc00000U) {
938     // larger than largest representable rate
939     
940     if (r == round_up) {
941         return -EINVAL;
942     } else {
943       exp = 31;
944       man = 511;
945     }
946     
947   } else if (rate) {
948     // representable rate
949     
950     exp = 31;
951     man = rate;
952     
953     // invariant: rate = man*2^(exp-31)
954     while (!(man & (1<<31))) {
955       exp = exp - 1;
956       man = man<<1;
957     }
958     
959     // man has top bit set
960     // rate = (2^31+(man-2^31))*2^(exp-31)
961     // rate = (1+(man-2^31)/2^31)*2^exp
962     man = man<<1;
963     man &= 0xffffffffU; // a nop on 32-bit systems
964     // rate = (1+man/2^32)*2^exp
965     
966     // exp is in the range 0 to 31, man is in the range 0 to 2^32-1
967     // time to lose significance... we want m in the range 0 to 2^9-1
968     // rounding presents a minor problem... we first decide which way
969     // we are rounding (based on given rounding direction and possibly
970     // the bits of the mantissa that are to be discarded).
971     
972     switch (r) {
973       case round_down: {
974         // just truncate
975         man = man>>(32-9);
976         break;
977       }
978       case round_up: {
979         // check all bits that we are discarding
980         if (man & (-1>>9)) {
981           man = (man>>(32-9)) + 1;
982           if (man == (1<<9)) {
983             // no need to check for round up outside of range
984             man = 0;
985             exp += 1;
986           }
987         } else {
988           man = (man>>(32-9));
989         }
990         break;
991       }
992       case round_nearest: {
993         // check msb that we are discarding
994         if (man & (1<<(32-9-1))) {
995           man = (man>>(32-9)) + 1;
996           if (man == (1<<9)) {
997             // no need to check for round up outside of range
998             man = 0;
999             exp += 1;
1000           }
1001         } else {
1002           man = (man>>(32-9));
1003         }
1004         break;
1005       }
1006     }
1007     
1008   } else {
1009     // zero rate - not representable
1010     
1011     if (r == round_down) {
1012       return -EINVAL;
1013     } else {
1014       exp = 0;
1015       man = 0;
1016     }
1017     
1018   }
1019   
1020   PRINTD (DBG_QOS, "rate: man=%u, exp=%hu", man, exp);
1021   
1022   if (bits)
1023     *bits = /* (1<<14) | */ (exp<<9) | man;
1024   
1025   if (actual)
1026     *actual = (exp >= 9)
1027       ? (1 << exp) + (man << (exp-9))
1028       : (1 << exp) + ((man + (1<<(9-exp-1))) >> (9-exp));
1029   
1030   return 0;
1031 }
1032
1033 /********** Linux ATM Operations **********/
1034
1035 // some are not yet implemented while others do not make sense for
1036 // this device
1037
1038 /********** Open a VC **********/
1039
1040 static int amb_open (struct atm_vcc * atm_vcc)
1041 {
1042   int error;
1043   
1044   struct atm_qos * qos;
1045   struct atm_trafprm * txtp;
1046   struct atm_trafprm * rxtp;
1047   u16 tx_rate_bits;
1048   u16 tx_vc_bits = -1; // hush gcc
1049   u16 tx_frame_bits = -1; // hush gcc
1050   
1051   amb_dev * dev = AMB_DEV(atm_vcc->dev);
1052   amb_vcc * vcc;
1053   unsigned char pool = -1; // hush gcc
1054   short vpi = atm_vcc->vpi;
1055   int vci = atm_vcc->vci;
1056   
1057   PRINTD (DBG_FLOW|DBG_VCC, "amb_open %x %x", vpi, vci);
1058   
1059 #ifdef ATM_VPI_UNSPEC
1060   // UNSPEC is deprecated, remove this code eventually
1061   if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC) {
1062     PRINTK (KERN_WARNING, "rejecting open with unspecified VPI/VCI (deprecated)");
1063     return -EINVAL;
1064   }
1065 #endif
1066   
1067   if (!(0 <= vpi && vpi < (1<<NUM_VPI_BITS) &&
1068         0 <= vci && vci < (1<<NUM_VCI_BITS))) {
1069     PRINTD (DBG_WARN|DBG_VCC, "VPI/VCI out of range: %hd/%d", vpi, vci);
1070     return -EINVAL;
1071   }
1072   
1073   qos = &atm_vcc->qos;
1074   
1075   if (qos->aal != ATM_AAL5) {
1076     PRINTD (DBG_QOS, "AAL not supported");
1077     return -EINVAL;
1078   }
1079   
1080   // traffic parameters
1081   
1082   PRINTD (DBG_QOS, "TX:");
1083   txtp = &qos->txtp;
1084   if (txtp->traffic_class != ATM_NONE) {
1085     switch (txtp->traffic_class) {
1086       case ATM_UBR: {
1087         // we take "the PCR" as a rate-cap
1088         int pcr = atm_pcr_goal (txtp);
1089         if (!pcr) {
1090           // no rate cap
1091           tx_rate_bits = 0;
1092           tx_vc_bits = TX_UBR;
1093           tx_frame_bits = TX_FRAME_NOTCAP;
1094         } else {
1095           rounding r;
1096           if (pcr < 0) {
1097             r = round_down;
1098             pcr = -pcr;
1099           } else {
1100             r = round_up;
1101           }
1102           error = make_rate (pcr, r, &tx_rate_bits, NULL);
1103           tx_vc_bits = TX_UBR_CAPPED;
1104           tx_frame_bits = TX_FRAME_CAPPED;
1105         }
1106         break;
1107       }
1108 #if 0
1109       case ATM_ABR: {
1110         pcr = atm_pcr_goal (txtp);
1111         PRINTD (DBG_QOS, "pcr goal = %d", pcr);
1112         break;
1113       }
1114 #endif
1115       default: {
1116         // PRINTD (DBG_QOS, "request for non-UBR/ABR denied");
1117         PRINTD (DBG_QOS, "request for non-UBR denied");
1118         return -EINVAL;
1119       }
1120     }
1121     PRINTD (DBG_QOS, "tx_rate_bits=%hx, tx_vc_bits=%hx",
1122             tx_rate_bits, tx_vc_bits);
1123   }
1124   
1125   PRINTD (DBG_QOS, "RX:");
1126   rxtp = &qos->rxtp;
1127   if (rxtp->traffic_class == ATM_NONE) {
1128     // do nothing
1129   } else {
1130     // choose an RX pool (arranged in increasing size)
1131     for (pool = 0; pool < NUM_RX_POOLS; ++pool)
1132       if ((unsigned int) rxtp->max_sdu <= dev->rxq[pool].buffer_size) {
1133         PRINTD (DBG_VCC|DBG_QOS|DBG_POOL, "chose pool %hu (max_sdu %u <= %u)",
1134                 pool, rxtp->max_sdu, dev->rxq[pool].buffer_size);
1135         break;
1136       }
1137     if (pool == NUM_RX_POOLS) {
1138       PRINTD (DBG_WARN|DBG_VCC|DBG_QOS|DBG_POOL,
1139               "no pool suitable for VC (RX max_sdu %d is too large)",
1140               rxtp->max_sdu);
1141       return -EINVAL;
1142     }
1143     
1144     switch (rxtp->traffic_class) {
1145       case ATM_UBR: {
1146         break;
1147       }
1148 #if 0
1149       case ATM_ABR: {
1150         pcr = atm_pcr_goal (rxtp);
1151         PRINTD (DBG_QOS, "pcr goal = %d", pcr);
1152         break;
1153       }
1154 #endif
1155       default: {
1156         // PRINTD (DBG_QOS, "request for non-UBR/ABR denied");
1157         PRINTD (DBG_QOS, "request for non-UBR denied");
1158         return -EINVAL;
1159       }
1160     }
1161   }
1162   
1163   // get space for our vcc stuff
1164   vcc = kmalloc (sizeof(amb_vcc), GFP_KERNEL);
1165   if (!vcc) {
1166     PRINTK (KERN_ERR, "out of memory!");
1167     return -ENOMEM;
1168   }
1169   atm_vcc->dev_data = (void *) vcc;
1170   
1171   // no failures beyond this point
1172   
1173   // we are not really "immediately before allocating the connection
1174   // identifier in hardware", but it will just have to do!
1175   set_bit(ATM_VF_ADDR,&atm_vcc->flags);
1176   
1177   if (txtp->traffic_class != ATM_NONE) {
1178     command cmd;
1179     
1180     vcc->tx_frame_bits = tx_frame_bits;
1181     
1182     down (&dev->vcc_sf);
1183     if (dev->rxer[vci]) {
1184       // RXer on the channel already, just modify rate...
1185       cmd.request = cpu_to_be32 (SRB_MODIFY_VC_RATE);
1186       cmd.args.modify_rate.vc = cpu_to_be32 (vci);  // vpi 0
1187       cmd.args.modify_rate.rate = cpu_to_be32 (tx_rate_bits << SRB_RATE_SHIFT);
1188       while (command_do (dev, &cmd))
1189         schedule();
1190       // ... and TX flags, preserving the RX pool
1191       cmd.request = cpu_to_be32 (SRB_MODIFY_VC_FLAGS);
1192       cmd.args.modify_flags.vc = cpu_to_be32 (vci);  // vpi 0
1193       cmd.args.modify_flags.flags = cpu_to_be32
1194         ( (AMB_VCC(dev->rxer[vci])->rx_info.pool << SRB_POOL_SHIFT)
1195           | (tx_vc_bits << SRB_FLAGS_SHIFT) );
1196       while (command_do (dev, &cmd))
1197         schedule();
1198     } else {
1199       // no RXer on the channel, just open (with pool zero)
1200       cmd.request = cpu_to_be32 (SRB_OPEN_VC);
1201       cmd.args.open.vc = cpu_to_be32 (vci);  // vpi 0
1202       cmd.args.open.flags = cpu_to_be32 (tx_vc_bits << SRB_FLAGS_SHIFT);
1203       cmd.args.open.rate = cpu_to_be32 (tx_rate_bits << SRB_RATE_SHIFT);
1204       while (command_do (dev, &cmd))
1205         schedule();
1206     }
1207     dev->txer[vci].tx_present = 1;
1208     up (&dev->vcc_sf);
1209   }
1210   
1211   if (rxtp->traffic_class != ATM_NONE) {
1212     command cmd;
1213     
1214     vcc->rx_info.pool = pool;
1215     
1216     down (&dev->vcc_sf); 
1217     /* grow RX buffer pool */
1218     if (!dev->rxq[pool].buffers_wanted)
1219       dev->rxq[pool].buffers_wanted = rx_lats;
1220     dev->rxq[pool].buffers_wanted += 1;
1221     fill_rx_pool (dev, pool, GFP_KERNEL);
1222     
1223     if (dev->txer[vci].tx_present) {
1224       // TXer on the channel already
1225       // switch (from pool zero) to this pool, preserving the TX bits
1226       cmd.request = cpu_to_be32 (SRB_MODIFY_VC_FLAGS);
1227       cmd.args.modify_flags.vc = cpu_to_be32 (vci);  // vpi 0
1228       cmd.args.modify_flags.flags = cpu_to_be32
1229         ( (pool << SRB_POOL_SHIFT)
1230           | (dev->txer[vci].tx_vc_bits << SRB_FLAGS_SHIFT) );
1231     } else {
1232       // no TXer on the channel, open the VC (with no rate info)
1233       cmd.request = cpu_to_be32 (SRB_OPEN_VC);
1234       cmd.args.open.vc = cpu_to_be32 (vci);  // vpi 0
1235       cmd.args.open.flags = cpu_to_be32 (pool << SRB_POOL_SHIFT);
1236       cmd.args.open.rate = cpu_to_be32 (0);
1237     }
1238     while (command_do (dev, &cmd))
1239       schedule();
1240     // this link allows RX frames through
1241     dev->rxer[vci] = atm_vcc;
1242     up (&dev->vcc_sf);
1243   }
1244   
1245   // indicate readiness
1246   set_bit(ATM_VF_READY,&atm_vcc->flags);
1247   
1248   return 0;
1249 }
1250
1251 /********** Close a VC **********/
1252
1253 static void amb_close (struct atm_vcc * atm_vcc) {
1254   amb_dev * dev = AMB_DEV (atm_vcc->dev);
1255   amb_vcc * vcc = AMB_VCC (atm_vcc);
1256   u16 vci = atm_vcc->vci;
1257   
1258   PRINTD (DBG_VCC|DBG_FLOW, "amb_close");
1259   
1260   // indicate unreadiness
1261   clear_bit(ATM_VF_READY,&atm_vcc->flags);
1262   
1263   // disable TXing
1264   if (atm_vcc->qos.txtp.traffic_class != ATM_NONE) {
1265     command cmd;
1266     
1267     down (&dev->vcc_sf);
1268     if (dev->rxer[vci]) {
1269       // RXer still on the channel, just modify rate... XXX not really needed
1270       cmd.request = cpu_to_be32 (SRB_MODIFY_VC_RATE);
1271       cmd.args.modify_rate.vc = cpu_to_be32 (vci);  // vpi 0
1272       cmd.args.modify_rate.rate = cpu_to_be32 (0);
1273       // ... and clear TX rate flags (XXX to stop RM cell output?), preserving RX pool
1274     } else {
1275       // no RXer on the channel, close channel
1276       cmd.request = cpu_to_be32 (SRB_CLOSE_VC);
1277       cmd.args.close.vc = cpu_to_be32 (vci); // vpi 0
1278     }
1279     dev->txer[vci].tx_present = 0;
1280     while (command_do (dev, &cmd))
1281       schedule();
1282     up (&dev->vcc_sf);
1283   }
1284   
1285   // disable RXing
1286   if (atm_vcc->qos.rxtp.traffic_class != ATM_NONE) {
1287     command cmd;
1288     
1289     // this is (the?) one reason why we need the amb_vcc struct
1290     unsigned char pool = vcc->rx_info.pool;
1291     
1292     down (&dev->vcc_sf);
1293     if (dev->txer[vci].tx_present) {
1294       // TXer still on the channel, just go to pool zero XXX not really needed
1295       cmd.request = cpu_to_be32 (SRB_MODIFY_VC_FLAGS);
1296       cmd.args.modify_flags.vc = cpu_to_be32 (vci);  // vpi 0
1297       cmd.args.modify_flags.flags = cpu_to_be32
1298         (dev->txer[vci].tx_vc_bits << SRB_FLAGS_SHIFT);
1299     } else {
1300       // no TXer on the channel, close the VC
1301       cmd.request = cpu_to_be32 (SRB_CLOSE_VC);
1302       cmd.args.close.vc = cpu_to_be32 (vci); // vpi 0
1303     }
1304     // forget the rxer - no more skbs will be pushed
1305     if (atm_vcc != dev->rxer[vci])
1306       PRINTK (KERN_ERR, "%s vcc=%p rxer[vci]=%p",
1307               "arghhh! we're going to die!",
1308               vcc, dev->rxer[vci]);
1309     dev->rxer[vci] = NULL;
1310     while (command_do (dev, &cmd))
1311       schedule();
1312     
1313     /* shrink RX buffer pool */
1314     dev->rxq[pool].buffers_wanted -= 1;
1315     if (dev->rxq[pool].buffers_wanted == rx_lats) {
1316       dev->rxq[pool].buffers_wanted = 0;
1317       drain_rx_pool (dev, pool);
1318     }
1319     up (&dev->vcc_sf);
1320   }
1321   
1322   // free our structure
1323   kfree (vcc);
1324   
1325   // say the VPI/VCI is free again
1326   clear_bit(ATM_VF_ADDR,&atm_vcc->flags);
1327
1328   return;
1329 }
1330
1331 /********** Set socket options for a VC **********/
1332
1333 // int amb_getsockopt (struct atm_vcc * atm_vcc, int level, int optname, void * optval, int optlen);
1334
1335 /********** Set socket options for a VC **********/
1336
1337 // int amb_setsockopt (struct atm_vcc * atm_vcc, int level, int optname, void * optval, int optlen);
1338
1339 /********** Send **********/
1340
1341 static int amb_send (struct atm_vcc * atm_vcc, struct sk_buff * skb) {
1342   amb_dev * dev = AMB_DEV(atm_vcc->dev);
1343   amb_vcc * vcc = AMB_VCC(atm_vcc);
1344   u16 vc = atm_vcc->vci;
1345   unsigned int tx_len = skb->len;
1346   unsigned char * tx_data = skb->data;
1347   tx_simple * tx_descr;
1348   tx_in tx;
1349   
1350   if (test_bit (dead, &dev->flags))
1351     return -EIO;
1352   
1353   PRINTD (DBG_FLOW|DBG_TX, "amb_send vc %x data %p len %u",
1354           vc, tx_data, tx_len);
1355   
1356   dump_skb (">>>", vc, skb);
1357   
1358   if (!dev->txer[vc].tx_present) {
1359     PRINTK (KERN_ERR, "attempt to send on RX-only VC %x", vc);
1360     return -EBADFD;
1361   }
1362   
1363   // this is a driver private field so we have to set it ourselves,
1364   // despite the fact that we are _required_ to use it to check for a
1365   // pop function
1366   ATM_SKB(skb)->vcc = atm_vcc;
1367   
1368   if (skb->len > (size_t) atm_vcc->qos.txtp.max_sdu) {
1369     PRINTK (KERN_ERR, "sk_buff length greater than agreed max_sdu, dropping...");
1370     return -EIO;
1371   }
1372   
1373   if (check_area (skb->data, skb->len)) {
1374     atomic_inc(&atm_vcc->stats->tx_err);
1375     return -ENOMEM; // ?
1376   }
1377   
1378   // allocate memory for fragments
1379   tx_descr = kmalloc (sizeof(tx_simple), GFP_KERNEL);
1380   if (!tx_descr) {
1381     PRINTK (KERN_ERR, "could not allocate TX descriptor");
1382     return -ENOMEM;
1383   }
1384   if (check_area (tx_descr, sizeof(tx_simple))) {
1385     kfree (tx_descr);
1386     return -ENOMEM;
1387   }
1388   PRINTD (DBG_TX, "fragment list allocated at %p", tx_descr);
1389   
1390   tx_descr->skb = skb;
1391   
1392   tx_descr->tx_frag.bytes = cpu_to_be32 (tx_len);
1393   tx_descr->tx_frag.address = cpu_to_be32 (virt_to_bus (tx_data));
1394   
1395   tx_descr->tx_frag_end.handle = virt_to_bus (tx_descr);
1396   tx_descr->tx_frag_end.vc = 0;
1397   tx_descr->tx_frag_end.next_descriptor_length = 0;
1398   tx_descr->tx_frag_end.next_descriptor = 0;
1399 #ifdef AMB_NEW_MICROCODE
1400   tx_descr->tx_frag_end.cpcs_uu = 0;
1401   tx_descr->tx_frag_end.cpi = 0;
1402   tx_descr->tx_frag_end.pad = 0;
1403 #endif
1404   
1405   tx.vc = cpu_to_be16 (vcc->tx_frame_bits | vc);
1406   tx.tx_descr_length = cpu_to_be16 (sizeof(tx_frag)+sizeof(tx_frag_end));
1407   tx.tx_descr_addr = cpu_to_be32 (virt_to_bus (&tx_descr->tx_frag));
1408   
1409   while (tx_give (dev, &tx))
1410     schedule();
1411   return 0;
1412 }
1413
1414 /********** Change QoS on a VC **********/
1415
1416 // int amb_change_qos (struct atm_vcc * atm_vcc, struct atm_qos * qos, int flags);
1417
1418 /********** Free RX Socket Buffer **********/
1419
1420 #if 0
1421 static void amb_free_rx_skb (struct atm_vcc * atm_vcc, struct sk_buff * skb) {
1422   amb_dev * dev = AMB_DEV (atm_vcc->dev);
1423   amb_vcc * vcc = AMB_VCC (atm_vcc);
1424   unsigned char pool = vcc->rx_info.pool;
1425   rx_in rx;
1426   
1427   // This may be unsafe for various reasons that I cannot really guess
1428   // at. However, I note that the ATM layer calls kfree_skb rather
1429   // than dev_kfree_skb at this point so we are least covered as far
1430   // as buffer locking goes. There may be bugs if pcap clones RX skbs.
1431
1432   PRINTD (DBG_FLOW|DBG_SKB, "amb_rx_free skb %p (atm_vcc %p, vcc %p)",
1433           skb, atm_vcc, vcc);
1434   
1435   rx.handle = virt_to_bus (skb);
1436   rx.host_address = cpu_to_be32 (virt_to_bus (skb->data));
1437   
1438   skb->data = skb->head;
1439   skb->tail = skb->head;
1440   skb->len = 0;
1441   
1442   if (!rx_give (dev, &rx, pool)) {
1443     // success
1444     PRINTD (DBG_SKB|DBG_POOL, "recycled skb for pool %hu", pool);
1445     return;
1446   }
1447   
1448   // just do what the ATM layer would have done
1449   dev_kfree_skb_any (skb);
1450   
1451   return;
1452 }
1453 #endif
1454
1455 /********** Proc File Output **********/
1456
1457 static int amb_proc_read (struct atm_dev * atm_dev, loff_t * pos, char * page) {
1458   amb_dev * dev = AMB_DEV (atm_dev);
1459   int left = *pos;
1460   unsigned char pool;
1461   
1462   PRINTD (DBG_FLOW, "amb_proc_read");
1463   
1464   /* more diagnostics here? */
1465   
1466   if (!left--) {
1467     amb_stats * s = &dev->stats;
1468     return sprintf (page,
1469                     "frames: TX OK %lu, RX OK %lu, RX bad %lu "
1470                     "(CRC %lu, long %lu, aborted %lu, unused %lu).\n",
1471                     s->tx_ok, s->rx.ok, s->rx.error,
1472                     s->rx.badcrc, s->rx.toolong,
1473                     s->rx.aborted, s->rx.unused);
1474   }
1475   
1476   if (!left--) {
1477     amb_cq * c = &dev->cq;
1478     return sprintf (page, "cmd queue [cur/hi/max]: %u/%u/%u. ",
1479                     c->pending, c->high, c->maximum);
1480   }
1481   
1482   if (!left--) {
1483     amb_txq * t = &dev->txq;
1484     return sprintf (page, "TX queue [cur/max high full]: %u/%u %u %u.\n",
1485                     t->pending, t->maximum, t->high, t->filled);
1486   }
1487   
1488   if (!left--) {
1489     unsigned int count = sprintf (page, "RX queues [cur/max/req low empty]:");
1490     for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
1491       amb_rxq * r = &dev->rxq[pool];
1492       count += sprintf (page+count, " %u/%u/%u %u %u",
1493                         r->pending, r->maximum, r->buffers_wanted, r->low, r->emptied);
1494     }
1495     count += sprintf (page+count, ".\n");
1496     return count;
1497   }
1498   
1499   if (!left--) {
1500     unsigned int count = sprintf (page, "RX buffer sizes:");
1501     for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
1502       amb_rxq * r = &dev->rxq[pool];
1503       count += sprintf (page+count, " %u", r->buffer_size);
1504     }
1505     count += sprintf (page+count, ".\n");
1506     return count;
1507   }
1508   
1509 #if 0
1510   if (!left--) {
1511     // suni block etc?
1512   }
1513 #endif
1514   
1515   return 0;
1516 }
1517
1518 /********** Operation Structure **********/
1519
1520 static const struct atmdev_ops amb_ops = {
1521   .open         = amb_open,
1522   .close        = amb_close,
1523   .send         = amb_send,
1524   .proc_read    = amb_proc_read,
1525   .owner        = THIS_MODULE,
1526 };
1527
1528 /********** housekeeping **********/
1529 static void do_housekeeping (unsigned long arg) {
1530   amb_dev * dev = (amb_dev *) arg;
1531   
1532   // could collect device-specific (not driver/atm-linux) stats here
1533       
1534   // last resort refill once every ten seconds
1535   fill_rx_pools (dev);
1536   mod_timer(&dev->housekeeping, jiffies + 10*HZ);
1537   
1538   return;
1539 }
1540
1541 /********** creation of communication queues **********/
1542
1543 static int __devinit create_queues (amb_dev * dev, unsigned int cmds,
1544                                  unsigned int txs, unsigned int * rxs,
1545                                  unsigned int * rx_buffer_sizes) {
1546   unsigned char pool;
1547   size_t total = 0;
1548   void * memory;
1549   void * limit;
1550   
1551   PRINTD (DBG_FLOW, "create_queues %p", dev);
1552   
1553   total += cmds * sizeof(command);
1554   
1555   total += txs * (sizeof(tx_in) + sizeof(tx_out));
1556   
1557   for (pool = 0; pool < NUM_RX_POOLS; ++pool)
1558     total += rxs[pool] * (sizeof(rx_in) + sizeof(rx_out));
1559   
1560   memory = kmalloc (total, GFP_KERNEL);
1561   if (!memory) {
1562     PRINTK (KERN_ERR, "could not allocate queues");
1563     return -ENOMEM;
1564   }
1565   if (check_area (memory, total)) {
1566     PRINTK (KERN_ERR, "queues allocated in nasty area");
1567     kfree (memory);
1568     return -ENOMEM;
1569   }
1570   
1571   limit = memory + total;
1572   PRINTD (DBG_INIT, "queues from %p to %p", memory, limit);
1573   
1574   PRINTD (DBG_CMD, "command queue at %p", memory);
1575   
1576   {
1577     command * cmd = memory;
1578     amb_cq * cq = &dev->cq;
1579     
1580     cq->pending = 0;
1581     cq->high = 0;
1582     cq->maximum = cmds - 1;
1583     
1584     cq->ptrs.start = cmd;
1585     cq->ptrs.in = cmd;
1586     cq->ptrs.out = cmd;
1587     cq->ptrs.limit = cmd + cmds;
1588     
1589     memory = cq->ptrs.limit;
1590   }
1591   
1592   PRINTD (DBG_TX, "TX queue pair at %p", memory);
1593   
1594   {
1595     tx_in * in = memory;
1596     tx_out * out;
1597     amb_txq * txq = &dev->txq;
1598     
1599     txq->pending = 0;
1600     txq->high = 0;
1601     txq->filled = 0;
1602     txq->maximum = txs - 1;
1603     
1604     txq->in.start = in;
1605     txq->in.ptr = in;
1606     txq->in.limit = in + txs;
1607     
1608     memory = txq->in.limit;
1609     out = memory;
1610     
1611     txq->out.start = out;
1612     txq->out.ptr = out;
1613     txq->out.limit = out + txs;
1614     
1615     memory = txq->out.limit;
1616   }
1617   
1618   PRINTD (DBG_RX, "RX queue pairs at %p", memory);
1619   
1620   for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
1621     rx_in * in = memory;
1622     rx_out * out;
1623     amb_rxq * rxq = &dev->rxq[pool];
1624     
1625     rxq->buffer_size = rx_buffer_sizes[pool];
1626     rxq->buffers_wanted = 0;
1627     
1628     rxq->pending = 0;
1629     rxq->low = rxs[pool] - 1;
1630     rxq->emptied = 0;
1631     rxq->maximum = rxs[pool] - 1;
1632     
1633     rxq->in.start = in;
1634     rxq->in.ptr = in;
1635     rxq->in.limit = in + rxs[pool];
1636     
1637     memory = rxq->in.limit;
1638     out = memory;
1639     
1640     rxq->out.start = out;
1641     rxq->out.ptr = out;
1642     rxq->out.limit = out + rxs[pool];
1643     
1644     memory = rxq->out.limit;
1645   }
1646   
1647   if (memory == limit) {
1648     return 0;
1649   } else {
1650     PRINTK (KERN_ERR, "bad queue alloc %p != %p (tell maintainer)", memory, limit);
1651     kfree (limit - total);
1652     return -ENOMEM;
1653   }
1654   
1655 }
1656
1657 /********** destruction of communication queues **********/
1658
1659 static void destroy_queues (amb_dev * dev) {
1660   // all queues assumed empty
1661   void * memory = dev->cq.ptrs.start;
1662   // includes txq.in, txq.out, rxq[].in and rxq[].out
1663   
1664   PRINTD (DBG_FLOW, "destroy_queues %p", dev);
1665   
1666   PRINTD (DBG_INIT, "freeing queues at %p", memory);
1667   kfree (memory);
1668   
1669   return;
1670 }
1671
1672 /********** basic loader commands and error handling **********/
1673 // centisecond timeouts - guessing away here
1674 static unsigned int command_timeouts [] = {
1675         [host_memory_test]     = 15,
1676         [read_adapter_memory]  = 2,
1677         [write_adapter_memory] = 2,
1678         [adapter_start]        = 50,
1679         [get_version_number]   = 10,
1680         [interrupt_host]       = 1,
1681         [flash_erase_sector]   = 1,
1682         [adap_download_block]  = 1,
1683         [adap_erase_flash]     = 1,
1684         [adap_run_in_iram]     = 1,
1685         [adap_end_download]    = 1
1686 };
1687
1688
1689 static unsigned int command_successes [] = {
1690         [host_memory_test]     = COMMAND_PASSED_TEST,
1691         [read_adapter_memory]  = COMMAND_READ_DATA_OK,
1692         [write_adapter_memory] = COMMAND_WRITE_DATA_OK,
1693         [adapter_start]        = COMMAND_COMPLETE,
1694         [get_version_number]   = COMMAND_COMPLETE,
1695         [interrupt_host]       = COMMAND_COMPLETE,
1696         [flash_erase_sector]   = COMMAND_COMPLETE,
1697         [adap_download_block]  = COMMAND_COMPLETE,
1698         [adap_erase_flash]     = COMMAND_COMPLETE,
1699         [adap_run_in_iram]     = COMMAND_COMPLETE,
1700         [adap_end_download]    = COMMAND_COMPLETE
1701 };
1702   
1703 static  int decode_loader_result (loader_command cmd, u32 result)
1704 {
1705         int res;
1706         const char *msg;
1707
1708         if (result == command_successes[cmd])
1709                 return 0;
1710
1711         switch (result) {
1712                 case BAD_COMMAND:
1713                         res = -EINVAL;
1714                         msg = "bad command";
1715                         break;
1716                 case COMMAND_IN_PROGRESS:
1717                         res = -ETIMEDOUT;
1718                         msg = "command in progress";
1719                         break;
1720                 case COMMAND_PASSED_TEST:
1721                         res = 0;
1722                         msg = "command passed test";
1723                         break;
1724                 case COMMAND_FAILED_TEST:
1725                         res = -EIO;
1726                         msg = "command failed test";
1727                         break;
1728                 case COMMAND_READ_DATA_OK:
1729                         res = 0;
1730                         msg = "command read data ok";
1731                         break;
1732                 case COMMAND_READ_BAD_ADDRESS:
1733                         res = -EINVAL;
1734                         msg = "command read bad address";
1735                         break;
1736                 case COMMAND_WRITE_DATA_OK:
1737                         res = 0;
1738                         msg = "command write data ok";
1739                         break;
1740                 case COMMAND_WRITE_BAD_ADDRESS:
1741                         res = -EINVAL;
1742                         msg = "command write bad address";
1743                         break;
1744                 case COMMAND_WRITE_FLASH_FAILURE:
1745                         res = -EIO;
1746                         msg = "command write flash failure";
1747                         break;
1748                 case COMMAND_COMPLETE:
1749                         res = 0;
1750                         msg = "command complete";
1751                         break;
1752                 case COMMAND_FLASH_ERASE_FAILURE:
1753                         res = -EIO;
1754                         msg = "command flash erase failure";
1755                         break;
1756                 case COMMAND_WRITE_BAD_DATA:
1757                         res = -EINVAL;
1758                         msg = "command write bad data";
1759                         break;
1760                 default:
1761                         res = -EINVAL;
1762                         msg = "unknown error";
1763                         PRINTD (DBG_LOAD|DBG_ERR,
1764                                 "decode_loader_result got %d=%x !",
1765                                 result, result);
1766                         break;
1767         }
1768
1769         PRINTK (KERN_ERR, "%s", msg);
1770         return res;
1771 }
1772
1773 static int __devinit do_loader_command (volatile loader_block * lb,
1774                                      const amb_dev * dev, loader_command cmd) {
1775   
1776   unsigned long timeout;
1777   
1778   PRINTD (DBG_FLOW|DBG_LOAD, "do_loader_command");
1779   
1780   /* do a command
1781      
1782      Set the return value to zero, set the command type and set the
1783      valid entry to the right magic value. The payload is already
1784      correctly byte-ordered so we leave it alone. Hit the doorbell
1785      with the bus address of this structure.
1786      
1787   */
1788   
1789   lb->result = 0;
1790   lb->command = cpu_to_be32 (cmd);
1791   lb->valid = cpu_to_be32 (DMA_VALID);
1792   // dump_registers (dev);
1793   // dump_loader_block (lb);
1794   wr_mem (dev, offsetof(amb_mem, doorbell), virt_to_bus (lb) & ~onegigmask);
1795   
1796   timeout = command_timeouts[cmd] * 10;
1797   
1798   while (!lb->result || lb->result == cpu_to_be32 (COMMAND_IN_PROGRESS))
1799     if (timeout) {
1800       timeout = msleep_interruptible(timeout);
1801     } else {
1802       PRINTD (DBG_LOAD|DBG_ERR, "command %d timed out", cmd);
1803       dump_registers (dev);
1804       dump_loader_block (lb);
1805       return -ETIMEDOUT;
1806     }
1807   
1808   if (cmd == adapter_start) {
1809     // wait for start command to acknowledge...
1810     timeout = 100;
1811     while (rd_plain (dev, offsetof(amb_mem, doorbell)))
1812       if (timeout) {
1813         timeout = msleep_interruptible(timeout);
1814       } else {
1815         PRINTD (DBG_LOAD|DBG_ERR, "start command did not clear doorbell, res=%08x",
1816                 be32_to_cpu (lb->result));
1817         dump_registers (dev);
1818         return -ETIMEDOUT;
1819       }
1820     return 0;
1821   } else {
1822     return decode_loader_result (cmd, be32_to_cpu (lb->result));
1823   }
1824   
1825 }
1826
1827 /* loader: determine loader version */
1828
1829 static int __devinit get_loader_version (loader_block * lb,
1830                                       const amb_dev * dev, u32 * version) {
1831   int res;
1832   
1833   PRINTD (DBG_FLOW|DBG_LOAD, "get_loader_version");
1834   
1835   res = do_loader_command (lb, dev, get_version_number);
1836   if (res)
1837     return res;
1838   if (version)
1839     *version = be32_to_cpu (lb->payload.version);
1840   return 0;
1841 }
1842
1843 /* loader: write memory data blocks */
1844
1845 static int __devinit loader_write (loader_block * lb,
1846                                 const amb_dev * dev, const u32 * data,
1847                                 u32 address, unsigned int count) {
1848   unsigned int i;
1849   transfer_block * tb = &lb->payload.transfer;
1850   
1851   PRINTD (DBG_FLOW|DBG_LOAD, "loader_write");
1852   
1853   if (count > MAX_TRANSFER_DATA)
1854     return -EINVAL;
1855   tb->address = cpu_to_be32 (address);
1856   tb->count = cpu_to_be32 (count);
1857   for (i = 0; i < count; ++i)
1858     tb->data[i] = cpu_to_be32 (data[i]);
1859   return do_loader_command (lb, dev, write_adapter_memory);
1860 }
1861
1862 /* loader: verify memory data blocks */
1863
1864 static int __devinit loader_verify (loader_block * lb,
1865                                  const amb_dev * dev, const u32 * data,
1866                                  u32 address, unsigned int count) {
1867   unsigned int i;
1868   transfer_block * tb = &lb->payload.transfer;
1869   int res;
1870   
1871   PRINTD (DBG_FLOW|DBG_LOAD, "loader_verify");
1872   
1873   if (count > MAX_TRANSFER_DATA)
1874     return -EINVAL;
1875   tb->address = cpu_to_be32 (address);
1876   tb->count = cpu_to_be32 (count);
1877   res = do_loader_command (lb, dev, read_adapter_memory);
1878   if (!res)
1879     for (i = 0; i < count; ++i)
1880       if (tb->data[i] != cpu_to_be32 (data[i])) {
1881         res = -EINVAL;
1882         break;
1883       }
1884   return res;
1885 }
1886
1887 /* loader: start microcode */
1888
1889 static int __devinit loader_start (loader_block * lb,
1890                                 const amb_dev * dev, u32 address) {
1891   PRINTD (DBG_FLOW|DBG_LOAD, "loader_start");
1892   
1893   lb->payload.start = cpu_to_be32 (address);
1894   return do_loader_command (lb, dev, adapter_start);
1895 }
1896
1897 /********** reset card **********/
1898
1899 static inline void sf (const char * msg)
1900 {
1901         PRINTK (KERN_ERR, "self-test failed: %s", msg);
1902 }
1903
1904 static int amb_reset (amb_dev * dev, int diags) {
1905   u32 word;
1906   
1907   PRINTD (DBG_FLOW|DBG_LOAD, "amb_reset");
1908   
1909   word = rd_plain (dev, offsetof(amb_mem, reset_control));
1910   // put card into reset state
1911   wr_plain (dev, offsetof(amb_mem, reset_control), word | AMB_RESET_BITS);
1912   // wait a short while
1913   udelay (10);
1914 #if 1
1915   // put card into known good state
1916   wr_plain (dev, offsetof(amb_mem, interrupt_control), AMB_DOORBELL_BITS);
1917   // clear all interrupts just in case
1918   wr_plain (dev, offsetof(amb_mem, interrupt), -1);
1919 #endif
1920   // clear self-test done flag
1921   wr_plain (dev, offsetof(amb_mem, mb.loader.ready), 0);
1922   // take card out of reset state
1923   wr_plain (dev, offsetof(amb_mem, reset_control), word &~ AMB_RESET_BITS);
1924   
1925   if (diags) { 
1926     unsigned long timeout;
1927     // 4.2 second wait
1928     msleep(4200);
1929     // half second time-out
1930     timeout = 500;
1931     while (!rd_plain (dev, offsetof(amb_mem, mb.loader.ready)))
1932       if (timeout) {
1933         timeout = msleep_interruptible(timeout);
1934       } else {
1935         PRINTD (DBG_LOAD|DBG_ERR, "reset timed out");
1936         return -ETIMEDOUT;
1937       }
1938     
1939     // get results of self-test
1940     // XXX double check byte-order
1941     word = rd_mem (dev, offsetof(amb_mem, mb.loader.result));
1942     if (word & SELF_TEST_FAILURE) {
1943       if (word & GPINT_TST_FAILURE)
1944         sf ("interrupt");
1945       if (word & SUNI_DATA_PATTERN_FAILURE)
1946         sf ("SUNI data pattern");
1947       if (word & SUNI_DATA_BITS_FAILURE)
1948         sf ("SUNI data bits");
1949       if (word & SUNI_UTOPIA_FAILURE)
1950         sf ("SUNI UTOPIA interface");
1951       if (word & SUNI_FIFO_FAILURE)
1952         sf ("SUNI cell buffer FIFO");
1953       if (word & SRAM_FAILURE)
1954         sf ("bad SRAM");
1955       // better return value?
1956       return -EIO;
1957     }
1958     
1959   }
1960   return 0;
1961 }
1962
1963 /********** transfer and start the microcode **********/
1964
1965 static int __devinit ucode_init (loader_block * lb, amb_dev * dev) {
1966   unsigned int i = 0;
1967   unsigned int total = 0;
1968   const u32 * pointer = ucode_data;
1969   u32 address;
1970   unsigned int count;
1971   int res;
1972   
1973   PRINTD (DBG_FLOW|DBG_LOAD, "ucode_init");
1974   
1975   while (address = ucode_regions[i].start,
1976          count = ucode_regions[i].count) {
1977     PRINTD (DBG_LOAD, "starting region (%x, %u)", address, count);
1978     while (count) {
1979       unsigned int words;
1980       if (count <= MAX_TRANSFER_DATA)
1981         words = count;
1982       else
1983         words = MAX_TRANSFER_DATA;
1984       total += words;
1985       res = loader_write (lb, dev, pointer, address, words);
1986       if (res)
1987         return res;
1988       res = loader_verify (lb, dev, pointer, address, words);
1989       if (res)
1990         return res;
1991       count -= words;
1992       address += sizeof(u32) * words;
1993       pointer += words;
1994     }
1995     i += 1;
1996   }
1997   if (*pointer == ATM_POISON) {
1998     return loader_start (lb, dev, ucode_start);
1999   } else {
2000     // cast needed as there is no %? for pointer differnces
2001     PRINTD (DBG_LOAD|DBG_ERR,
2002             "offset=%li, *pointer=%x, address=%x, total=%u",
2003             (long) (pointer - ucode_data), *pointer, address, total);
2004     PRINTK (KERN_ERR, "incorrect microcode data");
2005     return -ENOMEM;
2006   }
2007 }
2008
2009 /********** give adapter parameters **********/
2010   
2011 static inline __be32 bus_addr(void * addr) {
2012     return cpu_to_be32 (virt_to_bus (addr));
2013 }
2014
2015 static int __devinit amb_talk (amb_dev * dev) {
2016   adap_talk_block a;
2017   unsigned char pool;
2018   unsigned long timeout;
2019   
2020   PRINTD (DBG_FLOW, "amb_talk %p", dev);
2021   
2022   a.command_start = bus_addr (dev->cq.ptrs.start);
2023   a.command_end   = bus_addr (dev->cq.ptrs.limit);
2024   a.tx_start      = bus_addr (dev->txq.in.start);
2025   a.tx_end        = bus_addr (dev->txq.in.limit);
2026   a.txcom_start   = bus_addr (dev->txq.out.start);
2027   a.txcom_end     = bus_addr (dev->txq.out.limit);
2028   
2029   for (pool = 0; pool < NUM_RX_POOLS; ++pool) {
2030     // the other "a" items are set up by the adapter
2031     a.rec_struct[pool].buffer_start = bus_addr (dev->rxq[pool].in.start);
2032     a.rec_struct[pool].buffer_end   = bus_addr (dev->rxq[pool].in.limit);
2033     a.rec_struct[pool].rx_start     = bus_addr (dev->rxq[pool].out.start);
2034     a.rec_struct[pool].rx_end       = bus_addr (dev->rxq[pool].out.limit);
2035     a.rec_struct[pool].buffer_size = cpu_to_be32 (dev->rxq[pool].buffer_size);
2036   }
2037   
2038 #ifdef AMB_NEW_MICROCODE
2039   // disable fast PLX prefetching
2040   a.init_flags = 0;
2041 #endif
2042   
2043   // pass the structure
2044   wr_mem (dev, offsetof(amb_mem, doorbell), virt_to_bus (&a));
2045   
2046   // 2.2 second wait (must not touch doorbell during 2 second DMA test)
2047   msleep(2200);
2048   // give the adapter another half second?
2049   timeout = 500;
2050   while (rd_plain (dev, offsetof(amb_mem, doorbell)))
2051     if (timeout) {
2052       timeout = msleep_interruptible(timeout);
2053     } else {
2054       PRINTD (DBG_INIT|DBG_ERR, "adapter init timed out");
2055       return -ETIMEDOUT;
2056     }
2057   
2058   return 0;
2059 }
2060
2061 // get microcode version
2062 static void __devinit amb_ucode_version (amb_dev * dev) {
2063   u32 major;
2064   u32 minor;
2065   command cmd;
2066   cmd.request = cpu_to_be32 (SRB_GET_VERSION);
2067   while (command_do (dev, &cmd)) {
2068     set_current_state(TASK_UNINTERRUPTIBLE);
2069     schedule();
2070   }
2071   major = be32_to_cpu (cmd.args.version.major);
2072   minor = be32_to_cpu (cmd.args.version.minor);
2073   PRINTK (KERN_INFO, "microcode version is %u.%u", major, minor);
2074 }
2075   
2076 // swap bits within byte to get Ethernet ordering
2077 static u8 bit_swap (u8 byte)
2078 {
2079     const u8 swap[] = {
2080       0x0, 0x8, 0x4, 0xc,
2081       0x2, 0xa, 0x6, 0xe,
2082       0x1, 0x9, 0x5, 0xd,
2083       0x3, 0xb, 0x7, 0xf
2084     };
2085     return ((swap[byte & 0xf]<<4) | swap[byte>>4]);
2086 }
2087
2088 // get end station address
2089 static void __devinit amb_esi (amb_dev * dev, u8 * esi) {
2090   u32 lower4;
2091   u16 upper2;
2092   command cmd;
2093   
2094   cmd.request = cpu_to_be32 (SRB_GET_BIA);
2095   while (command_do (dev, &cmd)) {
2096     set_current_state(TASK_UNINTERRUPTIBLE);
2097     schedule();
2098   }
2099   lower4 = be32_to_cpu (cmd.args.bia.lower4);
2100   upper2 = be32_to_cpu (cmd.args.bia.upper2);
2101   PRINTD (DBG_LOAD, "BIA: lower4: %08x, upper2 %04x", lower4, upper2);
2102   
2103   if (esi) {
2104     unsigned int i;
2105     
2106     PRINTDB (DBG_INIT, "ESI:");
2107     for (i = 0; i < ESI_LEN; ++i) {
2108       if (i < 4)
2109           esi[i] = bit_swap (lower4>>(8*i));
2110       else
2111           esi[i] = bit_swap (upper2>>(8*(i-4)));
2112       PRINTDM (DBG_INIT, " %02x", esi[i]);
2113     }
2114     
2115     PRINTDE (DBG_INIT, "");
2116   }
2117   
2118   return;
2119 }
2120   
2121 static void fixup_plx_window (amb_dev *dev, loader_block *lb)
2122 {
2123         // fix up the PLX-mapped window base address to match the block
2124         unsigned long blb;
2125         u32 mapreg;
2126         blb = virt_to_bus(lb);
2127         // the kernel stack had better not ever cross a 1Gb boundary!
2128         mapreg = rd_plain (dev, offsetof(amb_mem, stuff[10]));
2129         mapreg &= ~onegigmask;
2130         mapreg |= blb & onegigmask;
2131         wr_plain (dev, offsetof(amb_mem, stuff[10]), mapreg);
2132         return;
2133 }
2134
2135 static int __devinit amb_init (amb_dev * dev)
2136 {
2137   loader_block lb;
2138   
2139   u32 version;
2140   
2141   if (amb_reset (dev, 1)) {
2142     PRINTK (KERN_ERR, "card reset failed!");
2143   } else {
2144     fixup_plx_window (dev, &lb);
2145     
2146     if (get_loader_version (&lb, dev, &version)) {
2147       PRINTK (KERN_INFO, "failed to get loader version");
2148     } else {
2149       PRINTK (KERN_INFO, "loader version is %08x", version);
2150       
2151       if (ucode_init (&lb, dev)) {
2152         PRINTK (KERN_ERR, "microcode failure");
2153       } else if (create_queues (dev, cmds, txs, rxs, rxs_bs)) {
2154         PRINTK (KERN_ERR, "failed to get memory for queues");
2155       } else {
2156         
2157         if (amb_talk (dev)) {
2158           PRINTK (KERN_ERR, "adapter did not accept queues");
2159         } else {
2160           
2161           amb_ucode_version (dev);
2162           return 0;
2163           
2164         } /* amb_talk */
2165         
2166         destroy_queues (dev);
2167       } /* create_queues, ucode_init */
2168       
2169       amb_reset (dev, 0);
2170     } /* get_loader_version */
2171     
2172   } /* amb_reset */
2173   
2174   return -EINVAL;
2175 }
2176
2177 static void setup_dev(amb_dev *dev, struct pci_dev *pci_dev) 
2178 {
2179       unsigned char pool;
2180       memset (dev, 0, sizeof(amb_dev));
2181       
2182       // set up known dev items straight away
2183       dev->pci_dev = pci_dev; 
2184       pci_set_drvdata(pci_dev, dev);
2185       
2186       dev->iobase = pci_resource_start (pci_dev, 1);
2187       dev->irq = pci_dev->irq; 
2188       dev->membase = bus_to_virt(pci_resource_start(pci_dev, 0));
2189       
2190       // flags (currently only dead)
2191       dev->flags = 0;
2192       
2193       // Allocate cell rates (fibre)
2194       // ATM_OC3_PCR = 1555200000/8/270*260/53 - 29/53
2195       // to be really pedantic, this should be ATM_OC3c_PCR
2196       dev->tx_avail = ATM_OC3_PCR;
2197       dev->rx_avail = ATM_OC3_PCR;
2198       
2199 #ifdef FILL_RX_POOLS_IN_BH
2200       // initialise bottom half
2201       INIT_WORK(&dev->bh, (void (*)(void *)) fill_rx_pools, dev);
2202 #endif
2203       
2204       // semaphore for txer/rxer modifications - we cannot use a
2205       // spinlock as the critical region needs to switch processes
2206       init_MUTEX (&dev->vcc_sf);
2207       // queue manipulation spinlocks; we want atomic reads and
2208       // writes to the queue descriptors (handles IRQ and SMP)
2209       // consider replacing "int pending" -> "atomic_t available"
2210       // => problem related to who gets to move queue pointers
2211       spin_lock_init (&dev->cq.lock);
2212       spin_lock_init (&dev->txq.lock);
2213       for (pool = 0; pool < NUM_RX_POOLS; ++pool)
2214         spin_lock_init (&dev->rxq[pool].lock);
2215 }
2216
2217 static void setup_pci_dev(struct pci_dev *pci_dev)
2218 {
2219         unsigned char lat;
2220       
2221         // enable bus master accesses
2222         pci_set_master(pci_dev);
2223
2224         // frobnicate latency (upwards, usually)
2225         pci_read_config_byte (pci_dev, PCI_LATENCY_TIMER, &lat);
2226
2227         if (!pci_lat)
2228                 pci_lat = (lat < MIN_PCI_LATENCY) ? MIN_PCI_LATENCY : lat;
2229
2230         if (lat != pci_lat) {
2231                 PRINTK (KERN_INFO, "Changing PCI latency timer from %hu to %hu",
2232                         lat, pci_lat);
2233                 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, pci_lat);
2234         }
2235 }
2236
2237 static int __devinit amb_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_ent)
2238 {
2239         amb_dev * dev;
2240         int err;
2241         unsigned int irq;
2242       
2243         err = pci_enable_device(pci_dev);
2244         if (err < 0) {
2245                 PRINTK (KERN_ERR, "skipped broken (PLX rev 2) card");
2246                 goto out;
2247         }
2248
2249         // read resources from PCI configuration space
2250         irq = pci_dev->irq;
2251
2252         if (pci_dev->device == PCI_DEVICE_ID_MADGE_AMBASSADOR_BAD) {
2253                 PRINTK (KERN_ERR, "skipped broken (PLX rev 2) card");
2254                 err = -EINVAL;
2255                 goto out_disable;
2256         }
2257
2258         PRINTD (DBG_INFO, "found Madge ATM adapter (amb) at"
2259                 " IO %llx, IRQ %u, MEM %p",
2260                 (unsigned long long)pci_resource_start(pci_dev, 1),
2261                 irq, bus_to_virt(pci_resource_start(pci_dev, 0)));
2262
2263         // check IO region
2264         err = pci_request_region(pci_dev, 1, DEV_LABEL);
2265         if (err < 0) {
2266                 PRINTK (KERN_ERR, "IO range already in use!");
2267                 goto out_disable;
2268         }
2269
2270         dev = kmalloc (sizeof(amb_dev), GFP_KERNEL);
2271         if (!dev) {
2272                 PRINTK (KERN_ERR, "out of memory!");
2273                 err = -ENOMEM;
2274                 goto out_release;
2275         }
2276
2277         setup_dev(dev, pci_dev);
2278
2279         err = amb_init(dev);
2280         if (err < 0) {
2281                 PRINTK (KERN_ERR, "adapter initialisation failure");
2282                 goto out_free;
2283         }
2284
2285         setup_pci_dev(pci_dev);
2286
2287         // grab (but share) IRQ and install handler
2288         err = request_irq(irq, interrupt_handler, IRQF_SHARED, DEV_LABEL, dev);
2289         if (err < 0) {
2290                 PRINTK (KERN_ERR, "request IRQ failed!");
2291                 goto out_reset;
2292         }
2293
2294         dev->atm_dev = atm_dev_register (DEV_LABEL, &amb_ops, -1, NULL);
2295         if (!dev->atm_dev) {
2296                 PRINTD (DBG_ERR, "failed to register Madge ATM adapter");
2297                 err = -EINVAL;
2298                 goto out_free_irq;
2299         }
2300
2301         PRINTD (DBG_INFO, "registered Madge ATM adapter (no. %d) (%p) at %p",
2302                 dev->atm_dev->number, dev, dev->atm_dev);
2303                 dev->atm_dev->dev_data = (void *) dev;
2304
2305         // register our address
2306         amb_esi (dev, dev->atm_dev->esi);
2307
2308         // 0 bits for vpi, 10 bits for vci
2309         dev->atm_dev->ci_range.vpi_bits = NUM_VPI_BITS;
2310         dev->atm_dev->ci_range.vci_bits = NUM_VCI_BITS;
2311
2312         init_timer(&dev->housekeeping);
2313         dev->housekeeping.function = do_housekeeping;
2314         dev->housekeeping.data = (unsigned long) dev;
2315         mod_timer(&dev->housekeeping, jiffies);
2316
2317         // enable host interrupts
2318         interrupts_on (dev);
2319
2320 out:
2321         return err;
2322
2323 out_free_irq:
2324         free_irq(irq, dev);
2325 out_reset:
2326         amb_reset(dev, 0);
2327 out_free:
2328         kfree(dev);
2329 out_release:
2330         pci_release_region(pci_dev, 1);
2331 out_disable:
2332         pci_disable_device(pci_dev);
2333         goto out;
2334 }
2335
2336
2337 static void __devexit amb_remove_one(struct pci_dev *pci_dev)
2338 {
2339         struct amb_dev *dev;
2340
2341         dev = pci_get_drvdata(pci_dev);
2342
2343         PRINTD(DBG_INFO|DBG_INIT, "closing %p (atm_dev = %p)", dev, dev->atm_dev);
2344         del_timer_sync(&dev->housekeeping);
2345         // the drain should not be necessary
2346         drain_rx_pools(dev);
2347         interrupts_off(dev);
2348         amb_reset(dev, 0);
2349         free_irq(dev->irq, dev);
2350         pci_disable_device(pci_dev);
2351         destroy_queues(dev);
2352         atm_dev_deregister(dev->atm_dev);
2353         kfree(dev);
2354         pci_release_region(pci_dev, 1);
2355 }
2356
2357 static void __init amb_check_args (void) {
2358   unsigned char pool;
2359   unsigned int max_rx_size;
2360   
2361 #ifdef DEBUG_AMBASSADOR
2362   PRINTK (KERN_NOTICE, "debug bitmap is %hx", debug &= DBG_MASK);
2363 #else
2364   if (debug)
2365     PRINTK (KERN_NOTICE, "no debugging support");
2366 #endif
2367   
2368   if (cmds < MIN_QUEUE_SIZE)
2369     PRINTK (KERN_NOTICE, "cmds has been raised to %u",
2370             cmds = MIN_QUEUE_SIZE);
2371   
2372   if (txs < MIN_QUEUE_SIZE)
2373     PRINTK (KERN_NOTICE, "txs has been raised to %u",
2374             txs = MIN_QUEUE_SIZE);
2375   
2376   for (pool = 0; pool < NUM_RX_POOLS; ++pool)
2377     if (rxs[pool] < MIN_QUEUE_SIZE)
2378       PRINTK (KERN_NOTICE, "rxs[%hu] has been raised to %u",
2379               pool, rxs[pool] = MIN_QUEUE_SIZE);
2380   
2381   // buffers sizes should be greater than zero and strictly increasing
2382   max_rx_size = 0;
2383   for (pool = 0; pool < NUM_RX_POOLS; ++pool)
2384     if (rxs_bs[pool] <= max_rx_size)
2385       PRINTK (KERN_NOTICE, "useless pool (rxs_bs[%hu] = %u)",
2386               pool, rxs_bs[pool]);
2387     else
2388       max_rx_size = rxs_bs[pool];
2389   
2390   if (rx_lats < MIN_RX_BUFFERS)
2391     PRINTK (KERN_NOTICE, "rx_lats has been raised to %u",
2392             rx_lats = MIN_RX_BUFFERS);
2393   
2394   return;
2395 }
2396
2397 /********** module stuff **********/
2398
2399 MODULE_AUTHOR(maintainer_string);
2400 MODULE_DESCRIPTION(description_string);
2401 MODULE_LICENSE("GPL");
2402 module_param(debug,   ushort, 0644);
2403 module_param(cmds,    uint, 0);
2404 module_param(txs,     uint, 0);
2405 module_param_array(rxs,     uint, NULL, 0);
2406 module_param_array(rxs_bs,  uint, NULL, 0);
2407 module_param(rx_lats, uint, 0);
2408 module_param(pci_lat, byte, 0);
2409 MODULE_PARM_DESC(debug,   "debug bitmap, see .h file");
2410 MODULE_PARM_DESC(cmds,    "number of command queue entries");
2411 MODULE_PARM_DESC(txs,     "number of TX queue entries");
2412 MODULE_PARM_DESC(rxs,     "number of RX queue entries [" __MODULE_STRING(NUM_RX_POOLS) "]");
2413 MODULE_PARM_DESC(rxs_bs,  "size of RX buffers [" __MODULE_STRING(NUM_RX_POOLS) "]");
2414 MODULE_PARM_DESC(rx_lats, "number of extra buffers to cope with RX latencies");
2415 MODULE_PARM_DESC(pci_lat, "PCI latency in bus cycles");
2416
2417 /********** module entry **********/
2418
2419 static struct pci_device_id amb_pci_tbl[] = {
2420         { PCI_VENDOR_ID_MADGE, PCI_DEVICE_ID_MADGE_AMBASSADOR, PCI_ANY_ID, PCI_ANY_ID,
2421           0, 0, 0 },
2422         { PCI_VENDOR_ID_MADGE, PCI_DEVICE_ID_MADGE_AMBASSADOR_BAD, PCI_ANY_ID, PCI_ANY_ID,
2423           0, 0, 0 },
2424         { 0, }
2425 };
2426
2427 MODULE_DEVICE_TABLE(pci, amb_pci_tbl);
2428
2429 static struct pci_driver amb_driver = {
2430         .name =         "amb",
2431         .probe =        amb_probe,
2432         .remove =       __devexit_p(amb_remove_one),
2433         .id_table =     amb_pci_tbl,
2434 };
2435
2436 static int __init amb_module_init (void)
2437 {
2438   PRINTD (DBG_FLOW|DBG_INIT, "init_module");
2439   
2440   // sanity check - cast needed as printk does not support %Zu
2441   if (sizeof(amb_mem) != 4*16 + 4*12) {
2442     PRINTK (KERN_ERR, "Fix amb_mem (is %lu words).",
2443             (unsigned long) sizeof(amb_mem));
2444     return -ENOMEM;
2445   }
2446   
2447   show_version();
2448   
2449   amb_check_args();
2450   
2451   // get the juice
2452   return pci_register_driver(&amb_driver);
2453 }
2454
2455 /********** module exit **********/
2456
2457 static void __exit amb_module_exit (void)
2458 {
2459   PRINTD (DBG_FLOW|DBG_INIT, "cleanup_module");
2460   
2461   return pci_unregister_driver(&amb_driver);
2462 }
2463
2464 module_init(amb_module_init);
2465 module_exit(amb_module_exit);