ia64/linux-2.6.18-xen.hg

view drivers/atm/horizon.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 Madge Horizon ATM Adapter driver.
3 Copyright (C) 1995-1999 Madge Networks Ltd.
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.
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.
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
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 */
23 /*
24 IMPORTANT NOTE: Madge Networks no longer makes the adapters
25 supported by this driver and makes no commitment to maintain it.
26 */
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/mm.h>
31 #include <linux/pci.h>
32 #include <linux/errno.h>
33 #include <linux/atm.h>
34 #include <linux/atmdev.h>
35 #include <linux/sonet.h>
36 #include <linux/skbuff.h>
37 #include <linux/time.h>
38 #include <linux/delay.h>
39 #include <linux/uio.h>
40 #include <linux/init.h>
41 #include <linux/ioport.h>
42 #include <linux/wait.h>
44 #include <asm/system.h>
45 #include <asm/io.h>
46 #include <asm/atomic.h>
47 #include <asm/uaccess.h>
48 #include <asm/string.h>
49 #include <asm/byteorder.h>
51 #include "horizon.h"
53 #define maintainer_string "Giuliano Procida at Madge Networks <gprocida@madge.com>"
54 #define description_string "Madge ATM Horizon [Ultra] driver"
55 #define version_string "1.2.1"
57 static inline void __init show_version (void) {
58 printk ("%s version %s\n", description_string, version_string);
59 }
61 /*
63 CREDITS
65 Driver and documentation by:
67 Chris Aston Madge Networks
68 Giuliano Procida Madge Networks
69 Simon Benham Madge Networks
70 Simon Johnson Madge Networks
71 Various Others Madge Networks
73 Some inspiration taken from other drivers by:
75 Alexandru Cucos UTBv
76 Kari Mettinen University of Helsinki
77 Werner Almesberger EPFL LRC
79 Theory of Operation
81 I Hardware, detection, initialisation and shutdown.
83 1. Supported Hardware
85 This driver should handle all variants of the PCI Madge ATM adapters
86 with the Horizon chipset. These are all PCI cards supporting PIO, BM
87 DMA and a form of MMIO (registers only, not internal RAM).
89 The driver is only known to work with SONET and UTP Horizon Ultra
90 cards at 155Mb/s. However, code is in place to deal with both the
91 original Horizon and 25Mb/s operation.
93 There are two revisions of the Horizon ASIC: the original and the
94 Ultra. Details of hardware bugs are in section III.
96 The ASIC version can be distinguished by chip markings but is NOT
97 indicated by the PCI revision (all adapters seem to have PCI rev 1).
99 I believe that:
101 Horizon => Collage 25 PCI Adapter (UTP and STP)
102 Horizon Ultra => Collage 155 PCI Client (UTP or SONET)
103 Ambassador x => Collage 155 PCI Server (completely different)
105 Horizon (25Mb/s) is fitted with UTP and STP connectors. It seems to
106 have a Madge B154 plus glue logic serializer. I have also found a
107 really ancient version of this with slightly different glue. It
108 comes with the revision 0 (140-025-01) ASIC.
110 Horizon Ultra (155Mb/s) is fitted with either a Pulse Medialink
111 output (UTP) or an HP HFBR 5205 output (SONET). It has either
112 Madge's SAMBA framer or a SUNI-lite device (early versions). It
113 comes with the revision 1 (140-027-01) ASIC.
115 2. Detection
117 All Horizon-based cards present with the same PCI Vendor and Device
118 IDs. The standard Linux 2.2 PCI API is used to locate any cards and
119 to enable bus-mastering (with appropriate latency).
121 ATM_LAYER_STATUS in the control register distinguishes between the
122 two possible physical layers (25 and 155). It is not clear whether
123 the 155 cards can also operate at 25Mbps. We rely on the fact that a
124 card operates at 155 if and only if it has the newer Horizon Ultra
125 ASIC.
127 For 155 cards the two possible framers are probed for and then set
128 up for loop-timing.
130 3. Initialisation
132 The card is reset and then put into a known state. The physical
133 layer is configured for normal operation at the appropriate speed;
134 in the case of the 155 cards, the framer is initialised with
135 line-based timing; the internal RAM is zeroed and the allocation of
136 buffers for RX and TX is made; the Burnt In Address is read and
137 copied to the ATM ESI; various policy settings for RX (VPI bits,
138 unknown VCs, oam cells) are made. Ideally all policy items should be
139 configurable at module load (if not actually on-demand), however,
140 only the vpi vs vci bit allocation can be specified at insmod.
142 4. Shutdown
144 This is in response to module_cleaup. No VCs are in use and the card
145 should be idle; it is reset.
147 II Driver software (as it should be)
149 0. Traffic Parameters
151 The traffic classes (not an enumeration) are currently: ATM_NONE (no
152 traffic), ATM_UBR, ATM_CBR, ATM_VBR and ATM_ABR, ATM_ANYCLASS
153 (compatible with everything). Together with (perhaps only some of)
154 the following items they make up the traffic specification.
156 struct atm_trafprm {
157 unsigned char traffic_class; traffic class (ATM_UBR, ...)
158 int max_pcr; maximum PCR in cells per second
159 int pcr; desired PCR in cells per second
160 int min_pcr; minimum PCR in cells per second
161 int max_cdv; maximum CDV in microseconds
162 int max_sdu; maximum SDU in bytes
163 };
165 Note that these denote bandwidth available not bandwidth used; the
166 possibilities according to ATMF are:
168 Real Time (cdv and max CDT given)
170 CBR(pcr) pcr bandwidth always available
171 rtVBR(pcr,scr,mbs) scr bandwidth always available, upto pcr at mbs too
173 Non Real Time
175 nrtVBR(pcr,scr,mbs) scr bandwidth always available, upto pcr at mbs too
176 UBR()
177 ABR(mcr,pcr) mcr bandwidth always available, upto pcr (depending) too
179 mbs is max burst size (bucket)
180 pcr and scr have associated cdvt values
181 mcr is like scr but has no cdtv
182 cdtv may differ at each hop
184 Some of the above items are qos items (as opposed to traffic
185 parameters). We have nothing to do with qos. All except ABR can have
186 their traffic parameters converted to GCRA parameters. The GCRA may
187 be implemented as a (real-number) leaky bucket. The GCRA can be used
188 in complicated ways by switches and in simpler ways by end-stations.
189 It can be used both to filter incoming cells and shape out-going
190 cells.
192 ATM Linux actually supports:
194 ATM_NONE() (no traffic in this direction)
195 ATM_UBR(max_frame_size)
196 ATM_CBR(max/min_pcr, max_cdv, max_frame_size)
198 0 or ATM_MAX_PCR are used to indicate maximum available PCR
200 A traffic specification consists of the AAL type and separate
201 traffic specifications for either direction. In ATM Linux it is:
203 struct atm_qos {
204 struct atm_trafprm txtp;
205 struct atm_trafprm rxtp;
206 unsigned char aal;
207 };
209 AAL types are:
211 ATM_NO_AAL AAL not specified
212 ATM_AAL0 "raw" ATM cells
213 ATM_AAL1 AAL1 (CBR)
214 ATM_AAL2 AAL2 (VBR)
215 ATM_AAL34 AAL3/4 (data)
216 ATM_AAL5 AAL5 (data)
217 ATM_SAAL signaling AAL
219 The Horizon has support for AAL frame types: 0, 3/4 and 5. However,
220 it does not implement AAL 3/4 SAR and it has a different notion of
221 "raw cell" to ATM Linux's (48 bytes vs. 52 bytes) so neither are
222 supported by this driver.
224 The Horizon has limited support for ABR (including UBR), VBR and
225 CBR. Each TX channel has a bucket (containing up to 31 cell units)
226 and two timers (PCR and SCR) associated with it that can be used to
227 govern cell emissions and host notification (in the case of ABR this
228 is presumably so that RM cells may be emitted at appropriate times).
229 The timers may either be disabled or may be set to any of 240 values
230 (determined by the clock crystal, a fixed (?) per-device divider, a
231 configurable divider and a configurable timer preload value).
233 At the moment only UBR and CBR are supported by the driver. VBR will
234 be supported as soon as ATM for Linux supports it. ABR support is
235 very unlikely as RM cell handling is completely up to the driver.
237 1. TX (TX channel setup and TX transfer)
239 The TX half of the driver owns the TX Horizon registers. The TX
240 component in the IRQ handler is the BM completion handler. This can
241 only be entered when tx_busy is true (enforced by hardware). The
242 other TX component can only be entered when tx_busy is false
243 (enforced by driver). So TX is single-threaded.
245 Apart from a minor optimisation to not re-select the last channel,
246 the TX send component works as follows:
248 Atomic test and set tx_busy until we succeed; we should implement
249 some sort of timeout so that tx_busy will never be stuck at true.
251 If no TX channel is set up for this VC we wait for an idle one (if
252 necessary) and set it up.
254 At this point we have a TX channel ready for use. We wait for enough
255 buffers to become available then start a TX transmit (set the TX
256 descriptor, schedule transfer, exit).
258 The IRQ component handles TX completion (stats, free buffer, tx_busy
259 unset, exit). We also re-schedule further transfers for the same
260 frame if needed.
262 TX setup in more detail:
264 TX open is a nop, the relevant information is held in the hrz_vcc
265 (vcc->dev_data) structure and is "cached" on the card.
267 TX close gets the TX lock and clears the channel from the "cache".
269 2. RX (Data Available and RX transfer)
271 The RX half of the driver owns the RX registers. There are two RX
272 components in the IRQ handler: the data available handler deals with
273 fresh data that has arrived on the card, the BM completion handler
274 is very similar to the TX completion handler. The data available
275 handler grabs the rx_lock and it is only released once the data has
276 been discarded or completely transferred to the host. The BM
277 completion handler only runs when the lock is held; the data
278 available handler is locked out over the same period.
280 Data available on the card triggers an interrupt. If the data is not
281 suitable for our existing RX channels or we cannot allocate a buffer
282 it is flushed. Otherwise an RX receive is scheduled. Multiple RX
283 transfers may be scheduled for the same frame.
285 RX setup in more detail:
287 RX open...
288 RX close...
290 III Hardware Bugs
292 0. Byte vs Word addressing of adapter RAM.
294 A design feature; see the .h file (especially the memory map).
296 1. Bus Master Data Transfers (original Horizon only, fixed in Ultra)
298 The host must not start a transmit direction transfer at a
299 non-four-byte boundary in host memory. Instead the host should
300 perform a byte, or a two byte, or one byte followed by two byte
301 transfer in order to start the rest of the transfer on a four byte
302 boundary. RX is OK.
304 Simultaneous transmit and receive direction bus master transfers are
305 not allowed.
307 The simplest solution to these two is to always do PIO (never DMA)
308 in the TX direction on the original Horizon. More complicated
309 solutions are likely to hurt my brain.
311 2. Loss of buffer on close VC
313 When a VC is being closed, the buffer associated with it is not
314 returned to the pool. The host must store the reference to this
315 buffer and when opening a new VC then give it to that new VC.
317 The host intervention currently consists of stacking such a buffer
318 pointer at VC close and checking the stack at VC open.
320 3. Failure to close a VC
322 If a VC is currently receiving a frame then closing the VC may fail
323 and the frame continues to be received.
325 The solution is to make sure any received frames are flushed when
326 ready. This is currently done just before the solution to 2.
328 4. PCI bus (original Horizon only, fixed in Ultra)
330 Reading from the data port prior to initialisation will hang the PCI
331 bus. Just don't do that then! We don't.
333 IV To Do List
335 . Timer code may be broken.
337 . Allow users to specify buffer allocation split for TX and RX.
339 . Deal once and for all with buggy VC close.
341 . Handle interrupted and/or non-blocking operations.
343 . Change some macros to functions and move from .h to .c.
345 . Try to limit the number of TX frames each VC may have queued, in
346 order to reduce the chances of TX buffer exhaustion.
348 . Implement VBR (bucket and timers not understood) and ABR (need to
349 do RM cells manually); also no Linux support for either.
351 . Implement QoS changes on open VCs (involves extracting parts of VC open
352 and close into separate functions and using them to make changes).
354 */
356 /********** globals **********/
358 static void do_housekeeping (unsigned long arg);
360 static unsigned short debug = 0;
361 static unsigned short vpi_bits = 0;
362 static int max_tx_size = 9000;
363 static int max_rx_size = 9000;
364 static unsigned char pci_lat = 0;
366 /********** access functions **********/
368 /* Read / Write Horizon registers */
369 static inline void wr_regl (const hrz_dev * dev, unsigned char reg, u32 data) {
370 outl (cpu_to_le32 (data), dev->iobase + reg);
371 }
373 static inline u32 rd_regl (const hrz_dev * dev, unsigned char reg) {
374 return le32_to_cpu (inl (dev->iobase + reg));
375 }
377 static inline void wr_regw (const hrz_dev * dev, unsigned char reg, u16 data) {
378 outw (cpu_to_le16 (data), dev->iobase + reg);
379 }
381 static inline u16 rd_regw (const hrz_dev * dev, unsigned char reg) {
382 return le16_to_cpu (inw (dev->iobase + reg));
383 }
385 static inline void wrs_regb (const hrz_dev * dev, unsigned char reg, void * addr, u32 len) {
386 outsb (dev->iobase + reg, addr, len);
387 }
389 static inline void rds_regb (const hrz_dev * dev, unsigned char reg, void * addr, u32 len) {
390 insb (dev->iobase + reg, addr, len);
391 }
393 /* Read / Write to a given address in Horizon buffer memory.
394 Interrupts must be disabled between the address register and data
395 port accesses as these must form an atomic operation. */
396 static inline void wr_mem (const hrz_dev * dev, HDW * addr, u32 data) {
397 // wr_regl (dev, MEM_WR_ADDR_REG_OFF, (u32) addr);
398 wr_regl (dev, MEM_WR_ADDR_REG_OFF, (addr - (HDW *) 0) * sizeof(HDW));
399 wr_regl (dev, MEMORY_PORT_OFF, data);
400 }
402 static inline u32 rd_mem (const hrz_dev * dev, HDW * addr) {
403 // wr_regl (dev, MEM_RD_ADDR_REG_OFF, (u32) addr);
404 wr_regl (dev, MEM_RD_ADDR_REG_OFF, (addr - (HDW *) 0) * sizeof(HDW));
405 return rd_regl (dev, MEMORY_PORT_OFF);
406 }
408 static inline void wr_framer (const hrz_dev * dev, u32 addr, u32 data) {
409 wr_regl (dev, MEM_WR_ADDR_REG_OFF, (u32) addr | 0x80000000);
410 wr_regl (dev, MEMORY_PORT_OFF, data);
411 }
413 static inline u32 rd_framer (const hrz_dev * dev, u32 addr) {
414 wr_regl (dev, MEM_RD_ADDR_REG_OFF, (u32) addr | 0x80000000);
415 return rd_regl (dev, MEMORY_PORT_OFF);
416 }
418 /********** specialised access functions **********/
420 /* RX */
422 static inline void FLUSH_RX_CHANNEL (hrz_dev * dev, u16 channel) {
423 wr_regw (dev, RX_CHANNEL_PORT_OFF, FLUSH_CHANNEL | channel);
424 return;
425 }
427 static inline void WAIT_FLUSH_RX_COMPLETE (hrz_dev * dev) {
428 while (rd_regw (dev, RX_CHANNEL_PORT_OFF) & FLUSH_CHANNEL)
429 ;
430 return;
431 }
433 static inline void SELECT_RX_CHANNEL (hrz_dev * dev, u16 channel) {
434 wr_regw (dev, RX_CHANNEL_PORT_OFF, channel);
435 return;
436 }
438 static inline void WAIT_UPDATE_COMPLETE (hrz_dev * dev) {
439 while (rd_regw (dev, RX_CHANNEL_PORT_OFF) & RX_CHANNEL_UPDATE_IN_PROGRESS)
440 ;
441 return;
442 }
444 /* TX */
446 static inline void SELECT_TX_CHANNEL (hrz_dev * dev, u16 tx_channel) {
447 wr_regl (dev, TX_CHANNEL_PORT_OFF, tx_channel);
448 return;
449 }
451 /* Update or query one configuration parameter of a particular channel. */
453 static inline void update_tx_channel_config (hrz_dev * dev, short chan, u8 mode, u16 value) {
454 wr_regw (dev, TX_CHANNEL_CONFIG_COMMAND_OFF,
455 chan * TX_CHANNEL_CONFIG_MULT | mode);
456 wr_regw (dev, TX_CHANNEL_CONFIG_DATA_OFF, value);
457 return;
458 }
460 static inline u16 query_tx_channel_config (hrz_dev * dev, short chan, u8 mode) {
461 wr_regw (dev, TX_CHANNEL_CONFIG_COMMAND_OFF,
462 chan * TX_CHANNEL_CONFIG_MULT | mode);
463 return rd_regw (dev, TX_CHANNEL_CONFIG_DATA_OFF);
464 }
466 /********** dump functions **********/
468 static inline void dump_skb (char * prefix, unsigned int vc, struct sk_buff * skb) {
469 #ifdef DEBUG_HORIZON
470 unsigned int i;
471 unsigned char * data = skb->data;
472 PRINTDB (DBG_DATA, "%s(%u) ", prefix, vc);
473 for (i=0; i<skb->len && i < 256;i++)
474 PRINTDM (DBG_DATA, "%02x ", data[i]);
475 PRINTDE (DBG_DATA,"");
476 #else
477 (void) prefix;
478 (void) vc;
479 (void) skb;
480 #endif
481 return;
482 }
484 static inline void dump_regs (hrz_dev * dev) {
485 #ifdef DEBUG_HORIZON
486 PRINTD (DBG_REGS, "CONTROL 0: %#x", rd_regl (dev, CONTROL_0_REG));
487 PRINTD (DBG_REGS, "RX CONFIG: %#x", rd_regw (dev, RX_CONFIG_OFF));
488 PRINTD (DBG_REGS, "TX CONFIG: %#x", rd_regw (dev, TX_CONFIG_OFF));
489 PRINTD (DBG_REGS, "TX STATUS: %#x", rd_regw (dev, TX_STATUS_OFF));
490 PRINTD (DBG_REGS, "IRQ ENBLE: %#x", rd_regl (dev, INT_ENABLE_REG_OFF));
491 PRINTD (DBG_REGS, "IRQ SORCE: %#x", rd_regl (dev, INT_SOURCE_REG_OFF));
492 #else
493 (void) dev;
494 #endif
495 return;
496 }
498 static inline void dump_framer (hrz_dev * dev) {
499 #ifdef DEBUG_HORIZON
500 unsigned int i;
501 PRINTDB (DBG_REGS, "framer registers:");
502 for (i = 0; i < 0x10; ++i)
503 PRINTDM (DBG_REGS, " %02x", rd_framer (dev, i));
504 PRINTDE (DBG_REGS,"");
505 #else
506 (void) dev;
507 #endif
508 return;
509 }
511 /********** VPI/VCI <-> (RX) channel conversions **********/
513 /* RX channels are 10 bit integers, these fns are quite paranoid */
515 static inline int channel_to_vpivci (const u16 channel, short * vpi, int * vci) {
516 unsigned short vci_bits = 10 - vpi_bits;
517 if ((channel & RX_CHANNEL_MASK) == channel) {
518 *vci = channel & ((~0)<<vci_bits);
519 *vpi = channel >> vci_bits;
520 return channel ? 0 : -EINVAL;
521 }
522 return -EINVAL;
523 }
525 static inline int vpivci_to_channel (u16 * channel, const short vpi, const int vci) {
526 unsigned short vci_bits = 10 - vpi_bits;
527 if (0 <= vpi && vpi < 1<<vpi_bits && 0 <= vci && vci < 1<<vci_bits) {
528 *channel = vpi<<vci_bits | vci;
529 return *channel ? 0 : -EINVAL;
530 }
531 return -EINVAL;
532 }
534 /********** decode RX queue entries **********/
536 static inline u16 rx_q_entry_to_length (u32 x) {
537 return x & RX_Q_ENTRY_LENGTH_MASK;
538 }
540 static inline u16 rx_q_entry_to_rx_channel (u32 x) {
541 return (x>>RX_Q_ENTRY_CHANNEL_SHIFT) & RX_CHANNEL_MASK;
542 }
544 /* Cell Transmit Rate Values
545 *
546 * the cell transmit rate (cells per sec) can be set to a variety of
547 * different values by specifying two parameters: a timer preload from
548 * 1 to 16 (stored as 0 to 15) and a clock divider (2 to the power of
549 * an exponent from 0 to 14; the special value 15 disables the timer).
550 *
551 * cellrate = baserate / (preload * 2^divider)
552 *
553 * The maximum cell rate that can be specified is therefore just the
554 * base rate. Halving the preload is equivalent to adding 1 to the
555 * divider and so values 1 to 8 of the preload are redundant except
556 * in the case of a maximal divider (14).
557 *
558 * Given a desired cell rate, an algorithm to determine the preload
559 * and divider is:
560 *
561 * a) x = baserate / cellrate, want p * 2^d = x (as far as possible)
562 * b) if x > 16 * 2^14 then set p = 16, d = 14 (min rate), done
563 * if x <= 16 then set p = x, d = 0 (high rates), done
564 * c) now have 16 < x <= 2^18, or 1 < x/16 <= 2^14 and we want to
565 * know n such that 2^(n-1) < x/16 <= 2^n, so slide a bit until
566 * we find the range (n will be between 1 and 14), set d = n
567 * d) Also have 8 < x/2^n <= 16, so set p nearest x/2^n
568 *
569 * The algorithm used below is a minor variant of the above.
570 *
571 * The base rate is derived from the oscillator frequency (Hz) using a
572 * fixed divider:
573 *
574 * baserate = freq / 32 in the case of some Unknown Card
575 * baserate = freq / 8 in the case of the Horizon 25
576 * baserate = freq / 8 in the case of the Horizon Ultra 155
577 *
578 * The Horizon cards have oscillators and base rates as follows:
579 *
580 * Card Oscillator Base Rate
581 * Unknown Card 33 MHz 1.03125 MHz (33 MHz = PCI freq)
582 * Horizon 25 32 MHz 4 MHz
583 * Horizon Ultra 155 40 MHz 5 MHz
584 *
585 * The following defines give the base rates in Hz. These were
586 * previously a factor of 100 larger, no doubt someone was using
587 * cps*100.
588 */
590 #define BR_UKN 1031250l
591 #define BR_HRZ 4000000l
592 #define BR_ULT 5000000l
594 // d is an exponent
595 #define CR_MIND 0
596 #define CR_MAXD 14
598 // p ranges from 1 to a power of 2
599 #define CR_MAXPEXP 4
601 static int make_rate (const hrz_dev * dev, u32 c, rounding r,
602 u16 * bits, unsigned int * actual)
603 {
604 // note: rounding the rate down means rounding 'p' up
605 const unsigned long br = test_bit(ultra, &dev->flags) ? BR_ULT : BR_HRZ;
607 u32 div = CR_MIND;
608 u32 pre;
610 // br_exp and br_man are used to avoid overflowing (c*maxp*2^d) in
611 // the tests below. We could think harder about exact possibilities
612 // of failure...
614 unsigned long br_man = br;
615 unsigned int br_exp = 0;
617 PRINTD (DBG_QOS|DBG_FLOW, "make_rate b=%lu, c=%u, %s", br, c,
618 r == round_up ? "up" : r == round_down ? "down" : "nearest");
620 // avoid div by zero
621 if (!c) {
622 PRINTD (DBG_QOS|DBG_ERR, "zero rate is not allowed!");
623 return -EINVAL;
624 }
626 while (br_exp < CR_MAXPEXP + CR_MIND && (br_man % 2 == 0)) {
627 br_man = br_man >> 1;
628 ++br_exp;
629 }
630 // (br >>br_exp) <<br_exp == br and
631 // br_exp <= CR_MAXPEXP+CR_MIND
633 if (br_man <= (c << (CR_MAXPEXP+CR_MIND-br_exp))) {
634 // Equivalent to: B <= (c << (MAXPEXP+MIND))
635 // take care of rounding
636 switch (r) {
637 case round_down:
638 pre = (br+(c<<div)-1)/(c<<div);
639 // but p must be non-zero
640 if (!pre)
641 pre = 1;
642 break;
643 case round_nearest:
644 pre = (br+(c<<div)/2)/(c<<div);
645 // but p must be non-zero
646 if (!pre)
647 pre = 1;
648 break;
649 default: /* round_up */
650 pre = br/(c<<div);
651 // but p must be non-zero
652 if (!pre)
653 return -EINVAL;
654 }
655 PRINTD (DBG_QOS, "A: p=%u, d=%u", pre, div);
656 goto got_it;
657 }
659 // at this point we have
660 // d == MIND and (c << (MAXPEXP+MIND)) < B
661 while (div < CR_MAXD) {
662 div++;
663 if (br_man <= (c << (CR_MAXPEXP+div-br_exp))) {
664 // Equivalent to: B <= (c << (MAXPEXP+d))
665 // c << (MAXPEXP+d-1) < B <= c << (MAXPEXP+d)
666 // 1 << (MAXPEXP-1) < B/2^d/c <= 1 << MAXPEXP
667 // MAXP/2 < B/c2^d <= MAXP
668 // take care of rounding
669 switch (r) {
670 case round_down:
671 pre = (br+(c<<div)-1)/(c<<div);
672 break;
673 case round_nearest:
674 pre = (br+(c<<div)/2)/(c<<div);
675 break;
676 default: /* round_up */
677 pre = br/(c<<div);
678 }
679 PRINTD (DBG_QOS, "B: p=%u, d=%u", pre, div);
680 goto got_it;
681 }
682 }
683 // at this point we have
684 // d == MAXD and (c << (MAXPEXP+MAXD)) < B
685 // but we cannot go any higher
686 // take care of rounding
687 if (r == round_down)
688 return -EINVAL;
689 pre = 1 << CR_MAXPEXP;
690 PRINTD (DBG_QOS, "C: p=%u, d=%u", pre, div);
691 got_it:
692 // paranoia
693 if (div > CR_MAXD || (!pre) || pre > 1<<CR_MAXPEXP) {
694 PRINTD (DBG_QOS, "set_cr internal failure: d=%u p=%u",
695 div, pre);
696 return -EINVAL;
697 } else {
698 if (bits)
699 *bits = (div<<CLOCK_SELECT_SHIFT) | (pre-1);
700 if (actual) {
701 *actual = (br + (pre<<div) - 1) / (pre<<div);
702 PRINTD (DBG_QOS, "actual rate: %u", *actual);
703 }
704 return 0;
705 }
706 }
708 static int make_rate_with_tolerance (const hrz_dev * dev, u32 c, rounding r, unsigned int tol,
709 u16 * bit_pattern, unsigned int * actual) {
710 unsigned int my_actual;
712 PRINTD (DBG_QOS|DBG_FLOW, "make_rate_with_tolerance c=%u, %s, tol=%u",
713 c, (r == round_up) ? "up" : (r == round_down) ? "down" : "nearest", tol);
715 if (!actual)
716 // actual rate is not returned
717 actual = &my_actual;
719 if (make_rate (dev, c, round_nearest, bit_pattern, actual))
720 // should never happen as round_nearest always succeeds
721 return -1;
723 if (c - tol <= *actual && *actual <= c + tol)
724 // within tolerance
725 return 0;
726 else
727 // intolerant, try rounding instead
728 return make_rate (dev, c, r, bit_pattern, actual);
729 }
731 /********** Listen on a VC **********/
733 static int hrz_open_rx (hrz_dev * dev, u16 channel) {
734 // is there any guarantee that we don't get two simulataneous
735 // identical calls of this function from different processes? yes
736 // rate_lock
737 unsigned long flags;
738 u32 channel_type; // u16?
740 u16 buf_ptr = RX_CHANNEL_IDLE;
742 rx_ch_desc * rx_desc = &memmap->rx_descs[channel];
744 PRINTD (DBG_FLOW, "hrz_open_rx %x", channel);
746 spin_lock_irqsave (&dev->mem_lock, flags);
747 channel_type = rd_mem (dev, &rx_desc->wr_buf_type) & BUFFER_PTR_MASK;
748 spin_unlock_irqrestore (&dev->mem_lock, flags);
750 // very serious error, should never occur
751 if (channel_type != RX_CHANNEL_DISABLED) {
752 PRINTD (DBG_ERR|DBG_VCC, "RX channel for VC already open");
753 return -EBUSY; // clean up?
754 }
756 // Give back spare buffer
757 if (dev->noof_spare_buffers) {
758 buf_ptr = dev->spare_buffers[--dev->noof_spare_buffers];
759 PRINTD (DBG_VCC, "using a spare buffer: %u", buf_ptr);
760 // should never occur
761 if (buf_ptr == RX_CHANNEL_DISABLED || buf_ptr == RX_CHANNEL_IDLE) {
762 // but easy to recover from
763 PRINTD (DBG_ERR|DBG_VCC, "bad spare buffer pointer, using IDLE");
764 buf_ptr = RX_CHANNEL_IDLE;
765 }
766 } else {
767 PRINTD (DBG_VCC, "using IDLE buffer pointer");
768 }
770 // Channel is currently disabled so change its status to idle
772 // do we really need to save the flags again?
773 spin_lock_irqsave (&dev->mem_lock, flags);
775 wr_mem (dev, &rx_desc->wr_buf_type,
776 buf_ptr | CHANNEL_TYPE_AAL5 | FIRST_CELL_OF_AAL5_FRAME);
777 if (buf_ptr != RX_CHANNEL_IDLE)
778 wr_mem (dev, &rx_desc->rd_buf_type, buf_ptr);
780 spin_unlock_irqrestore (&dev->mem_lock, flags);
782 // rxer->rate = make_rate (qos->peak_cells);
784 PRINTD (DBG_FLOW, "hrz_open_rx ok");
786 return 0;
787 }
789 #if 0
790 /********** change vc rate for a given vc **********/
792 static void hrz_change_vc_qos (ATM_RXER * rxer, MAAL_QOS * qos) {
793 rxer->rate = make_rate (qos->peak_cells);
794 }
795 #endif
797 /********** free an skb (as per ATM device driver documentation) **********/
799 static inline void hrz_kfree_skb (struct sk_buff * skb) {
800 if (ATM_SKB(skb)->vcc->pop) {
801 ATM_SKB(skb)->vcc->pop (ATM_SKB(skb)->vcc, skb);
802 } else {
803 dev_kfree_skb_any (skb);
804 }
805 }
807 /********** cancel listen on a VC **********/
809 static void hrz_close_rx (hrz_dev * dev, u16 vc) {
810 unsigned long flags;
812 u32 value;
814 u32 r1, r2;
816 rx_ch_desc * rx_desc = &memmap->rx_descs[vc];
818 int was_idle = 0;
820 spin_lock_irqsave (&dev->mem_lock, flags);
821 value = rd_mem (dev, &rx_desc->wr_buf_type) & BUFFER_PTR_MASK;
822 spin_unlock_irqrestore (&dev->mem_lock, flags);
824 if (value == RX_CHANNEL_DISABLED) {
825 // I suppose this could happen once we deal with _NONE traffic properly
826 PRINTD (DBG_VCC, "closing VC: RX channel %u already disabled", vc);
827 return;
828 }
829 if (value == RX_CHANNEL_IDLE)
830 was_idle = 1;
832 spin_lock_irqsave (&dev->mem_lock, flags);
834 for (;;) {
835 wr_mem (dev, &rx_desc->wr_buf_type, RX_CHANNEL_DISABLED);
837 if ((rd_mem (dev, &rx_desc->wr_buf_type) & BUFFER_PTR_MASK) == RX_CHANNEL_DISABLED)
838 break;
840 was_idle = 0;
841 }
843 if (was_idle) {
844 spin_unlock_irqrestore (&dev->mem_lock, flags);
845 return;
846 }
848 WAIT_FLUSH_RX_COMPLETE(dev);
850 // XXX Is this all really necessary? We can rely on the rx_data_av
851 // handler to discard frames that remain queued for delivery. If the
852 // worry is that immediately reopening the channel (perhaps by a
853 // different process) may cause some data to be mis-delivered then
854 // there may still be a simpler solution (such as busy-waiting on
855 // rx_busy once the channel is disabled or before a new one is
856 // opened - does this leave any holes?). Arguably setting up and
857 // tearing down the TX and RX halves of each virtual circuit could
858 // most safely be done within ?x_busy protected regions.
860 // OK, current changes are that Simon's marker is disabled and we DO
861 // look for NULL rxer elsewhere. The code here seems flush frames
862 // and then remember the last dead cell belonging to the channel
863 // just disabled - the cell gets relinked at the next vc_open.
864 // However, when all VCs are closed or only a few opened there are a
865 // handful of buffers that are unusable.
867 // Does anyone feel like documenting spare_buffers properly?
868 // Does anyone feel like fixing this in a nicer way?
870 // Flush any data which is left in the channel
871 for (;;) {
872 // Change the rx channel port to something different to the RX
873 // channel we are trying to close to force Horizon to flush the rx
874 // channel read and write pointers.
876 u16 other = vc^(RX_CHANS/2);
878 SELECT_RX_CHANNEL (dev, other);
879 WAIT_UPDATE_COMPLETE (dev);
881 r1 = rd_mem (dev, &rx_desc->rd_buf_type);
883 // Select this RX channel. Flush doesn't seem to work unless we
884 // select an RX channel before hand
886 SELECT_RX_CHANNEL (dev, vc);
887 WAIT_UPDATE_COMPLETE (dev);
889 // Attempt to flush a frame on this RX channel
891 FLUSH_RX_CHANNEL (dev, vc);
892 WAIT_FLUSH_RX_COMPLETE (dev);
894 // Force Horizon to flush rx channel read and write pointers as before
896 SELECT_RX_CHANNEL (dev, other);
897 WAIT_UPDATE_COMPLETE (dev);
899 r2 = rd_mem (dev, &rx_desc->rd_buf_type);
901 PRINTD (DBG_VCC|DBG_RX, "r1 = %u, r2 = %u", r1, r2);
903 if (r1 == r2) {
904 dev->spare_buffers[dev->noof_spare_buffers++] = (u16)r1;
905 break;
906 }
907 }
909 #if 0
910 {
911 rx_q_entry * wr_ptr = &memmap->rx_q_entries[rd_regw (dev, RX_QUEUE_WR_PTR_OFF)];
912 rx_q_entry * rd_ptr = dev->rx_q_entry;
914 PRINTD (DBG_VCC|DBG_RX, "rd_ptr = %u, wr_ptr = %u", rd_ptr, wr_ptr);
916 while (rd_ptr != wr_ptr) {
917 u32 x = rd_mem (dev, (HDW *) rd_ptr);
919 if (vc == rx_q_entry_to_rx_channel (x)) {
920 x |= SIMONS_DODGEY_MARKER;
922 PRINTD (DBG_RX|DBG_VCC|DBG_WARN, "marking a frame as dodgey");
924 wr_mem (dev, (HDW *) rd_ptr, x);
925 }
927 if (rd_ptr == dev->rx_q_wrap)
928 rd_ptr = dev->rx_q_reset;
929 else
930 rd_ptr++;
931 }
932 }
933 #endif
935 spin_unlock_irqrestore (&dev->mem_lock, flags);
937 return;
938 }
940 /********** schedule RX transfers **********/
942 // Note on tail recursion: a GCC developer said that it is not likely
943 // to be fixed soon, so do not define TAILRECUSRIONWORKS unless you
944 // are sure it does as you may otherwise overflow the kernel stack.
946 // giving this fn a return value would help GCC, alledgedly
948 static void rx_schedule (hrz_dev * dev, int irq) {
949 unsigned int rx_bytes;
951 int pio_instead = 0;
952 #ifndef TAILRECURSIONWORKS
953 pio_instead = 1;
954 while (pio_instead) {
955 #endif
956 // bytes waiting for RX transfer
957 rx_bytes = dev->rx_bytes;
959 #if 0
960 spin_count = 0;
961 while (rd_regl (dev, MASTER_RX_COUNT_REG_OFF)) {
962 PRINTD (DBG_RX|DBG_WARN, "RX error: other PCI Bus Master RX still in progress!");
963 if (++spin_count > 10) {
964 PRINTD (DBG_RX|DBG_ERR, "spun out waiting PCI Bus Master RX completion");
965 wr_regl (dev, MASTER_RX_COUNT_REG_OFF, 0);
966 clear_bit (rx_busy, &dev->flags);
967 hrz_kfree_skb (dev->rx_skb);
968 return;
969 }
970 }
971 #endif
973 // this code follows the TX code but (at the moment) there is only
974 // one region - the skb itself. I don't know if this will change,
975 // but it doesn't hurt to have the code here, disabled.
977 if (rx_bytes) {
978 // start next transfer within same region
979 if (rx_bytes <= MAX_PIO_COUNT) {
980 PRINTD (DBG_RX|DBG_BUS, "(pio)");
981 pio_instead = 1;
982 }
983 if (rx_bytes <= MAX_TRANSFER_COUNT) {
984 PRINTD (DBG_RX|DBG_BUS, "(simple or last multi)");
985 dev->rx_bytes = 0;
986 } else {
987 PRINTD (DBG_RX|DBG_BUS, "(continuing multi)");
988 dev->rx_bytes = rx_bytes - MAX_TRANSFER_COUNT;
989 rx_bytes = MAX_TRANSFER_COUNT;
990 }
991 } else {
992 // rx_bytes == 0 -- we're between regions
993 // regions remaining to transfer
994 #if 0
995 unsigned int rx_regions = dev->rx_regions;
996 #else
997 unsigned int rx_regions = 0;
998 #endif
1000 if (rx_regions) {
1001 #if 0
1002 // start a new region
1003 dev->rx_addr = dev->rx_iovec->iov_base;
1004 rx_bytes = dev->rx_iovec->iov_len;
1005 ++dev->rx_iovec;
1006 dev->rx_regions = rx_regions - 1;
1008 if (rx_bytes <= MAX_PIO_COUNT) {
1009 PRINTD (DBG_RX|DBG_BUS, "(pio)");
1010 pio_instead = 1;
1012 if (rx_bytes <= MAX_TRANSFER_COUNT) {
1013 PRINTD (DBG_RX|DBG_BUS, "(full region)");
1014 dev->rx_bytes = 0;
1015 } else {
1016 PRINTD (DBG_RX|DBG_BUS, "(start multi region)");
1017 dev->rx_bytes = rx_bytes - MAX_TRANSFER_COUNT;
1018 rx_bytes = MAX_TRANSFER_COUNT;
1020 #endif
1021 } else {
1022 // rx_regions == 0
1023 // that's all folks - end of frame
1024 struct sk_buff * skb = dev->rx_skb;
1025 // dev->rx_iovec = 0;
1027 FLUSH_RX_CHANNEL (dev, dev->rx_channel);
1029 dump_skb ("<<<", dev->rx_channel, skb);
1031 PRINTD (DBG_RX|DBG_SKB, "push %p %u", skb->data, skb->len);
1034 struct atm_vcc * vcc = ATM_SKB(skb)->vcc;
1035 // VC layer stats
1036 atomic_inc(&vcc->stats->rx);
1037 __net_timestamp(skb);
1038 // end of our responsability
1039 vcc->push (vcc, skb);
1044 // note: writing RX_COUNT clears any interrupt condition
1045 if (rx_bytes) {
1046 if (pio_instead) {
1047 if (irq)
1048 wr_regl (dev, MASTER_RX_COUNT_REG_OFF, 0);
1049 rds_regb (dev, DATA_PORT_OFF, dev->rx_addr, rx_bytes);
1050 } else {
1051 wr_regl (dev, MASTER_RX_ADDR_REG_OFF, virt_to_bus (dev->rx_addr));
1052 wr_regl (dev, MASTER_RX_COUNT_REG_OFF, rx_bytes);
1054 dev->rx_addr += rx_bytes;
1055 } else {
1056 if (irq)
1057 wr_regl (dev, MASTER_RX_COUNT_REG_OFF, 0);
1058 // allow another RX thread to start
1059 YELLOW_LED_ON(dev);
1060 clear_bit (rx_busy, &dev->flags);
1061 PRINTD (DBG_RX, "cleared rx_busy for dev %p", dev);
1064 #ifdef TAILRECURSIONWORKS
1065 // and we all bless optimised tail calls
1066 if (pio_instead)
1067 return rx_schedule (dev, 0);
1068 return;
1069 #else
1070 // grrrrrrr!
1071 irq = 0;
1073 return;
1074 #endif
1077 /********** handle RX bus master complete events **********/
1079 static inline void rx_bus_master_complete_handler (hrz_dev * dev) {
1080 if (test_bit (rx_busy, &dev->flags)) {
1081 rx_schedule (dev, 1);
1082 } else {
1083 PRINTD (DBG_RX|DBG_ERR, "unexpected RX bus master completion");
1084 // clear interrupt condition on adapter
1085 wr_regl (dev, MASTER_RX_COUNT_REG_OFF, 0);
1087 return;
1090 /********** (queue to) become the next TX thread **********/
1092 static inline int tx_hold (hrz_dev * dev) {
1093 PRINTD (DBG_TX, "sleeping at tx lock %p %lu", dev, dev->flags);
1094 wait_event_interruptible(dev->tx_queue, (!test_and_set_bit(tx_busy, &dev->flags)));
1095 PRINTD (DBG_TX, "woken at tx lock %p %lu", dev, dev->flags);
1096 if (signal_pending (current))
1097 return -1;
1098 PRINTD (DBG_TX, "set tx_busy for dev %p", dev);
1099 return 0;
1102 /********** allow another TX thread to start **********/
1104 static inline void tx_release (hrz_dev * dev) {
1105 clear_bit (tx_busy, &dev->flags);
1106 PRINTD (DBG_TX, "cleared tx_busy for dev %p", dev);
1107 wake_up_interruptible (&dev->tx_queue);
1110 /********** schedule TX transfers **********/
1112 static void tx_schedule (hrz_dev * const dev, int irq) {
1113 unsigned int tx_bytes;
1115 int append_desc = 0;
1117 int pio_instead = 0;
1118 #ifndef TAILRECURSIONWORKS
1119 pio_instead = 1;
1120 while (pio_instead) {
1121 #endif
1122 // bytes in current region waiting for TX transfer
1123 tx_bytes = dev->tx_bytes;
1125 #if 0
1126 spin_count = 0;
1127 while (rd_regl (dev, MASTER_TX_COUNT_REG_OFF)) {
1128 PRINTD (DBG_TX|DBG_WARN, "TX error: other PCI Bus Master TX still in progress!");
1129 if (++spin_count > 10) {
1130 PRINTD (DBG_TX|DBG_ERR, "spun out waiting PCI Bus Master TX completion");
1131 wr_regl (dev, MASTER_TX_COUNT_REG_OFF, 0);
1132 tx_release (dev);
1133 hrz_kfree_skb (dev->tx_skb);
1134 return;
1137 #endif
1139 if (tx_bytes) {
1140 // start next transfer within same region
1141 if (!test_bit (ultra, &dev->flags) || tx_bytes <= MAX_PIO_COUNT) {
1142 PRINTD (DBG_TX|DBG_BUS, "(pio)");
1143 pio_instead = 1;
1145 if (tx_bytes <= MAX_TRANSFER_COUNT) {
1146 PRINTD (DBG_TX|DBG_BUS, "(simple or last multi)");
1147 if (!dev->tx_iovec) {
1148 // end of last region
1149 append_desc = 1;
1151 dev->tx_bytes = 0;
1152 } else {
1153 PRINTD (DBG_TX|DBG_BUS, "(continuing multi)");
1154 dev->tx_bytes = tx_bytes - MAX_TRANSFER_COUNT;
1155 tx_bytes = MAX_TRANSFER_COUNT;
1157 } else {
1158 // tx_bytes == 0 -- we're between regions
1159 // regions remaining to transfer
1160 unsigned int tx_regions = dev->tx_regions;
1162 if (tx_regions) {
1163 // start a new region
1164 dev->tx_addr = dev->tx_iovec->iov_base;
1165 tx_bytes = dev->tx_iovec->iov_len;
1166 ++dev->tx_iovec;
1167 dev->tx_regions = tx_regions - 1;
1169 if (!test_bit (ultra, &dev->flags) || tx_bytes <= MAX_PIO_COUNT) {
1170 PRINTD (DBG_TX|DBG_BUS, "(pio)");
1171 pio_instead = 1;
1173 if (tx_bytes <= MAX_TRANSFER_COUNT) {
1174 PRINTD (DBG_TX|DBG_BUS, "(full region)");
1175 dev->tx_bytes = 0;
1176 } else {
1177 PRINTD (DBG_TX|DBG_BUS, "(start multi region)");
1178 dev->tx_bytes = tx_bytes - MAX_TRANSFER_COUNT;
1179 tx_bytes = MAX_TRANSFER_COUNT;
1181 } else {
1182 // tx_regions == 0
1183 // that's all folks - end of frame
1184 struct sk_buff * skb = dev->tx_skb;
1185 dev->tx_iovec = NULL;
1187 // VC layer stats
1188 atomic_inc(&ATM_SKB(skb)->vcc->stats->tx);
1190 // free the skb
1191 hrz_kfree_skb (skb);
1195 // note: writing TX_COUNT clears any interrupt condition
1196 if (tx_bytes) {
1197 if (pio_instead) {
1198 if (irq)
1199 wr_regl (dev, MASTER_TX_COUNT_REG_OFF, 0);
1200 wrs_regb (dev, DATA_PORT_OFF, dev->tx_addr, tx_bytes);
1201 if (append_desc)
1202 wr_regl (dev, TX_DESCRIPTOR_PORT_OFF, cpu_to_be32 (dev->tx_skb->len));
1203 } else {
1204 wr_regl (dev, MASTER_TX_ADDR_REG_OFF, virt_to_bus (dev->tx_addr));
1205 if (append_desc)
1206 wr_regl (dev, TX_DESCRIPTOR_REG_OFF, cpu_to_be32 (dev->tx_skb->len));
1207 wr_regl (dev, MASTER_TX_COUNT_REG_OFF,
1208 append_desc
1209 ? tx_bytes | MASTER_TX_AUTO_APPEND_DESC
1210 : tx_bytes);
1212 dev->tx_addr += tx_bytes;
1213 } else {
1214 if (irq)
1215 wr_regl (dev, MASTER_TX_COUNT_REG_OFF, 0);
1216 YELLOW_LED_ON(dev);
1217 tx_release (dev);
1220 #ifdef TAILRECURSIONWORKS
1221 // and we all bless optimised tail calls
1222 if (pio_instead)
1223 return tx_schedule (dev, 0);
1224 return;
1225 #else
1226 // grrrrrrr!
1227 irq = 0;
1229 return;
1230 #endif
1233 /********** handle TX bus master complete events **********/
1235 static inline void tx_bus_master_complete_handler (hrz_dev * dev) {
1236 if (test_bit (tx_busy, &dev->flags)) {
1237 tx_schedule (dev, 1);
1238 } else {
1239 PRINTD (DBG_TX|DBG_ERR, "unexpected TX bus master completion");
1240 // clear interrupt condition on adapter
1241 wr_regl (dev, MASTER_TX_COUNT_REG_OFF, 0);
1243 return;
1246 /********** move RX Q pointer to next item in circular buffer **********/
1248 // called only from IRQ sub-handler
1249 static inline u32 rx_queue_entry_next (hrz_dev * dev) {
1250 u32 rx_queue_entry;
1251 spin_lock (&dev->mem_lock);
1252 rx_queue_entry = rd_mem (dev, &dev->rx_q_entry->entry);
1253 if (dev->rx_q_entry == dev->rx_q_wrap)
1254 dev->rx_q_entry = dev->rx_q_reset;
1255 else
1256 dev->rx_q_entry++;
1257 wr_regw (dev, RX_QUEUE_RD_PTR_OFF, dev->rx_q_entry - dev->rx_q_reset);
1258 spin_unlock (&dev->mem_lock);
1259 return rx_queue_entry;
1262 /********** handle RX disabled by device **********/
1264 static inline void rx_disabled_handler (hrz_dev * dev) {
1265 wr_regw (dev, RX_CONFIG_OFF, rd_regw (dev, RX_CONFIG_OFF) | RX_ENABLE);
1266 // count me please
1267 PRINTK (KERN_WARNING, "RX was disabled!");
1270 /********** handle RX data received by device **********/
1272 // called from IRQ handler
1273 static inline void rx_data_av_handler (hrz_dev * dev) {
1274 u32 rx_queue_entry;
1275 u32 rx_queue_entry_flags;
1276 u16 rx_len;
1277 u16 rx_channel;
1279 PRINTD (DBG_FLOW, "hrz_data_av_handler");
1281 // try to grab rx lock (not possible during RX bus mastering)
1282 if (test_and_set_bit (rx_busy, &dev->flags)) {
1283 PRINTD (DBG_RX, "locked out of rx lock");
1284 return;
1286 PRINTD (DBG_RX, "set rx_busy for dev %p", dev);
1287 // lock is cleared if we fail now, o/w after bus master completion
1289 YELLOW_LED_OFF(dev);
1291 rx_queue_entry = rx_queue_entry_next (dev);
1293 rx_len = rx_q_entry_to_length (rx_queue_entry);
1294 rx_channel = rx_q_entry_to_rx_channel (rx_queue_entry);
1296 WAIT_FLUSH_RX_COMPLETE (dev);
1298 SELECT_RX_CHANNEL (dev, rx_channel);
1300 PRINTD (DBG_RX, "rx_queue_entry is: %#x", rx_queue_entry);
1301 rx_queue_entry_flags = rx_queue_entry & (RX_CRC_32_OK|RX_COMPLETE_FRAME|SIMONS_DODGEY_MARKER);
1303 if (!rx_len) {
1304 // (at least) bus-mastering breaks if we try to handle a
1305 // zero-length frame, besides AAL5 does not support them
1306 PRINTK (KERN_ERR, "zero-length frame!");
1307 rx_queue_entry_flags &= ~RX_COMPLETE_FRAME;
1310 if (rx_queue_entry_flags & SIMONS_DODGEY_MARKER) {
1311 PRINTD (DBG_RX|DBG_ERR, "Simon's marker detected!");
1313 if (rx_queue_entry_flags == (RX_CRC_32_OK | RX_COMPLETE_FRAME)) {
1314 struct atm_vcc * atm_vcc;
1316 PRINTD (DBG_RX, "got a frame on rx_channel %x len %u", rx_channel, rx_len);
1318 atm_vcc = dev->rxer[rx_channel];
1319 // if no vcc is assigned to this channel, we should drop the frame
1320 // (is this what SIMONS etc. was trying to achieve?)
1322 if (atm_vcc) {
1324 if (atm_vcc->qos.rxtp.traffic_class != ATM_NONE) {
1326 if (rx_len <= atm_vcc->qos.rxtp.max_sdu) {
1328 struct sk_buff * skb = atm_alloc_charge (atm_vcc, rx_len, GFP_ATOMIC);
1329 if (skb) {
1330 // remember this so we can push it later
1331 dev->rx_skb = skb;
1332 // remember this so we can flush it later
1333 dev->rx_channel = rx_channel;
1335 // prepare socket buffer
1336 skb_put (skb, rx_len);
1337 ATM_SKB(skb)->vcc = atm_vcc;
1339 // simple transfer
1340 // dev->rx_regions = 0;
1341 // dev->rx_iovec = 0;
1342 dev->rx_bytes = rx_len;
1343 dev->rx_addr = skb->data;
1344 PRINTD (DBG_RX, "RX start simple transfer (addr %p, len %d)",
1345 skb->data, rx_len);
1347 // do the business
1348 rx_schedule (dev, 0);
1349 return;
1351 } else {
1352 PRINTD (DBG_SKB|DBG_WARN, "failed to get skb");
1355 } else {
1356 PRINTK (KERN_INFO, "frame received on TX-only VC %x", rx_channel);
1357 // do we count this?
1360 } else {
1361 PRINTK (KERN_WARNING, "dropped over-size frame");
1362 // do we count this?
1365 } else {
1366 PRINTD (DBG_WARN|DBG_VCC|DBG_RX, "no VCC for this frame (VC closed)");
1367 // do we count this?
1370 } else {
1371 // Wait update complete ? SPONG
1374 // RX was aborted
1375 YELLOW_LED_ON(dev);
1377 FLUSH_RX_CHANNEL (dev,rx_channel);
1378 clear_bit (rx_busy, &dev->flags);
1380 return;
1383 /********** interrupt handler **********/
1385 static irqreturn_t interrupt_handler(int irq, void *dev_id,
1386 struct pt_regs *pt_regs) {
1387 hrz_dev * dev = (hrz_dev *) dev_id;
1388 u32 int_source;
1389 unsigned int irq_ok;
1390 (void) pt_regs;
1392 PRINTD (DBG_FLOW, "interrupt_handler: %p", dev_id);
1394 if (!dev_id) {
1395 PRINTD (DBG_IRQ|DBG_ERR, "irq with NULL dev_id: %d", irq);
1396 return IRQ_NONE;
1398 if (irq != dev->irq) {
1399 PRINTD (DBG_IRQ|DBG_ERR, "irq mismatch: %d", irq);
1400 return IRQ_NONE;
1403 // definitely for us
1404 irq_ok = 0;
1405 while ((int_source = rd_regl (dev, INT_SOURCE_REG_OFF)
1406 & INTERESTING_INTERRUPTS)) {
1407 // In the interests of fairness, the (inline) handlers below are
1408 // called in sequence and without immediate return to the head of
1409 // the while loop. This is only of issue for slow hosts (or when
1410 // debugging messages are on). Really slow hosts may find a fast
1411 // sender keeps them permanently in the IRQ handler. :(
1413 // (only an issue for slow hosts) RX completion goes before
1414 // rx_data_av as the former implies rx_busy and so the latter
1415 // would just abort. If it reschedules another transfer
1416 // (continuing the same frame) then it will not clear rx_busy.
1418 // (only an issue for slow hosts) TX completion goes before RX
1419 // data available as it is a much shorter routine - there is the
1420 // chance that any further transfers it schedules will be complete
1421 // by the time of the return to the head of the while loop
1423 if (int_source & RX_BUS_MASTER_COMPLETE) {
1424 ++irq_ok;
1425 PRINTD (DBG_IRQ|DBG_BUS|DBG_RX, "rx_bus_master_complete asserted");
1426 rx_bus_master_complete_handler (dev);
1428 if (int_source & TX_BUS_MASTER_COMPLETE) {
1429 ++irq_ok;
1430 PRINTD (DBG_IRQ|DBG_BUS|DBG_TX, "tx_bus_master_complete asserted");
1431 tx_bus_master_complete_handler (dev);
1433 if (int_source & RX_DATA_AV) {
1434 ++irq_ok;
1435 PRINTD (DBG_IRQ|DBG_RX, "rx_data_av asserted");
1436 rx_data_av_handler (dev);
1439 if (irq_ok) {
1440 PRINTD (DBG_IRQ, "work done: %u", irq_ok);
1441 } else {
1442 PRINTD (DBG_IRQ|DBG_WARN, "spurious interrupt source: %#x", int_source);
1445 PRINTD (DBG_IRQ|DBG_FLOW, "interrupt_handler done: %p", dev_id);
1446 if (irq_ok)
1447 return IRQ_HANDLED;
1448 return IRQ_NONE;
1451 /********** housekeeping **********/
1453 static void do_housekeeping (unsigned long arg) {
1454 // just stats at the moment
1455 hrz_dev * dev = (hrz_dev *) arg;
1457 // collect device-specific (not driver/atm-linux) stats here
1458 dev->tx_cell_count += rd_regw (dev, TX_CELL_COUNT_OFF);
1459 dev->rx_cell_count += rd_regw (dev, RX_CELL_COUNT_OFF);
1460 dev->hec_error_count += rd_regw (dev, HEC_ERROR_COUNT_OFF);
1461 dev->unassigned_cell_count += rd_regw (dev, UNASSIGNED_CELL_COUNT_OFF);
1463 mod_timer (&dev->housekeeping, jiffies + HZ/10);
1465 return;
1468 /********** find an idle channel for TX and set it up **********/
1470 // called with tx_busy set
1471 static inline short setup_idle_tx_channel (hrz_dev * dev, hrz_vcc * vcc) {
1472 unsigned short idle_channels;
1473 short tx_channel = -1;
1474 unsigned int spin_count;
1475 PRINTD (DBG_FLOW|DBG_TX, "setup_idle_tx_channel %p", dev);
1477 // better would be to fail immediately, the caller can then decide whether
1478 // to wait or drop (depending on whether this is UBR etc.)
1479 spin_count = 0;
1480 while (!(idle_channels = rd_regw (dev, TX_STATUS_OFF) & IDLE_CHANNELS_MASK)) {
1481 PRINTD (DBG_TX|DBG_WARN, "waiting for idle TX channel");
1482 // delay a bit here
1483 if (++spin_count > 100) {
1484 PRINTD (DBG_TX|DBG_ERR, "spun out waiting for idle TX channel");
1485 return -EBUSY;
1489 // got an idle channel
1491 // tx_idle ensures we look for idle channels in RR order
1492 int chan = dev->tx_idle;
1494 int keep_going = 1;
1495 while (keep_going) {
1496 if (idle_channels & (1<<chan)) {
1497 tx_channel = chan;
1498 keep_going = 0;
1500 ++chan;
1501 if (chan == TX_CHANS)
1502 chan = 0;
1505 dev->tx_idle = chan;
1508 // set up the channel we found
1510 // Initialise the cell header in the transmit channel descriptor
1511 // a.k.a. prepare the channel and remember that we have done so.
1513 tx_ch_desc * tx_desc = &memmap->tx_descs[tx_channel];
1514 u32 rd_ptr;
1515 u32 wr_ptr;
1516 u16 channel = vcc->channel;
1518 unsigned long flags;
1519 spin_lock_irqsave (&dev->mem_lock, flags);
1521 // Update the transmit channel record.
1522 dev->tx_channel_record[tx_channel] = channel;
1524 // xBR channel
1525 update_tx_channel_config (dev, tx_channel, RATE_TYPE_ACCESS,
1526 vcc->tx_xbr_bits);
1528 // Update the PCR counter preload value etc.
1529 update_tx_channel_config (dev, tx_channel, PCR_TIMER_ACCESS,
1530 vcc->tx_pcr_bits);
1532 #if 0
1533 if (vcc->tx_xbr_bits == VBR_RATE_TYPE) {
1534 // SCR timer
1535 update_tx_channel_config (dev, tx_channel, SCR_TIMER_ACCESS,
1536 vcc->tx_scr_bits);
1538 // Bucket size...
1539 update_tx_channel_config (dev, tx_channel, BUCKET_CAPACITY_ACCESS,
1540 vcc->tx_bucket_bits);
1542 // ... and fullness
1543 update_tx_channel_config (dev, tx_channel, BUCKET_FULLNESS_ACCESS,
1544 vcc->tx_bucket_bits);
1546 #endif
1548 // Initialise the read and write buffer pointers
1549 rd_ptr = rd_mem (dev, &tx_desc->rd_buf_type) & BUFFER_PTR_MASK;
1550 wr_ptr = rd_mem (dev, &tx_desc->wr_buf_type) & BUFFER_PTR_MASK;
1552 // idle TX channels should have identical pointers
1553 if (rd_ptr != wr_ptr) {
1554 PRINTD (DBG_TX|DBG_ERR, "TX buffer pointers are broken!");
1555 // spin_unlock... return -E...
1556 // I wonder if gcc would get rid of one of the pointer aliases
1558 PRINTD (DBG_TX, "TX buffer pointers are: rd %x, wr %x.",
1559 rd_ptr, wr_ptr);
1561 switch (vcc->aal) {
1562 case aal0:
1563 PRINTD (DBG_QOS|DBG_TX, "tx_channel: aal0");
1564 rd_ptr |= CHANNEL_TYPE_RAW_CELLS;
1565 wr_ptr |= CHANNEL_TYPE_RAW_CELLS;
1566 break;
1567 case aal34:
1568 PRINTD (DBG_QOS|DBG_TX, "tx_channel: aal34");
1569 rd_ptr |= CHANNEL_TYPE_AAL3_4;
1570 wr_ptr |= CHANNEL_TYPE_AAL3_4;
1571 break;
1572 case aal5:
1573 rd_ptr |= CHANNEL_TYPE_AAL5;
1574 wr_ptr |= CHANNEL_TYPE_AAL5;
1575 // Initialise the CRC
1576 wr_mem (dev, &tx_desc->partial_crc, INITIAL_CRC);
1577 break;
1580 wr_mem (dev, &tx_desc->rd_buf_type, rd_ptr);
1581 wr_mem (dev, &tx_desc->wr_buf_type, wr_ptr);
1583 // Write the Cell Header
1584 // Payload Type, CLP and GFC would go here if non-zero
1585 wr_mem (dev, &tx_desc->cell_header, channel);
1587 spin_unlock_irqrestore (&dev->mem_lock, flags);
1590 return tx_channel;
1593 /********** send a frame **********/
1595 static int hrz_send (struct atm_vcc * atm_vcc, struct sk_buff * skb) {
1596 unsigned int spin_count;
1597 int free_buffers;
1598 hrz_dev * dev = HRZ_DEV(atm_vcc->dev);
1599 hrz_vcc * vcc = HRZ_VCC(atm_vcc);
1600 u16 channel = vcc->channel;
1602 u32 buffers_required;
1604 /* signed for error return */
1605 short tx_channel;
1607 PRINTD (DBG_FLOW|DBG_TX, "hrz_send vc %x data %p len %u",
1608 channel, skb->data, skb->len);
1610 dump_skb (">>>", channel, skb);
1612 if (atm_vcc->qos.txtp.traffic_class == ATM_NONE) {
1613 PRINTK (KERN_ERR, "attempt to send on RX-only VC %x", channel);
1614 hrz_kfree_skb (skb);
1615 return -EIO;
1618 // don't understand this
1619 ATM_SKB(skb)->vcc = atm_vcc;
1621 if (skb->len > atm_vcc->qos.txtp.max_sdu) {
1622 PRINTK (KERN_ERR, "sk_buff length greater than agreed max_sdu, dropping...");
1623 hrz_kfree_skb (skb);
1624 return -EIO;
1627 if (!channel) {
1628 PRINTD (DBG_ERR|DBG_TX, "attempt to transmit on zero (rx_)channel");
1629 hrz_kfree_skb (skb);
1630 return -EIO;
1633 #if 0
1635 // where would be a better place for this? housekeeping?
1636 u16 status;
1637 pci_read_config_word (dev->pci_dev, PCI_STATUS, &status);
1638 if (status & PCI_STATUS_REC_MASTER_ABORT) {
1639 PRINTD (DBG_BUS|DBG_ERR, "Clearing PCI Master Abort (and cleaning up)");
1640 status &= ~PCI_STATUS_REC_MASTER_ABORT;
1641 pci_write_config_word (dev->pci_dev, PCI_STATUS, status);
1642 if (test_bit (tx_busy, &dev->flags)) {
1643 hrz_kfree_skb (dev->tx_skb);
1644 tx_release (dev);
1648 #endif
1650 #ifdef DEBUG_HORIZON
1651 /* wey-hey! */
1652 if (channel == 1023) {
1653 unsigned int i;
1654 unsigned short d = 0;
1655 char * s = skb->data;
1656 if (*s++ == 'D') {
1657 for (i = 0; i < 4; ++i) {
1658 d = (d<<4) | ((*s <= '9') ? (*s - '0') : (*s - 'a' + 10));
1659 ++s;
1661 PRINTK (KERN_INFO, "debug bitmap is now %hx", debug = d);
1664 #endif
1666 // wait until TX is free and grab lock
1667 if (tx_hold (dev)) {
1668 hrz_kfree_skb (skb);
1669 return -ERESTARTSYS;
1672 // Wait for enough space to be available in transmit buffer memory.
1674 // should be number of cells needed + 2 (according to hardware docs)
1675 // = ((framelen+8)+47) / 48 + 2
1676 // = (framelen+7) / 48 + 3, hmm... faster to put addition inside XXX
1677 buffers_required = (skb->len+(ATM_AAL5_TRAILER-1)) / ATM_CELL_PAYLOAD + 3;
1679 // replace with timer and sleep, add dev->tx_buffers_queue (max 1 entry)
1680 spin_count = 0;
1681 while ((free_buffers = rd_regw (dev, TX_FREE_BUFFER_COUNT_OFF)) < buffers_required) {
1682 PRINTD (DBG_TX, "waiting for free TX buffers, got %d of %d",
1683 free_buffers, buffers_required);
1684 // what is the appropriate delay? implement a timeout? (depending on line speed?)
1685 // mdelay (1);
1686 // what happens if we kill (current_pid, SIGKILL) ?
1687 schedule();
1688 if (++spin_count > 1000) {
1689 PRINTD (DBG_TX|DBG_ERR, "spun out waiting for tx buffers, got %d of %d",
1690 free_buffers, buffers_required);
1691 tx_release (dev);
1692 hrz_kfree_skb (skb);
1693 return -ERESTARTSYS;
1697 // Select a channel to transmit the frame on.
1698 if (channel == dev->last_vc) {
1699 PRINTD (DBG_TX, "last vc hack: hit");
1700 tx_channel = dev->tx_last;
1701 } else {
1702 PRINTD (DBG_TX, "last vc hack: miss");
1703 // Are we currently transmitting this VC on one of the channels?
1704 for (tx_channel = 0; tx_channel < TX_CHANS; ++tx_channel)
1705 if (dev->tx_channel_record[tx_channel] == channel) {
1706 PRINTD (DBG_TX, "vc already on channel: hit");
1707 break;
1709 if (tx_channel == TX_CHANS) {
1710 PRINTD (DBG_TX, "vc already on channel: miss");
1711 // Find and set up an idle channel.
1712 tx_channel = setup_idle_tx_channel (dev, vcc);
1713 if (tx_channel < 0) {
1714 PRINTD (DBG_TX|DBG_ERR, "failed to get channel");
1715 tx_release (dev);
1716 return tx_channel;
1720 PRINTD (DBG_TX, "got channel");
1721 SELECT_TX_CHANNEL(dev, tx_channel);
1723 dev->last_vc = channel;
1724 dev->tx_last = tx_channel;
1727 PRINTD (DBG_TX, "using channel %u", tx_channel);
1729 YELLOW_LED_OFF(dev);
1731 // TX start transfer
1734 unsigned int tx_len = skb->len;
1735 unsigned int tx_iovcnt = skb_shinfo(skb)->nr_frags;
1736 // remember this so we can free it later
1737 dev->tx_skb = skb;
1739 if (tx_iovcnt) {
1740 // scatter gather transfer
1741 dev->tx_regions = tx_iovcnt;
1742 dev->tx_iovec = NULL; /* @@@ needs rewritten */
1743 dev->tx_bytes = 0;
1744 PRINTD (DBG_TX|DBG_BUS, "TX start scatter-gather transfer (iovec %p, len %d)",
1745 skb->data, tx_len);
1746 tx_release (dev);
1747 hrz_kfree_skb (skb);
1748 return -EIO;
1749 } else {
1750 // simple transfer
1751 dev->tx_regions = 0;
1752 dev->tx_iovec = NULL;
1753 dev->tx_bytes = tx_len;
1754 dev->tx_addr = skb->data;
1755 PRINTD (DBG_TX|DBG_BUS, "TX start simple transfer (addr %p, len %d)",
1756 skb->data, tx_len);
1759 // and do the business
1760 tx_schedule (dev, 0);
1764 return 0;
1767 /********** reset a card **********/
1769 static void hrz_reset (const hrz_dev * dev) {
1770 u32 control_0_reg = rd_regl (dev, CONTROL_0_REG);
1772 // why not set RESET_HORIZON to one and wait for the card to
1773 // reassert that bit as zero? Like so:
1774 control_0_reg = control_0_reg & RESET_HORIZON;
1775 wr_regl (dev, CONTROL_0_REG, control_0_reg);
1776 while (control_0_reg & RESET_HORIZON)
1777 control_0_reg = rd_regl (dev, CONTROL_0_REG);
1779 // old reset code retained:
1780 wr_regl (dev, CONTROL_0_REG, control_0_reg |
1781 RESET_ATM | RESET_RX | RESET_TX | RESET_HOST);
1782 // just guessing here
1783 udelay (1000);
1785 wr_regl (dev, CONTROL_0_REG, control_0_reg);
1788 /********** read the burnt in address **********/
1790 static inline void WRITE_IT_WAIT (const hrz_dev *dev, u32 ctrl)
1792 wr_regl (dev, CONTROL_0_REG, ctrl);
1793 udelay (5);
1796 static inline void CLOCK_IT (const hrz_dev *dev, u32 ctrl)
1798 // DI must be valid around rising SK edge
1799 WRITE_IT_WAIT(dev, ctrl & ~SEEPROM_SK);
1800 WRITE_IT_WAIT(dev, ctrl | SEEPROM_SK);
1803 static u16 __init read_bia (const hrz_dev * dev, u16 addr)
1805 u32 ctrl = rd_regl (dev, CONTROL_0_REG);
1807 const unsigned int addr_bits = 6;
1808 const unsigned int data_bits = 16;
1810 unsigned int i;
1812 u16 res;
1814 ctrl &= ~(SEEPROM_CS | SEEPROM_SK | SEEPROM_DI);
1815 WRITE_IT_WAIT(dev, ctrl);
1817 // wake Serial EEPROM and send 110 (READ) command
1818 ctrl |= (SEEPROM_CS | SEEPROM_DI);
1819 CLOCK_IT(dev, ctrl);
1821 ctrl |= SEEPROM_DI;
1822 CLOCK_IT(dev, ctrl);
1824 ctrl &= ~SEEPROM_DI;
1825 CLOCK_IT(dev, ctrl);
1827 for (i=0; i<addr_bits; i++) {
1828 if (addr & (1 << (addr_bits-1)))
1829 ctrl |= SEEPROM_DI;
1830 else
1831 ctrl &= ~SEEPROM_DI;
1833 CLOCK_IT(dev, ctrl);
1835 addr = addr << 1;
1838 // we could check that we have DO = 0 here
1839 ctrl &= ~SEEPROM_DI;
1841 res = 0;
1842 for (i=0;i<data_bits;i++) {
1843 res = res >> 1;
1845 CLOCK_IT(dev, ctrl);
1847 if (rd_regl (dev, CONTROL_0_REG) & SEEPROM_DO)
1848 res |= (1 << (data_bits-1));
1851 ctrl &= ~(SEEPROM_SK | SEEPROM_CS);
1852 WRITE_IT_WAIT(dev, ctrl);
1854 return res;
1857 /********** initialise a card **********/
1859 static int __init hrz_init (hrz_dev * dev) {
1860 int onefivefive;
1862 u16 chan;
1864 int buff_count;
1866 HDW * mem;
1868 cell_buf * tx_desc;
1869 cell_buf * rx_desc;
1871 u32 ctrl;
1873 ctrl = rd_regl (dev, CONTROL_0_REG);
1874 PRINTD (DBG_INFO, "ctrl0reg is %#x", ctrl);
1875 onefivefive = ctrl & ATM_LAYER_STATUS;
1877 if (onefivefive)
1878 printk (DEV_LABEL ": Horizon Ultra (at 155.52 MBps)");
1879 else
1880 printk (DEV_LABEL ": Horizon (at 25 MBps)");
1882 printk (":");
1883 // Reset the card to get everything in a known state
1885 printk (" reset");
1886 hrz_reset (dev);
1888 // Clear all the buffer memory
1890 printk (" clearing memory");
1892 for (mem = (HDW *) memmap; mem < (HDW *) (memmap + 1); ++mem)
1893 wr_mem (dev, mem, 0);
1895 printk (" tx channels");
1897 // All transmit eight channels are set up as AAL5 ABR channels with
1898 // a 16us cell spacing. Why?
1900 // Channel 0 gets the free buffer at 100h, channel 1 gets the free
1901 // buffer at 110h etc.
1903 for (chan = 0; chan < TX_CHANS; ++chan) {
1904 tx_ch_desc * tx_desc = &memmap->tx_descs[chan];
1905 cell_buf * buf = &memmap->inittxbufs[chan];
1907 // initialise the read and write buffer pointers
1908 wr_mem (dev, &tx_desc->rd_buf_type, BUF_PTR(buf));
1909 wr_mem (dev, &tx_desc->wr_buf_type, BUF_PTR(buf));
1911 // set the status of the initial buffers to empty
1912 wr_mem (dev, &buf->next, BUFF_STATUS_EMPTY);
1915 // Use space bufn3 at the moment for tx buffers
1917 printk (" tx buffers");
1919 tx_desc = memmap->bufn3;
1921 wr_mem (dev, &memmap->txfreebufstart.next, BUF_PTR(tx_desc) | BUFF_STATUS_EMPTY);
1923 for (buff_count = 0; buff_count < BUFN3_SIZE-1; buff_count++) {
1924 wr_mem (dev, &tx_desc->next, BUF_PTR(tx_desc+1) | BUFF_STATUS_EMPTY);
1925 tx_desc++;
1928 wr_mem (dev, &tx_desc->next, BUF_PTR(&memmap->txfreebufend) | BUFF_STATUS_EMPTY);
1930 // Initialise the transmit free buffer count
1931 wr_regw (dev, TX_FREE_BUFFER_COUNT_OFF, BUFN3_SIZE);
1933 printk (" rx channels");
1935 // Initialise all of the receive channels to be AAL5 disabled with
1936 // an interrupt threshold of 0
1938 for (chan = 0; chan < RX_CHANS; ++chan) {
1939 rx_ch_desc * rx_desc = &memmap->rx_descs[chan];
1941 wr_mem (dev, &rx_desc->wr_buf_type, CHANNEL_TYPE_AAL5 | RX_CHANNEL_DISABLED);
1944 printk (" rx buffers");
1946 // Use space bufn4 at the moment for rx buffers
1948 rx_desc = memmap->bufn4;
1950 wr_mem (dev, &memmap->rxfreebufstart.next, BUF_PTR(rx_desc) | BUFF_STATUS_EMPTY);
1952 for (buff_count = 0; buff_count < BUFN4_SIZE-1; buff_count++) {
1953 wr_mem (dev, &rx_desc->next, BUF_PTR(rx_desc+1) | BUFF_STATUS_EMPTY);
1955 rx_desc++;
1958 wr_mem (dev, &rx_desc->next, BUF_PTR(&memmap->rxfreebufend) | BUFF_STATUS_EMPTY);
1960 // Initialise the receive free buffer count
1961 wr_regw (dev, RX_FREE_BUFFER_COUNT_OFF, BUFN4_SIZE);
1963 // Initialize Horizons registers
1965 // TX config
1966 wr_regw (dev, TX_CONFIG_OFF,
1967 ABR_ROUND_ROBIN | TX_NORMAL_OPERATION | DRVR_DRVRBAR_ENABLE);
1969 // RX config. Use 10-x VC bits, x VP bits, non user cells in channel 0.
1970 wr_regw (dev, RX_CONFIG_OFF,
1971 DISCARD_UNUSED_VPI_VCI_BITS_SET | NON_USER_CELLS_IN_ONE_CHANNEL | vpi_bits);
1973 // RX line config
1974 wr_regw (dev, RX_LINE_CONFIG_OFF,
1975 LOCK_DETECT_ENABLE | FREQUENCY_DETECT_ENABLE | GXTALOUT_SELECT_DIV4);
1977 // Set the max AAL5 cell count to be just enough to contain the
1978 // largest AAL5 frame that the user wants to receive
1979 wr_regw (dev, MAX_AAL5_CELL_COUNT_OFF,
1980 (max_rx_size + ATM_AAL5_TRAILER + ATM_CELL_PAYLOAD - 1) / ATM_CELL_PAYLOAD);
1982 // Enable receive
1983 wr_regw (dev, RX_CONFIG_OFF, rd_regw (dev, RX_CONFIG_OFF) | RX_ENABLE);
1985 printk (" control");
1987 // Drive the OE of the LEDs then turn the green LED on
1988 ctrl |= GREEN_LED_OE | YELLOW_LED_OE | GREEN_LED | YELLOW_LED;
1989 wr_regl (dev, CONTROL_0_REG, ctrl);
1991 // Test for a 155-capable card
1993 if (onefivefive) {
1994 // Select 155 mode... make this a choice (or: how do we detect
1995 // external line speed and switch?)
1996 ctrl |= ATM_LAYER_SELECT;
1997 wr_regl (dev, CONTROL_0_REG, ctrl);
1999 // test SUNI-lite vs SAMBA
2001 // Register 0x00 in the SUNI will have some of bits 3-7 set, and
2002 // they will always be zero for the SAMBA. Ha! Bloody hardware
2003 // engineers. It'll never work.
2005 if (rd_framer (dev, 0) & 0x00f0) {
2006 // SUNI
2007 printk (" SUNI");
2009 // Reset, just in case
2010 wr_framer (dev, 0x00, 0x0080);
2011 wr_framer (dev, 0x00, 0x0000);
2013 // Configure transmit FIFO
2014 wr_framer (dev, 0x63, rd_framer (dev, 0x63) | 0x0002);
2016 // Set line timed mode
2017 wr_framer (dev, 0x05, rd_framer (dev, 0x05) | 0x0001);
2018 } else {
2019 // SAMBA
2020 printk (" SAMBA");
2022 // Reset, just in case
2023 wr_framer (dev, 0, rd_framer (dev, 0) | 0x0001);
2024 wr_framer (dev, 0, rd_framer (dev, 0) &~ 0x0001);
2026 // Turn off diagnostic loopback and enable line-timed mode
2027 wr_framer (dev, 0, 0x0002);
2029 // Turn on transmit outputs
2030 wr_framer (dev, 2, 0x0B80);
2032 } else {
2033 // Select 25 mode
2034 ctrl &= ~ATM_LAYER_SELECT;
2036 // Madge B154 setup
2037 // none required?
2040 printk (" LEDs");
2042 GREEN_LED_ON(dev);
2043 YELLOW_LED_ON(dev);
2045 printk (" ESI=");
2048 u16 b = 0;
2049 int i;
2050 u8 * esi = dev->atm_dev->esi;
2052 // in the card I have, EEPROM
2053 // addresses 0, 1, 2 contain 0
2054 // addresess 5, 6 etc. contain ffff
2055 // NB: Madge prefix is 00 00 f6 (which is 00 00 6f in Ethernet bit order)
2056 // the read_bia routine gets the BIA in Ethernet bit order
2058 for (i=0; i < ESI_LEN; ++i) {
2059 if (i % 2 == 0)
2060 b = read_bia (dev, i/2 + 2);
2061 else
2062 b = b >> 8;
2063 esi[i] = b & 0xFF;
2064 printk ("%02x", esi[i]);
2068 // Enable RX_Q and ?X_COMPLETE interrupts only
2069 wr_regl (dev, INT_ENABLE_REG_OFF, INTERESTING_INTERRUPTS);
2070 printk (" IRQ on");
2072 printk (".\n");
2074 return onefivefive;
2077 /********** check max_sdu **********/
2079 static int check_max_sdu (hrz_aal aal, struct atm_trafprm * tp, unsigned int max_frame_size) {
2080 PRINTD (DBG_FLOW|DBG_QOS, "check_max_sdu");
2082 switch (aal) {
2083 case aal0:
2084 if (!(tp->max_sdu)) {
2085 PRINTD (DBG_QOS, "defaulting max_sdu");
2086 tp->max_sdu = ATM_AAL0_SDU;
2087 } else if (tp->max_sdu != ATM_AAL0_SDU) {
2088 PRINTD (DBG_QOS|DBG_ERR, "rejecting max_sdu");
2089 return -EINVAL;
2091 break;
2092 case aal34:
2093 if (tp->max_sdu == 0 || tp->max_sdu > ATM_MAX_AAL34_PDU) {
2094 PRINTD (DBG_QOS, "%sing max_sdu", tp->max_sdu ? "capp" : "default");
2095 tp->max_sdu = ATM_MAX_AAL34_PDU;
2097 break;
2098 case aal5:
2099 if (tp->max_sdu == 0 || tp->max_sdu > max_frame_size) {
2100 PRINTD (DBG_QOS, "%sing max_sdu", tp->max_sdu ? "capp" : "default");
2101 tp->max_sdu = max_frame_size;
2103 break;
2105 return 0;
2108 /********** check pcr **********/
2110 // something like this should be part of ATM Linux
2111 static int atm_pcr_check (struct atm_trafprm * tp, unsigned int pcr) {
2112 // we are assuming non-UBR, and non-special values of pcr
2113 if (tp->min_pcr == ATM_MAX_PCR)
2114 PRINTD (DBG_QOS, "luser gave min_pcr = ATM_MAX_PCR");
2115 else if (tp->min_pcr < 0)
2116 PRINTD (DBG_QOS, "luser gave negative min_pcr");
2117 else if (tp->min_pcr && tp->min_pcr > pcr)
2118 PRINTD (DBG_QOS, "pcr less than min_pcr");
2119 else
2120 // !! max_pcr = UNSPEC (0) is equivalent to max_pcr = MAX (-1)
2121 // easier to #define ATM_MAX_PCR 0 and have all rates unsigned?
2122 // [this would get rid of next two conditionals]
2123 if ((0) && tp->max_pcr == ATM_MAX_PCR)
2124 PRINTD (DBG_QOS, "luser gave max_pcr = ATM_MAX_PCR");
2125 else if ((tp->max_pcr != ATM_MAX_PCR) && tp->max_pcr < 0)
2126 PRINTD (DBG_QOS, "luser gave negative max_pcr");
2127 else if (tp->max_pcr && tp->max_pcr != ATM_MAX_PCR && tp->max_pcr < pcr)
2128 PRINTD (DBG_QOS, "pcr greater than max_pcr");
2129 else {
2130 // each limit unspecified or not violated
2131 PRINTD (DBG_QOS, "xBR(pcr) OK");
2132 return 0;
2134 PRINTD (DBG_QOS, "pcr=%u, tp: min_pcr=%d, pcr=%d, max_pcr=%d",
2135 pcr, tp->min_pcr, tp->pcr, tp->max_pcr);
2136 return -EINVAL;
2139 /********** open VC **********/
2141 static int hrz_open (struct atm_vcc *atm_vcc)
2143 int error;
2144 u16 channel;
2146 struct atm_qos * qos;
2147 struct atm_trafprm * txtp;
2148 struct atm_trafprm * rxtp;
2150 hrz_dev * dev = HRZ_DEV(atm_vcc->dev);
2151 hrz_vcc vcc;
2152 hrz_vcc * vccp; // allocated late
2153 short vpi = atm_vcc->vpi;
2154 int vci = atm_vcc->vci;
2155 PRINTD (DBG_FLOW|DBG_VCC, "hrz_open %x %x", vpi, vci);
2157 #ifdef ATM_VPI_UNSPEC
2158 // UNSPEC is deprecated, remove this code eventually
2159 if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC) {
2160 PRINTK (KERN_WARNING, "rejecting open with unspecified VPI/VCI (deprecated)");
2161 return -EINVAL;
2163 #endif
2165 error = vpivci_to_channel (&channel, vpi, vci);
2166 if (error) {
2167 PRINTD (DBG_WARN|DBG_VCC, "VPI/VCI out of range: %hd/%d", vpi, vci);
2168 return error;
2171 vcc.channel = channel;
2172 // max speed for the moment
2173 vcc.tx_rate = 0x0;
2175 qos = &atm_vcc->qos;
2177 // check AAL and remember it
2178 switch (qos->aal) {
2179 case ATM_AAL0:
2180 // we would if it were 48 bytes and not 52!
2181 PRINTD (DBG_QOS|DBG_VCC, "AAL0");
2182 vcc.aal = aal0;
2183 break;
2184 case ATM_AAL34:
2185 // we would if I knew how do the SAR!
2186 PRINTD (DBG_QOS|DBG_VCC, "AAL3/4");
2187 vcc.aal = aal34;
2188 break;
2189 case ATM_AAL5:
2190 PRINTD (DBG_QOS|DBG_VCC, "AAL5");
2191 vcc.aal = aal5;
2192 break;
2193 default:
2194 PRINTD (DBG_QOS|DBG_VCC, "Bad AAL!");
2195 return -EINVAL;
2196 break;
2199 // TX traffic parameters
2201 // there are two, interrelated problems here: 1. the reservation of
2202 // PCR is not a binary choice, we are given bounds and/or a
2203 // desirable value; 2. the device is only capable of certain values,
2204 // most of which are not integers. It is almost certainly acceptable
2205 // to be off by a maximum of 1 to 10 cps.
2207 // Pragmatic choice: always store an integral PCR as that which has
2208 // been allocated, even if we allocate a little (or a lot) less,
2209 // after rounding. The actual allocation depends on what we can
2210 // manage with our rate selection algorithm. The rate selection
2211 // algorithm is given an integral PCR and a tolerance and told
2212 // whether it should round the value up or down if the tolerance is
2213 // exceeded; it returns: a) the actual rate selected (rounded up to
2214 // the nearest integer), b) a bit pattern to feed to the timer
2215 // register, and c) a failure value if no applicable rate exists.
2217 // Part of the job is done by atm_pcr_goal which gives us a PCR
2218 // specification which says: EITHER grab the maximum available PCR
2219 // (and perhaps a lower bound which we musn't pass), OR grab this
2220 // amount, rounding down if you have to (and perhaps a lower bound
2221 // which we musn't pass) OR grab this amount, rounding up if you
2222 // have to (and perhaps an upper bound which we musn't pass). If any
2223 // bounds ARE passed we fail. Note that rounding is only rounding to
2224 // match device limitations, we do not round down to satisfy
2225 // bandwidth availability even if this would not violate any given
2226 // lower bound.
2228 // Note: telephony = 64kb/s = 48 byte cell payload @ 500/3 cells/s
2229 // (say) so this is not even a binary fixpoint cell rate (but this
2230 // device can do it). To avoid this sort of hassle we use a
2231 // tolerance parameter (currently fixed at 10 cps).
2233 PRINTD (DBG_QOS, "TX:");
2235 txtp = &qos->txtp;
2237 // set up defaults for no traffic
2238 vcc.tx_rate = 0;
2239 // who knows what would actually happen if you try and send on this?
2240 vcc.tx_xbr_bits = IDLE_RATE_TYPE;
2241 vcc.tx_pcr_bits = CLOCK_DISABLE;
2242 #if 0
2243 vcc.tx_scr_bits = CLOCK_DISABLE;
2244 vcc.tx_bucket_bits = 0;
2245 #endif
2247 if (txtp->traffic_class != ATM_NONE) {
2248 error = check_max_sdu (vcc.aal, txtp, max_tx_size);
2249 if (error) {
2250 PRINTD (DBG_QOS, "TX max_sdu check failed");
2251 return error;
2254 switch (txtp->traffic_class) {
2255 case ATM_UBR: {
2256 // we take "the PCR" as a rate-cap
2257 // not reserved
2258 vcc.tx_rate = 0;
2259 make_rate (dev, 1<<30, round_nearest, &vcc.tx_pcr_bits, NULL);
2260 vcc.tx_xbr_bits = ABR_RATE_TYPE;
2261 break;
2263 #if 0
2264 case ATM_ABR: {
2265 // reserve min, allow up to max
2266 vcc.tx_rate = 0; // ?
2267 make_rate (dev, 1<<30, round_nearest, &vcc.tx_pcr_bits, 0);
2268 vcc.tx_xbr_bits = ABR_RATE_TYPE;
2269 break;
2271 #endif
2272 case ATM_CBR: {
2273 int pcr = atm_pcr_goal (txtp);
2274 rounding r;
2275 if (!pcr) {
2276 // down vs. up, remaining bandwidth vs. unlimited bandwidth!!
2277 // should really have: once someone gets unlimited bandwidth
2278 // that no more non-UBR channels can be opened until the
2279 // unlimited one closes?? For the moment, round_down means
2280 // greedy people actually get something and not nothing
2281 r = round_down;
2282 // slight race (no locking) here so we may get -EAGAIN
2283 // later; the greedy bastards would deserve it :)
2284 PRINTD (DBG_QOS, "snatching all remaining TX bandwidth");
2285 pcr = dev->tx_avail;
2286 } else if (pcr < 0) {
2287 r = round_down;
2288 pcr = -pcr;
2289 } else {
2290 r = round_up;
2292 error = make_rate_with_tolerance (dev, pcr, r, 10,
2293 &vcc.tx_pcr_bits, &vcc.tx_rate);
2294 if (error) {
2295 PRINTD (DBG_QOS, "could not make rate from TX PCR");
2296 return error;
2298 // not really clear what further checking is needed
2299 error = atm_pcr_check (txtp, vcc.tx_rate);
2300 if (error) {
2301 PRINTD (DBG_QOS, "TX PCR failed consistency check");
2302 return error;
2304 vcc.tx_xbr_bits = CBR_RATE_TYPE;
2305 break;
2307 #if 0
2308 case ATM_VBR: {
2309 int pcr = atm_pcr_goal (txtp);
2310 // int scr = atm_scr_goal (txtp);
2311 int scr = pcr/2; // just for fun
2312 unsigned int mbs = 60; // just for fun
2313 rounding pr;
2314 rounding sr;
2315 unsigned int bucket;
2316 if (!pcr) {
2317 pr = round_nearest;
2318 pcr = 1<<30;
2319 } else if (pcr < 0) {
2320 pr = round_down;
2321 pcr = -pcr;
2322 } else {
2323 pr = round_up;
2325 error = make_rate_with_tolerance (dev, pcr, pr, 10,
2326 &vcc.tx_pcr_bits, 0);
2327 if (!scr) {
2328 // see comments for PCR with CBR above
2329 sr = round_down;
2330 // slight race (no locking) here so we may get -EAGAIN
2331 // later; the greedy bastards would deserve it :)
2332 PRINTD (DBG_QOS, "snatching all remaining TX bandwidth");
2333 scr = dev->tx_avail;
2334 } else if (scr < 0) {
2335 sr = round_down;
2336 scr = -scr;
2337 } else {
2338 sr = round_up;
2340 error = make_rate_with_tolerance (dev, scr, sr, 10,
2341 &vcc.tx_scr_bits, &vcc.tx_rate);
2342 if (error) {
2343 PRINTD (DBG_QOS, "could not make rate from TX SCR");
2344 return error;
2346 // not really clear what further checking is needed
2347 // error = atm_scr_check (txtp, vcc.tx_rate);
2348 if (error) {
2349 PRINTD (DBG_QOS, "TX SCR failed consistency check");
2350 return error;
2352 // bucket calculations (from a piece of paper...) cell bucket
2353 // capacity must be largest integer smaller than m(p-s)/p + 1
2354 // where m = max burst size, p = pcr, s = scr
2355 bucket = mbs*(pcr-scr)/pcr;
2356 if (bucket*pcr != mbs*(pcr-scr))
2357 bucket += 1;
2358 if (bucket > BUCKET_MAX_SIZE) {
2359 PRINTD (DBG_QOS, "shrinking bucket from %u to %u",
2360 bucket, BUCKET_MAX_SIZE);
2361 bucket = BUCKET_MAX_SIZE;
2363 vcc.tx_xbr_bits = VBR_RATE_TYPE;
2364 vcc.tx_bucket_bits = bucket;
2365 break;
2367 #endif
2368 default: {
2369 PRINTD (DBG_QOS, "unsupported TX traffic class");
2370 return -EINVAL;
2371 break;
2376 // RX traffic parameters
2378 PRINTD (DBG_QOS, "RX:");
2380 rxtp = &qos->rxtp;
2382 // set up defaults for no traffic
2383 vcc.rx_rate = 0;
2385 if (rxtp->traffic_class != ATM_NONE) {
2386 error = check_max_sdu (vcc.aal, rxtp, max_rx_size);
2387 if (error) {
2388 PRINTD (DBG_QOS, "RX max_sdu check failed");
2389 return error;
2391 switch (rxtp->traffic_class) {
2392 case ATM_UBR: {
2393 // not reserved
2394 break;
2396 #if 0
2397 case ATM_ABR: {
2398 // reserve min
2399 vcc.rx_rate = 0; // ?
2400 break;
2402 #endif
2403 case ATM_CBR: {
2404 int pcr = atm_pcr_goal (rxtp);
2405 if (!pcr) {
2406 // slight race (no locking) here so we may get -EAGAIN
2407 // later; the greedy bastards would deserve it :)
2408 PRINTD (DBG_QOS, "snatching all remaining RX bandwidth");
2409 pcr = dev->rx_avail;
2410 } else if (pcr < 0) {
2411 pcr = -pcr;
2413 vcc.rx_rate = pcr;
2414 // not really clear what further checking is needed
2415 error = atm_pcr_check (rxtp, vcc.rx_rate);
2416 if (error) {
2417 PRINTD (DBG_QOS, "RX PCR failed consistency check");
2418 return error;
2420 break;
2422 #if 0
2423 case ATM_VBR: {
2424 // int scr = atm_scr_goal (rxtp);
2425 int scr = 1<<16; // just for fun
2426 if (!scr) {
2427 // slight race (no locking) here so we may get -EAGAIN
2428 // later; the greedy bastards would deserve it :)
2429 PRINTD (DBG_QOS, "snatching all remaining RX bandwidth");
2430 scr = dev->rx_avail;
2431 } else if (scr < 0) {
2432 scr = -scr;
2434 vcc.rx_rate = scr;
2435 // not really clear what further checking is needed
2436 // error = atm_scr_check (rxtp, vcc.rx_rate);
2437 if (error) {
2438 PRINTD (DBG_QOS, "RX SCR failed consistency check");
2439 return error;
2441 break;
2443 #endif
2444 default: {
2445 PRINTD (DBG_QOS, "unsupported RX traffic class");
2446 return -EINVAL;
2447 break;
2453 // late abort useful for diagnostics
2454 if (vcc.aal != aal5) {
2455 PRINTD (DBG_QOS, "AAL not supported");
2456 return -EINVAL;
2459 // get space for our vcc stuff and copy parameters into it
2460 vccp = kmalloc (sizeof(hrz_vcc), GFP_KERNEL);
2461 if (!vccp) {
2462 PRINTK (KERN_ERR, "out of memory!");
2463 return -ENOMEM;
2465 *vccp = vcc;
2467 // clear error and grab cell rate resource lock
2468 error = 0;
2469 spin_lock (&dev->rate_lock);
2471 if (vcc.tx_rate > dev->tx_avail) {
2472 PRINTD (DBG_QOS, "not enough TX PCR left");
2473 error = -EAGAIN;
2476 if (vcc.rx_rate > dev->rx_avail) {
2477 PRINTD (DBG_QOS, "not enough RX PCR left");
2478 error = -EAGAIN;
2481 if (!error) {
2482 // really consume cell rates
2483 dev->tx_avail -= vcc.tx_rate;
2484 dev->rx_avail -= vcc.rx_rate;
2485 PRINTD (DBG_QOS|DBG_VCC, "reserving %u TX PCR and %u RX PCR",
2486 vcc.tx_rate, vcc.rx_rate);
2489 // release lock and exit on error
2490 spin_unlock (&dev->rate_lock);
2491 if (error) {
2492 PRINTD (DBG_QOS|DBG_VCC, "insufficient cell rate resources");
2493 kfree (vccp);
2494 return error;
2497 // this is "immediately before allocating the connection identifier
2498 // in hardware" - so long as the next call does not fail :)
2499 set_bit(ATM_VF_ADDR,&atm_vcc->flags);
2501 // any errors here are very serious and should never occur
2503 if (rxtp->traffic_class != ATM_NONE) {
2504 if (dev->rxer[channel]) {
2505 PRINTD (DBG_ERR|DBG_VCC, "VC already open for RX");
2506 error = -EBUSY;
2508 if (!error)
2509 error = hrz_open_rx (dev, channel);
2510 if (error) {
2511 kfree (vccp);
2512 return error;
2514 // this link allows RX frames through
2515 dev->rxer[channel] = atm_vcc;
2518 // success, set elements of atm_vcc
2519 atm_vcc->dev_data = (void *) vccp;
2521 // indicate readiness
2522 set_bit(ATM_VF_READY,&atm_vcc->flags);
2524 return 0;
2527 /********** close VC **********/
2529 static void hrz_close (struct atm_vcc * atm_vcc) {
2530 hrz_dev * dev = HRZ_DEV(atm_vcc->dev);
2531 hrz_vcc * vcc = HRZ_VCC(atm_vcc);
2532 u16 channel = vcc->channel;
2533 PRINTD (DBG_VCC|DBG_FLOW, "hrz_close");
2535 // indicate unreadiness
2536 clear_bit(ATM_VF_READY,&atm_vcc->flags);
2538 if (atm_vcc->qos.txtp.traffic_class != ATM_NONE) {
2539 unsigned int i;
2541 // let any TX on this channel that has started complete
2542 // no restart, just keep trying
2543 while (tx_hold (dev))
2545 // remove record of any tx_channel having been setup for this channel
2546 for (i = 0; i < TX_CHANS; ++i)
2547 if (dev->tx_channel_record[i] == channel) {
2548 dev->tx_channel_record[i] = -1;
2549 break;
2551 if (dev->last_vc == channel)
2552 dev->tx_last = -1;
2553 tx_release (dev);
2556 if (atm_vcc->qos.rxtp.traffic_class != ATM_NONE) {
2557 // disable RXing - it tries quite hard
2558 hrz_close_rx (dev, channel);
2559 // forget the vcc - no more skbs will be pushed
2560 if (atm_vcc != dev->rxer[channel])
2561 PRINTK (KERN_ERR, "%s atm_vcc=%p rxer[channel]=%p",
2562 "arghhh! we're going to die!",
2563 atm_vcc, dev->rxer[channel]);
2564 dev->rxer[channel] = NULL;
2567 // atomically release our rate reservation
2568 spin_lock (&dev->rate_lock);
2569 PRINTD (DBG_QOS|DBG_VCC, "releasing %u TX PCR and %u RX PCR",
2570 vcc->tx_rate, vcc->rx_rate);
2571 dev->tx_avail += vcc->tx_rate;
2572 dev->rx_avail += vcc->rx_rate;
2573 spin_unlock (&dev->rate_lock);
2575 // free our structure
2576 kfree (vcc);
2577 // say the VPI/VCI is free again
2578 clear_bit(ATM_VF_ADDR,&atm_vcc->flags);
2581 #if 0
2582 static int hrz_getsockopt (struct atm_vcc * atm_vcc, int level, int optname,
2583 void *optval, int optlen) {
2584 hrz_dev * dev = HRZ_DEV(atm_vcc->dev);
2585 PRINTD (DBG_FLOW|DBG_VCC, "hrz_getsockopt");
2586 switch (level) {
2587 case SOL_SOCKET:
2588 switch (optname) {
2589 // case SO_BCTXOPT:
2590 // break;
2591 // case SO_BCRXOPT:
2592 // break;
2593 default:
2594 return -ENOPROTOOPT;
2595 break;
2596 };
2597 break;
2599 return -EINVAL;
2602 static int hrz_setsockopt (struct atm_vcc * atm_vcc, int level, int optname,
2603 void *optval, int optlen) {
2604 hrz_dev * dev = HRZ_DEV(atm_vcc->dev);
2605 PRINTD (DBG_FLOW|DBG_VCC, "hrz_setsockopt");
2606 switch (level) {
2607 case SOL_SOCKET:
2608 switch (optname) {
2609 // case SO_BCTXOPT:
2610 // break;
2611 // case SO_BCRXOPT:
2612 // break;
2613 default:
2614 return -ENOPROTOOPT;
2615 break;
2616 };
2617 break;
2619 return -EINVAL;
2621 #endif
2623 #if 0
2624 static int hrz_ioctl (struct atm_dev * atm_dev, unsigned int cmd, void *arg) {
2625 hrz_dev * dev = HRZ_DEV(atm_dev);
2626 PRINTD (DBG_FLOW, "hrz_ioctl");
2627 return -1;
2630 unsigned char hrz_phy_get (struct atm_dev * atm_dev, unsigned long addr) {
2631 hrz_dev * dev = HRZ_DEV(atm_dev);
2632 PRINTD (DBG_FLOW, "hrz_phy_get");
2633 return 0;
2636 static void hrz_phy_put (struct atm_dev * atm_dev, unsigned char value,
2637 unsigned long addr) {
2638 hrz_dev * dev = HRZ_DEV(atm_dev);
2639 PRINTD (DBG_FLOW, "hrz_phy_put");
2642 static int hrz_change_qos (struct atm_vcc * atm_vcc, struct atm_qos *qos, int flgs) {
2643 hrz_dev * dev = HRZ_DEV(vcc->dev);
2644 PRINTD (DBG_FLOW, "hrz_change_qos");
2645 return -1;
2647 #endif
2649 /********** proc file contents **********/
2651 static int hrz_proc_read (struct atm_dev * atm_dev, loff_t * pos, char * page) {
2652 hrz_dev * dev = HRZ_DEV(atm_dev);
2653 int left = *pos;
2654 PRINTD (DBG_FLOW, "hrz_proc_read");
2656 /* more diagnostics here? */
2658 #if 0
2659 if (!left--) {
2660 unsigned int count = sprintf (page, "vbr buckets:");
2661 unsigned int i;
2662 for (i = 0; i < TX_CHANS; ++i)
2663 count += sprintf (page, " %u/%u",
2664 query_tx_channel_config (dev, i, BUCKET_FULLNESS_ACCESS),
2665 query_tx_channel_config (dev, i, BUCKET_CAPACITY_ACCESS));
2666 count += sprintf (page+count, ".\n");
2667 return count;
2669 #endif
2671 if (!left--)
2672 return sprintf (page,
2673 "cells: TX %lu, RX %lu, HEC errors %lu, unassigned %lu.\n",
2674 dev->tx_cell_count, dev->rx_cell_count,
2675 dev->hec_error_count, dev->unassigned_cell_count);
2677 if (!left--)
2678 return sprintf (page,
2679 "free cell buffers: TX %hu, RX %hu+%hu.\n",
2680 rd_regw (dev, TX_FREE_BUFFER_COUNT_OFF),
2681 rd_regw (dev, RX_FREE_BUFFER_COUNT_OFF),
2682 dev->noof_spare_buffers);
2684 if (!left--)
2685 return sprintf (page,
2686 "cps remaining: TX %u, RX %u\n",
2687 dev->tx_avail, dev->rx_avail);
2689 return 0;
2692 static const struct atmdev_ops hrz_ops = {
2693 .open = hrz_open,
2694 .close = hrz_close,
2695 .send = hrz_send,
2696 .proc_read = hrz_proc_read,
2697 .owner = THIS_MODULE,
2698 };
2700 static int __devinit hrz_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_ent)
2702 hrz_dev * dev;
2703 int err = 0;
2705 // adapter slot free, read resources from PCI configuration space
2706 u32 iobase = pci_resource_start (pci_dev, 0);
2707 u32 * membase = bus_to_virt (pci_resource_start (pci_dev, 1));
2708 unsigned int irq;
2709 unsigned char lat;
2711 PRINTD (DBG_FLOW, "hrz_probe");
2713 if (pci_enable_device(pci_dev))
2714 return -EINVAL;
2716 /* XXX DEV_LABEL is a guess */
2717 if (!request_region(iobase, HRZ_IO_EXTENT, DEV_LABEL)) {
2718 return -EINVAL;
2719 goto out_disable;
2722 dev = kmalloc(sizeof(hrz_dev), GFP_KERNEL);
2723 if (!dev) {
2724 // perhaps we should be nice: deregister all adapters and abort?
2725 PRINTD(DBG_ERR, "out of memory");
2726 err = -ENOMEM;
2727 goto out_release;
2730 memset(dev, 0, sizeof(hrz_dev));
2732 pci_set_drvdata(pci_dev, dev);
2734 // grab IRQ and install handler - move this someplace more sensible
2735 irq = pci_dev->irq;
2736 if (request_irq(irq,
2737 interrupt_handler,
2738 IRQF_SHARED, /* irqflags guess */
2739 DEV_LABEL, /* name guess */
2740 dev)) {
2741 PRINTD(DBG_WARN, "request IRQ failed!");
2742 err = -EINVAL;
2743 goto out_free;
2746 PRINTD(DBG_INFO, "found Madge ATM adapter (hrz) at: IO %x, IRQ %u, MEM %p",
2747 iobase, irq, membase);
2749 dev->atm_dev = atm_dev_register(DEV_LABEL, &hrz_ops, -1, NULL);
2750 if (!(dev->atm_dev)) {
2751 PRINTD(DBG_ERR, "failed to register Madge ATM adapter");
2752 err = -EINVAL;
2753 goto out_free_irq;
2756 PRINTD(DBG_INFO, "registered Madge ATM adapter (no. %d) (%p) at %p",
2757 dev->atm_dev->number, dev, dev->atm_dev);
2758 dev->atm_dev->dev_data = (void *) dev;
2759 dev->pci_dev = pci_dev;
2761 // enable bus master accesses
2762 pci_set_master(pci_dev);
2764 // frobnicate latency (upwards, usually)
2765 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &lat);
2766 if (pci_lat) {
2767 PRINTD(DBG_INFO, "%s PCI latency timer from %hu to %hu",
2768 "changing", lat, pci_lat);
2769 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, pci_lat);
2770 } else if (lat < MIN_PCI_LATENCY) {
2771 PRINTK(KERN_INFO, "%s PCI latency timer from %hu to %hu",
2772 "increasing", lat, MIN_PCI_LATENCY);
2773 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, MIN_PCI_LATENCY);
2776 dev->iobase = iobase;
2777 dev->irq = irq;
2778 dev->membase = membase;
2780 dev->rx_q_entry = dev->rx_q_reset = &memmap->rx_q_entries[0];
2781 dev->rx_q_wrap = &memmap->rx_q_entries[RX_CHANS-1];
2783 // these next three are performance hacks
2784 dev->last_vc = -1;
2785 dev->tx_last = -1;
2786 dev->tx_idle = 0;
2788 dev->tx_regions = 0;
2789 dev->tx_bytes = 0;
2790 dev->tx_skb = NULL;
2791 dev->tx_iovec = NULL;
2793 dev->tx_cell_count = 0;
2794 dev->rx_cell_count = 0;
2795 dev->hec_error_count = 0;
2796 dev->unassigned_cell_count = 0;
2798 dev->noof_spare_buffers = 0;
2801 unsigned int i;
2802 for (i = 0; i < TX_CHANS; ++i)
2803 dev->tx_channel_record[i] = -1;
2806 dev->flags = 0;
2808 // Allocate cell rates and remember ASIC version
2809 // Fibre: ATM_OC3_PCR = 1555200000/8/270*260/53 - 29/53
2810 // Copper: (WRONG) we want 6 into the above, close to 25Mb/s
2811 // Copper: (plagarise!) 25600000/8/270*260/53 - n/53
2813 if (hrz_init(dev)) {
2814 // to be really pedantic, this should be ATM_OC3c_PCR
2815 dev->tx_avail = ATM_OC3_PCR;
2816 dev->rx_avail = ATM_OC3_PCR;
2817 set_bit(ultra, &dev->flags); // NOT "|= ultra" !
2818 } else {
2819 dev->tx_avail = ((25600000/8)*26)/(27*53);
2820 dev->rx_avail = ((25600000/8)*26)/(27*53);
2821 PRINTD(DBG_WARN, "Buggy ASIC: no TX bus-mastering.");
2824 // rate changes spinlock
2825 spin_lock_init(&dev->rate_lock);
2827 // on-board memory access spinlock; we want atomic reads and
2828 // writes to adapter memory (handles IRQ and SMP)
2829 spin_lock_init(&dev->mem_lock);
2831 init_waitqueue_head(&dev->tx_queue);
2833 // vpi in 0..4, vci in 6..10
2834 dev->atm_dev->ci_range.vpi_bits = vpi_bits;
2835 dev->atm_dev->ci_range.vci_bits = 10-vpi_bits;
2837 init_timer(&dev->housekeeping);
2838 dev->housekeeping.function = do_housekeeping;
2839 dev->housekeeping.data = (unsigned long) dev;
2840 mod_timer(&dev->housekeeping, jiffies);
2842 out:
2843 return err;
2845 out_free_irq:
2846 free_irq(dev->irq, dev);
2847 out_free:
2848 kfree(dev);
2849 out_release:
2850 release_region(iobase, HRZ_IO_EXTENT);
2851 out_disable:
2852 pci_disable_device(pci_dev);
2853 goto out;
2856 static void __devexit hrz_remove_one(struct pci_dev *pci_dev)
2858 hrz_dev *dev;
2860 dev = pci_get_drvdata(pci_dev);
2862 PRINTD(DBG_INFO, "closing %p (atm_dev = %p)", dev, dev->atm_dev);
2863 del_timer_sync(&dev->housekeeping);
2864 hrz_reset(dev);
2865 atm_dev_deregister(dev->atm_dev);
2866 free_irq(dev->irq, dev);
2867 release_region(dev->iobase, HRZ_IO_EXTENT);
2868 kfree(dev);
2870 pci_disable_device(pci_dev);
2873 static void __init hrz_check_args (void) {
2874 #ifdef DEBUG_HORIZON
2875 PRINTK (KERN_NOTICE, "debug bitmap is %hx", debug &= DBG_MASK);
2876 #else
2877 if (debug)
2878 PRINTK (KERN_NOTICE, "no debug support in this image");
2879 #endif
2881 if (vpi_bits > HRZ_MAX_VPI)
2882 PRINTK (KERN_ERR, "vpi_bits has been limited to %hu",
2883 vpi_bits = HRZ_MAX_VPI);
2885 if (max_tx_size < 0 || max_tx_size > TX_AAL5_LIMIT)
2886 PRINTK (KERN_NOTICE, "max_tx_size has been limited to %hu",
2887 max_tx_size = TX_AAL5_LIMIT);
2889 if (max_rx_size < 0 || max_rx_size > RX_AAL5_LIMIT)
2890 PRINTK (KERN_NOTICE, "max_rx_size has been limited to %hu",
2891 max_rx_size = RX_AAL5_LIMIT);
2893 return;
2896 MODULE_AUTHOR(maintainer_string);
2897 MODULE_DESCRIPTION(description_string);
2898 MODULE_LICENSE("GPL");
2899 module_param(debug, ushort, 0644);
2900 module_param(vpi_bits, ushort, 0);
2901 module_param(max_tx_size, int, 0);
2902 module_param(max_rx_size, int, 0);
2903 module_param(pci_lat, byte, 0);
2904 MODULE_PARM_DESC(debug, "debug bitmap, see .h file");
2905 MODULE_PARM_DESC(vpi_bits, "number of bits (0..4) to allocate to VPIs");
2906 MODULE_PARM_DESC(max_tx_size, "maximum size of TX AAL5 frames");
2907 MODULE_PARM_DESC(max_rx_size, "maximum size of RX AAL5 frames");
2908 MODULE_PARM_DESC(pci_lat, "PCI latency in bus cycles");
2910 static struct pci_device_id hrz_pci_tbl[] = {
2911 { PCI_VENDOR_ID_MADGE, PCI_DEVICE_ID_MADGE_HORIZON, PCI_ANY_ID, PCI_ANY_ID,
2912 0, 0, 0 },
2913 { 0, }
2914 };
2916 MODULE_DEVICE_TABLE(pci, hrz_pci_tbl);
2918 static struct pci_driver hrz_driver = {
2919 .name = "horizon",
2920 .probe = hrz_probe,
2921 .remove = __devexit_p(hrz_remove_one),
2922 .id_table = hrz_pci_tbl,
2923 };
2925 /********** module entry **********/
2927 static int __init hrz_module_init (void) {
2928 // sanity check - cast is needed since printk does not support %Zu
2929 if (sizeof(struct MEMMAP) != 128*1024/4) {
2930 PRINTK (KERN_ERR, "Fix struct MEMMAP (is %lu fakewords).",
2931 (unsigned long) sizeof(struct MEMMAP));
2932 return -ENOMEM;
2935 show_version();
2937 // check arguments
2938 hrz_check_args();
2940 // get the juice
2941 return pci_register_driver(&hrz_driver);
2944 /********** module exit **********/
2946 static void __exit hrz_module_exit (void) {
2947 PRINTD (DBG_FLOW, "cleanup_module");
2949 return pci_unregister_driver(&hrz_driver);
2952 module_init(hrz_module_init);
2953 module_exit(hrz_module_exit);