aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless
diff options
context:
space:
mode:
authorJohn W. Linville <linville@tuxdriver.com>2009-10-20 00:53:08 -0400
committerJohn W. Linville <linville@tuxdriver.com>2009-10-30 16:50:33 -0400
commite38879efd336fb78b288dcebdc9ca030fd24f449 (patch)
tree61e0caaf24485474e52085658e46909e822a7fc0 /drivers/net/wireless
parent955015bb0b42167d14f776ff5947ae2463a974dc (diff)
arlan: move driver to staging
Move the arlan driver to drivers/staging. This is another pre-802.11 driver that has seen virtually no non-API-fixup activity in years, and for which no active hardware is likely to still exist. This driver represents unnecessary ongoing maintenance for no clear benefit. This patch brought to you by the "hacking" session at the 2009 Kernel Summit in Tokyo, Japan... Acked-by: Greg Kroah-Hartman <gregkh@suse.de> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless')
-rw-r--r--drivers/net/wireless/Kconfig16
-rw-r--r--drivers/net/wireless/Makefile4
-rw-r--r--drivers/net/wireless/arlan-main.c1887
-rw-r--r--drivers/net/wireless/arlan-proc.c1253
-rw-r--r--drivers/net/wireless/arlan.h539
5 files changed, 0 insertions, 3699 deletions
diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig
index 5df47486e358..d50b3bee9a9b 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -25,22 +25,6 @@ menuconfig WLAN_PRE80211
25 This option does not affect the kernel build, it only 25 This option does not affect the kernel build, it only
26 lets you choose drivers. 26 lets you choose drivers.
27 27
28config ARLAN
29 tristate "Aironet Arlan 655 & IC2200 DS support"
30 depends on ISA && !64BIT && WLAN_PRE80211
31 select WIRELESS_EXT
32 ---help---
33 Aironet makes Arlan, a class of wireless LAN adapters. These use the
34 www.Telxon.com chip, which is also used on several similar cards.
35 This driver is tested on the 655 and IC2200 series cards. Look at
36 <http://www.ylenurme.ee/~elmer/655/> for the latest information.
37
38 The driver is built as two modules, arlan and arlan-proc. The latter
39 is the /proc interface and is not needed most of time.
40
41 On some computers the card ends up in non-valid state after some
42 time. Use a ping-reset script to clear it.
43
44config WAVELAN 28config WAVELAN
45 tristate "AT&T/Lucent old WaveLAN & DEC RoamAbout DS ISA support" 29 tristate "AT&T/Lucent old WaveLAN & DEC RoamAbout DS ISA support"
46 depends on ISA && WLAN_PRE80211 30 depends on ISA && WLAN_PRE80211
diff --git a/drivers/net/wireless/Makefile b/drivers/net/wireless/Makefile
index 527c272aa1af..b56c70f4ca75 100644
--- a/drivers/net/wireless/Makefile
+++ b/drivers/net/wireless/Makefile
@@ -5,10 +5,6 @@
5obj-$(CONFIG_IPW2100) += ipw2x00/ 5obj-$(CONFIG_IPW2100) += ipw2x00/
6obj-$(CONFIG_IPW2200) += ipw2x00/ 6obj-$(CONFIG_IPW2200) += ipw2x00/
7 7
8obj-$(CONFIG_ARLAN) += arlan.o
9
10arlan-objs := arlan-main.o arlan-proc.o
11
12# Obsolete cards 8# Obsolete cards
13obj-$(CONFIG_WAVELAN) += wavelan.o 9obj-$(CONFIG_WAVELAN) += wavelan.o
14obj-$(CONFIG_PCMCIA_NETWAVE) += netwave_cs.o 10obj-$(CONFIG_PCMCIA_NETWAVE) += netwave_cs.o
diff --git a/drivers/net/wireless/arlan-main.c b/drivers/net/wireless/arlan-main.c
deleted file mode 100644
index 921a082487a1..000000000000
--- a/drivers/net/wireless/arlan-main.c
+++ /dev/null
@@ -1,1887 +0,0 @@
1/*
2 * Copyright (C) 1997 Cullen Jennings
3 * Copyright (C) 1998 Elmer Joandiu, elmer@ylenurme.ee
4 * GNU General Public License applies
5 * This module provides support for the Arlan 655 card made by Aironet
6 */
7
8#include "arlan.h"
9
10#if BITS_PER_LONG != 32
11# error FIXME: this driver requires a 32-bit platform
12#endif
13
14static const char *arlan_version = "C.Jennigs 97 & Elmer.Joandi@ut.ee Oct'98, http://www.ylenurme.ee/~elmer/655/";
15
16struct net_device *arlan_device[MAX_ARLANS];
17
18static int SID = SIDUNKNOWN;
19static int radioNodeId = radioNodeIdUNKNOWN;
20static char encryptionKey[12] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
21int arlan_debug = debugUNKNOWN;
22static int spreadingCode = spreadingCodeUNKNOWN;
23static int channelNumber = channelNumberUNKNOWN;
24static int channelSet = channelSetUNKNOWN;
25static int systemId = systemIdUNKNOWN;
26static int registrationMode = registrationModeUNKNOWN;
27static int keyStart;
28static int tx_delay_ms;
29static int retries = 5;
30static int tx_queue_len = 1;
31static int arlan_EEPROM_bad;
32
33#ifdef ARLAN_DEBUGGING
34
35static int testMemory = testMemoryUNKNOWN;
36static int irq = irqUNKNOWN;
37static int txScrambled = 1;
38static int mdebug;
39
40module_param(irq, int, 0);
41module_param(mdebug, int, 0);
42module_param(testMemory, int, 0);
43module_param(txScrambled, int, 0);
44MODULE_PARM_DESC(irq, "(unused)");
45MODULE_PARM_DESC(testMemory, "(unused)");
46MODULE_PARM_DESC(mdebug, "Arlan multicast debugging (0-1)");
47#endif
48
49module_param_named(debug, arlan_debug, int, 0);
50module_param(spreadingCode, int, 0);
51module_param(channelNumber, int, 0);
52module_param(channelSet, int, 0);
53module_param(systemId, int, 0);
54module_param(registrationMode, int, 0);
55module_param(radioNodeId, int, 0);
56module_param(SID, int, 0);
57module_param(keyStart, int, 0);
58module_param(tx_delay_ms, int, 0);
59module_param(retries, int, 0);
60module_param(tx_queue_len, int, 0);
61module_param_named(EEPROM_bad, arlan_EEPROM_bad, int, 0);
62MODULE_PARM_DESC(debug, "Arlan debug enable (0-1)");
63MODULE_PARM_DESC(retries, "Arlan maximum packet retransmisions");
64#ifdef ARLAN_ENTRY_EXIT_DEBUGGING
65static int arlan_entry_debug;
66static int arlan_exit_debug;
67static int arlan_entry_and_exit_debug;
68module_param_named(entry_debug, arlan_entry_debug, int, 0);
69module_param_named(exit_debug, arlan_exit_debug, int, 0);
70module_param_named(entry_and_exit_debug, arlan_entry_and_exit_debug, int, 0);
71MODULE_PARM_DESC(entry_debug, "Arlan driver function entry debugging");
72MODULE_PARM_DESC(exit_debug, "Arlan driver function exit debugging");
73MODULE_PARM_DESC(entry_and_exit_debug, "Arlan driver function entry and exit debugging");
74#endif
75
76struct arlan_conf_stru arlan_conf[MAX_ARLANS];
77static int arlans_found;
78
79static int arlan_open(struct net_device *dev);
80static netdev_tx_t arlan_tx(struct sk_buff *skb, struct net_device *dev);
81static irqreturn_t arlan_interrupt(int irq, void *dev_id);
82static int arlan_close(struct net_device *dev);
83static struct net_device_stats *
84 arlan_statistics (struct net_device *dev);
85static void arlan_set_multicast (struct net_device *dev);
86static int arlan_hw_tx (struct net_device* dev, char *buf, int length );
87static int arlan_hw_config (struct net_device * dev);
88static void arlan_tx_done_interrupt (struct net_device * dev, int status);
89static void arlan_rx_interrupt (struct net_device * dev, u_char rxStatus, u_short, u_short);
90static void arlan_process_interrupt (struct net_device * dev);
91static void arlan_tx_timeout (struct net_device *dev);
92
93static inline long us2ticks(int us)
94{
95 return us * (1000000 / HZ);
96}
97
98
99#ifdef ARLAN_ENTRY_EXIT_DEBUGGING
100#define ARLAN_DEBUG_ENTRY(name) \
101 {\
102 struct timeval timev;\
103 do_gettimeofday(&timev);\
104 if (arlan_entry_debug || arlan_entry_and_exit_debug)\
105 printk("--->>>" name " %ld " "\n",((long int) timev.tv_sec * 1000000 + timev.tv_usec));\
106 }
107#define ARLAN_DEBUG_EXIT(name) \
108 {\
109 struct timeval timev;\
110 do_gettimeofday(&timev);\
111 if (arlan_exit_debug || arlan_entry_and_exit_debug)\
112 printk("<<<---" name " %ld " "\n",((long int) timev.tv_sec * 1000000 + timev.tv_usec) );\
113 }
114#else
115#define ARLAN_DEBUG_ENTRY(name)
116#define ARLAN_DEBUG_EXIT(name)
117#endif
118
119
120#define arlan_interrupt_ack(dev)\
121 clearClearInterrupt(dev);\
122 setClearInterrupt(dev);
123
124static inline int arlan_drop_tx(struct net_device *dev)
125{
126 struct arlan_private *priv = netdev_priv(dev);
127
128 dev->stats.tx_errors++;
129 if (priv->Conf->tx_delay_ms)
130 {
131 priv->tx_done_delayed = jiffies + priv->Conf->tx_delay_ms * HZ / 1000 + 1;
132 }
133 else
134 {
135 priv->waiting_command_mask &= ~ARLAN_COMMAND_TX;
136 TXHEAD(dev).offset = 0;
137 TXTAIL(dev).offset = 0;
138 priv->txLast = 0;
139 priv->bad = 0;
140 if (!priv->under_reset && !priv->under_config)
141 netif_wake_queue (dev);
142 }
143 return 1;
144}
145
146
147int arlan_command(struct net_device *dev, int command_p)
148{
149 struct arlan_private *priv = netdev_priv(dev);
150 volatile struct arlan_shmem __iomem *arlan = priv->card;
151 struct arlan_conf_stru *conf = priv->Conf;
152 int udelayed = 0;
153 int i = 0;
154 unsigned long flags;
155
156 ARLAN_DEBUG_ENTRY("arlan_command");
157
158 if (priv->card_polling_interval)
159 priv->card_polling_interval = 1;
160
161 if (arlan_debug & ARLAN_DEBUG_CHAIN_LOCKS)
162 printk(KERN_DEBUG "arlan_command, %lx commandByte %x waiting %lx incoming %x \n",
163 jiffies, READSHMB(arlan->commandByte),
164 priv->waiting_command_mask, command_p);
165
166 priv->waiting_command_mask |= command_p;
167
168 if (priv->waiting_command_mask & ARLAN_COMMAND_RESET)
169 if (time_after(jiffies, priv->lastReset + 5 * HZ))
170 priv->waiting_command_mask &= ~ARLAN_COMMAND_RESET;
171
172 if (priv->waiting_command_mask & ARLAN_COMMAND_INT_ACK)
173 {
174 arlan_interrupt_ack(dev);
175 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_ACK;
176 }
177 if (priv->waiting_command_mask & ARLAN_COMMAND_INT_ENABLE)
178 {
179 setInterruptEnable(dev);
180 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_ENABLE;
181 }
182
183 /* Card access serializing lock */
184 spin_lock_irqsave(&priv->lock, flags);
185
186 /* Check cards status and waiting */
187
188 if (priv->waiting_command_mask & (ARLAN_COMMAND_LONG_WAIT_NOW | ARLAN_COMMAND_WAIT_NOW))
189 {
190 while (priv->waiting_command_mask & (ARLAN_COMMAND_LONG_WAIT_NOW | ARLAN_COMMAND_WAIT_NOW))
191 {
192 if (READSHMB(arlan->resetFlag) ||
193 READSHMB(arlan->commandByte)) /* ||
194 (readControlRegister(dev) & ARLAN_ACCESS))
195 */
196 udelay(40);
197 else
198 priv->waiting_command_mask &= ~(ARLAN_COMMAND_LONG_WAIT_NOW | ARLAN_COMMAND_WAIT_NOW);
199
200 udelayed++;
201
202 if (priv->waiting_command_mask & ARLAN_COMMAND_LONG_WAIT_NOW)
203 {
204 if (udelayed * 40 > 1000000)
205 {
206 printk(KERN_ERR "%s long wait too long \n", dev->name);
207 priv->waiting_command_mask |= ARLAN_COMMAND_RESET;
208 break;
209 }
210 }
211 else if (priv->waiting_command_mask & ARLAN_COMMAND_WAIT_NOW)
212 {
213 if (udelayed * 40 > 1000)
214 {
215 printk(KERN_ERR "%s short wait too long \n", dev->name);
216 goto bad_end;
217 }
218 }
219 }
220 }
221 else
222 {
223 i = 0;
224 while ((READSHMB(arlan->resetFlag) ||
225 READSHMB(arlan->commandByte)) &&
226 conf->pre_Command_Wait > (i++) * 10)
227 udelay(10);
228
229
230 if ((READSHMB(arlan->resetFlag) ||
231 READSHMB(arlan->commandByte)) &&
232 !(priv->waiting_command_mask & ARLAN_COMMAND_RESET))
233 {
234 goto card_busy_end;
235 }
236 }
237 if (priv->waiting_command_mask & ARLAN_COMMAND_RESET)
238 priv->under_reset = 1;
239 if (priv->waiting_command_mask & ARLAN_COMMAND_CONF)
240 priv->under_config = 1;
241
242 /* Issuing command */
243 arlan_lock_card_access(dev);
244 if (priv->waiting_command_mask & ARLAN_COMMAND_POWERUP)
245 {
246 // if (readControlRegister(dev) & (ARLAN_ACCESS && ARLAN_POWER))
247 setPowerOn(dev);
248 arlan_interrupt_lancpu(dev);
249 priv->waiting_command_mask &= ~ARLAN_COMMAND_POWERUP;
250 priv->waiting_command_mask |= ARLAN_COMMAND_RESET;
251 priv->card_polling_interval = HZ / 10;
252 }
253 else if (priv->waiting_command_mask & ARLAN_COMMAND_ACTIVATE)
254 {
255 WRITESHMB(arlan->commandByte, ARLAN_COM_ACTIVATE);
256 arlan_interrupt_lancpu(dev);
257 priv->waiting_command_mask &= ~ARLAN_COMMAND_ACTIVATE;
258 priv->card_polling_interval = HZ / 10;
259 }
260 else if (priv->waiting_command_mask & ARLAN_COMMAND_RX_ABORT)
261 {
262 if (priv->rx_command_given)
263 {
264 WRITESHMB(arlan->commandByte, ARLAN_COM_RX_ABORT);
265 arlan_interrupt_lancpu(dev);
266 priv->rx_command_given = 0;
267 }
268 priv->waiting_command_mask &= ~ARLAN_COMMAND_RX_ABORT;
269 priv->card_polling_interval = 1;
270 }
271 else if (priv->waiting_command_mask & ARLAN_COMMAND_TX_ABORT)
272 {
273 if (priv->tx_command_given)
274 {
275 WRITESHMB(arlan->commandByte, ARLAN_COM_TX_ABORT);
276 arlan_interrupt_lancpu(dev);
277 priv->tx_command_given = 0;
278 }
279 priv->waiting_command_mask &= ~ARLAN_COMMAND_TX_ABORT;
280 priv->card_polling_interval = 1;
281 }
282 else if (priv->waiting_command_mask & ARLAN_COMMAND_RESET)
283 {
284 priv->under_reset=1;
285 netif_stop_queue (dev);
286
287 arlan_drop_tx(dev);
288 if (priv->tx_command_given || priv->rx_command_given)
289 {
290 printk(KERN_ERR "%s: Reset under tx or rx command \n", dev->name);
291 }
292 netif_stop_queue (dev);
293 if (arlan_debug & ARLAN_DEBUG_RESET)
294 printk(KERN_ERR "%s: Doing chip reset\n", dev->name);
295 priv->lastReset = jiffies;
296 WRITESHM(arlan->commandByte, 0, u_char);
297 /* hold card in reset state */
298 setHardwareReset(dev);
299 /* set reset flag and then release reset */
300 WRITESHM(arlan->resetFlag, 0xff, u_char);
301 clearChannelAttention(dev);
302 clearHardwareReset(dev);
303 priv->card_polling_interval = HZ / 4;
304 priv->waiting_command_mask &= ~ARLAN_COMMAND_RESET;
305 priv->waiting_command_mask |= ARLAN_COMMAND_INT_RACK;
306// priv->waiting_command_mask |= ARLAN_COMMAND_INT_RENABLE;
307// priv->waiting_command_mask |= ARLAN_COMMAND_RX;
308 }
309 else if (priv->waiting_command_mask & ARLAN_COMMAND_INT_RACK)
310 {
311 clearHardwareReset(dev);
312 clearClearInterrupt(dev);
313 setClearInterrupt(dev);
314 setInterruptEnable(dev);
315 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_RACK;
316 priv->waiting_command_mask |= ARLAN_COMMAND_CONF;
317 priv->under_config = 1;
318 priv->under_reset = 0;
319 }
320 else if (priv->waiting_command_mask & ARLAN_COMMAND_INT_RENABLE)
321 {
322 setInterruptEnable(dev);
323 priv->waiting_command_mask &= ~ARLAN_COMMAND_INT_RENABLE;
324 }
325 else if (priv->waiting_command_mask & ARLAN_COMMAND_CONF)
326 {
327 if (priv->tx_command_given || priv->rx_command_given)
328 {
329 printk(KERN_ERR "%s: Reset under tx or rx command \n", dev->name);
330 }
331 arlan_drop_tx(dev);
332 setInterruptEnable(dev);
333 arlan_hw_config(dev);
334 arlan_interrupt_lancpu(dev);
335 priv->waiting_command_mask &= ~ARLAN_COMMAND_CONF;
336 priv->card_polling_interval = HZ / 10;
337// priv->waiting_command_mask |= ARLAN_COMMAND_INT_RACK;
338// priv->waiting_command_mask |= ARLAN_COMMAND_INT_ENABLE;
339 priv->waiting_command_mask |= ARLAN_COMMAND_CONF_WAIT;
340 }
341 else if (priv->waiting_command_mask & ARLAN_COMMAND_CONF_WAIT)
342 {
343 if (READSHMB(arlan->configuredStatusFlag) != 0 &&
344 READSHMB(arlan->diagnosticInfo) == 0xff)
345 {
346 priv->waiting_command_mask &= ~ARLAN_COMMAND_CONF_WAIT;
347 priv->waiting_command_mask |= ARLAN_COMMAND_RX;
348 priv->waiting_command_mask |= ARLAN_COMMAND_TBUSY_CLEAR;
349 priv->card_polling_interval = HZ / 10;
350 priv->tx_command_given = 0;
351 priv->under_config = 0;
352 }
353 else
354 {
355 priv->card_polling_interval = 1;
356 if (arlan_debug & ARLAN_DEBUG_TIMING)
357 printk(KERN_ERR "configure delayed \n");
358 }
359 }
360 else if (priv->waiting_command_mask & ARLAN_COMMAND_RX)
361 {
362 if (!registrationBad(dev))
363 {
364 setInterruptEnable(dev);
365 memset_io(arlan->commandParameter, 0, 0xf);
366 WRITESHMB(arlan->commandByte, ARLAN_COM_INT | ARLAN_COM_RX_ENABLE);
367 WRITESHMB(arlan->commandParameter[0], conf->rxParameter);
368 arlan_interrupt_lancpu(dev);
369 priv->rx_command_given = 0; // mnjah, bad
370 priv->waiting_command_mask &= ~ARLAN_COMMAND_RX;
371 priv->card_polling_interval = 1;
372 }
373 else
374 priv->card_polling_interval = 2;
375 }
376 else if (priv->waiting_command_mask & ARLAN_COMMAND_TBUSY_CLEAR)
377 {
378 if ( !registrationBad(dev) &&
379 (netif_queue_stopped(dev) || !netif_running(dev)) )
380 {
381 priv->waiting_command_mask &= ~ARLAN_COMMAND_TBUSY_CLEAR;
382 netif_wake_queue (dev);
383 }
384 }
385 else if (priv->waiting_command_mask & ARLAN_COMMAND_TX)
386 {
387 if (!test_and_set_bit(0, (void *) &priv->tx_command_given))
388 {
389 if (time_after(jiffies,
390 priv->tx_last_sent + us2ticks(conf->rx_tweak1))
391 || time_before(jiffies,
392 priv->last_rx_int_ack_time + us2ticks(conf->rx_tweak2)))
393 {
394 setInterruptEnable(dev);
395 memset_io(arlan->commandParameter, 0, 0xf);
396 WRITESHMB(arlan->commandByte, ARLAN_COM_TX_ENABLE | ARLAN_COM_INT);
397 memcpy_toio(arlan->commandParameter, &TXLAST(dev), 14);
398// for ( i=1 ; i < 15 ; i++) printk("%02x:",READSHMB(arlan->commandParameter[i]));
399 priv->tx_last_sent = jiffies;
400 arlan_interrupt_lancpu(dev);
401 priv->tx_command_given = 1;
402 priv->waiting_command_mask &= ~ARLAN_COMMAND_TX;
403 priv->card_polling_interval = 1;
404 }
405 else
406 {
407 priv->tx_command_given = 0;
408 priv->card_polling_interval = 1;
409 }
410 }
411 else if (arlan_debug & ARLAN_DEBUG_CHAIN_LOCKS)
412 printk(KERN_ERR "tx command when tx chain locked \n");
413 }
414 else if (priv->waiting_command_mask & ARLAN_COMMAND_NOOPINT)
415 {
416 {
417 WRITESHMB(arlan->commandByte, ARLAN_COM_NOP | ARLAN_COM_INT);
418 }
419 arlan_interrupt_lancpu(dev);
420 priv->waiting_command_mask &= ~ARLAN_COMMAND_NOOPINT;
421 priv->card_polling_interval = HZ / 3;
422 }
423 else if (priv->waiting_command_mask & ARLAN_COMMAND_NOOP)
424 {
425 WRITESHMB(arlan->commandByte, ARLAN_COM_NOP);
426 arlan_interrupt_lancpu(dev);
427 priv->waiting_command_mask &= ~ARLAN_COMMAND_NOOP;
428 priv->card_polling_interval = HZ / 3;
429 }
430 else if (priv->waiting_command_mask & ARLAN_COMMAND_SLOW_POLL)
431 {
432 WRITESHMB(arlan->commandByte, ARLAN_COM_GOTO_SLOW_POLL);
433 arlan_interrupt_lancpu(dev);
434 priv->waiting_command_mask &= ~ARLAN_COMMAND_SLOW_POLL;
435 priv->card_polling_interval = HZ / 3;
436 }
437 else if (priv->waiting_command_mask & ARLAN_COMMAND_POWERDOWN)
438 {
439 setPowerOff(dev);
440 if (arlan_debug & ARLAN_DEBUG_CARD_STATE)
441 printk(KERN_WARNING "%s: Arlan Going Standby\n", dev->name);
442 priv->waiting_command_mask &= ~ARLAN_COMMAND_POWERDOWN;
443 priv->card_polling_interval = 3 * HZ;
444 }
445 arlan_unlock_card_access(dev);
446 for (i = 0; READSHMB(arlan->commandByte) && i < 20; i++)
447 udelay(10);
448 if (READSHMB(arlan->commandByte))
449 if (arlan_debug & ARLAN_DEBUG_CARD_STATE)
450 printk(KERN_ERR "card busy leaving command %lx\n", priv->waiting_command_mask);
451
452 spin_unlock_irqrestore(&priv->lock, flags);
453 ARLAN_DEBUG_EXIT("arlan_command");
454 priv->last_command_buff_free_time = jiffies;
455 return 0;
456
457card_busy_end:
458 if (time_after(jiffies, priv->last_command_buff_free_time + HZ))
459 priv->waiting_command_mask |= ARLAN_COMMAND_CLEAN_AND_RESET;
460
461 if (arlan_debug & ARLAN_DEBUG_CARD_STATE)
462 printk(KERN_ERR "%s arlan_command card busy end \n", dev->name);
463 spin_unlock_irqrestore(&priv->lock, flags);
464 ARLAN_DEBUG_EXIT("arlan_command");
465 return 1;
466
467bad_end:
468 printk(KERN_ERR "%s arlan_command bad end \n", dev->name);
469
470 spin_unlock_irqrestore(&priv->lock, flags);
471 ARLAN_DEBUG_EXIT("arlan_command");
472
473 return -1;
474}
475
476static inline void arlan_command_process(struct net_device *dev)
477{
478 struct arlan_private *priv = netdev_priv(dev);
479
480 int times = 0;
481 while (priv->waiting_command_mask && times < 8)
482 {
483 if (priv->waiting_command_mask)
484 {
485 if (arlan_command(dev, 0))
486 break;
487 times++;
488 }
489 /* if long command, we won't repeat trying */ ;
490 if (priv->card_polling_interval > 1)
491 break;
492 times++;
493 }
494}
495
496
497static inline void arlan_retransmit_now(struct net_device *dev)
498{
499 struct arlan_private *priv = netdev_priv(dev);
500
501
502 ARLAN_DEBUG_ENTRY("arlan_retransmit_now");
503 if (TXLAST(dev).offset == 0)
504 {
505 if (TXHEAD(dev).offset)
506 {
507 priv->txLast = 0;
508 IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_DEBUG "TX buff switch to head \n");
509
510 }
511 else if (TXTAIL(dev).offset)
512 {
513 IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_DEBUG "TX buff switch to tail \n");
514 priv->txLast = 1;
515 }
516 else
517 IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_ERR "ReTransmit buff empty");
518 netif_wake_queue (dev);
519 return;
520
521 }
522 arlan_command(dev, ARLAN_COMMAND_TX);
523
524 priv->Conf->driverRetransmissions++;
525 priv->retransmissions++;
526
527 IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk("Retransmit %d bytes \n", TXLAST(dev).length);
528
529 ARLAN_DEBUG_EXIT("arlan_retransmit_now");
530}
531
532
533
534static void arlan_registration_timer(unsigned long data)
535{
536 struct net_device *dev = (struct net_device *) data;
537 struct arlan_private *priv = netdev_priv(dev);
538 int bh_mark_needed = 0;
539 int next_tick = 1;
540 long lostTime = ((long)jiffies - (long)priv->registrationLastSeen)
541 * (1000/HZ);
542
543 if (registrationBad(dev))
544 {
545 priv->registrationLostCount++;
546 if (lostTime > 7000 && lostTime < 7200)
547 {
548 printk(KERN_NOTICE "%s registration Lost \n", dev->name);
549 }
550 if (lostTime / priv->reRegisterExp > 2000)
551 arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_CONF);
552 if (lostTime / (priv->reRegisterExp) > 3500)
553 arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
554 if (priv->reRegisterExp < 400)
555 priv->reRegisterExp += 2;
556 if (lostTime > 7200)
557 {
558 next_tick = HZ;
559 arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
560 }
561 }
562 else
563 {
564 if (priv->Conf->registrationMode && lostTime > 10000 &&
565 priv->registrationLostCount)
566 {
567 printk(KERN_NOTICE "%s registration is back after %ld milliseconds\n",
568 dev->name, lostTime);
569 }
570 priv->registrationLastSeen = jiffies;
571 priv->registrationLostCount = 0;
572 priv->reRegisterExp = 1;
573 if (!netif_running(dev) )
574 netif_wake_queue(dev);
575 if (time_after(priv->tx_last_sent,priv->tx_last_cleared) &&
576 time_after(jiffies, priv->tx_last_sent * 5*HZ) ){
577 arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
578 priv->tx_last_cleared = jiffies;
579 }
580 }
581
582
583 if (!registrationBad(dev) && priv->ReTransmitRequested)
584 {
585 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
586 printk(KERN_ERR "Retransmit from timer \n");
587 priv->ReTransmitRequested = 0;
588 arlan_retransmit_now(dev);
589 }
590 if (!registrationBad(dev) &&
591 time_after(jiffies, priv->tx_done_delayed) &&
592 priv->tx_done_delayed != 0)
593 {
594 TXLAST(dev).offset = 0;
595 if (priv->txLast)
596 priv->txLast = 0;
597 else if (TXTAIL(dev).offset)
598 priv->txLast = 1;
599 if (TXLAST(dev).offset)
600 {
601 arlan_retransmit_now(dev);
602 dev->trans_start = jiffies;
603 }
604 if (!(TXHEAD(dev).offset && TXTAIL(dev).offset))
605 {
606 netif_wake_queue (dev);
607 }
608 priv->tx_done_delayed = 0;
609 bh_mark_needed = 1;
610 }
611 if (bh_mark_needed)
612 {
613 netif_wake_queue (dev);
614 }
615 arlan_process_interrupt(dev);
616
617 if (next_tick < priv->card_polling_interval)
618 next_tick = priv->card_polling_interval;
619
620 priv->timer.expires = jiffies + next_tick;
621
622 add_timer(&priv->timer);
623}
624
625
626#ifdef ARLAN_DEBUGGING
627
628static void arlan_print_registers(struct net_device *dev, int line)
629{
630 struct arlan_private *priv = netdev_priv(dev);
631 volatile struct arlan_shmem *arlan = priv->card;
632
633 u_char hostcpuLock, lancpuLock, controlRegister, cntrlRegImage,
634 txStatus, rxStatus, interruptInProgress, commandByte;
635
636
637 ARLAN_DEBUG_ENTRY("arlan_print_registers");
638 READSHM(interruptInProgress, arlan->interruptInProgress, u_char);
639 READSHM(hostcpuLock, arlan->hostcpuLock, u_char);
640 READSHM(lancpuLock, arlan->lancpuLock, u_char);
641 READSHM(controlRegister, arlan->controlRegister, u_char);
642 READSHM(cntrlRegImage, arlan->cntrlRegImage, u_char);
643 READSHM(txStatus, arlan->txStatus, u_char);
644 READSHM(rxStatus, arlan->rxStatus, u_char);
645 READSHM(commandByte, arlan->commandByte, u_char);
646
647 printk(KERN_WARNING "line %04d IP %02x HL %02x LL %02x CB %02x CR %02x CRI %02x TX %02x RX %02x\n",
648 line, interruptInProgress, hostcpuLock, lancpuLock, commandByte,
649 controlRegister, cntrlRegImage, txStatus, rxStatus);
650
651 ARLAN_DEBUG_EXIT("arlan_print_registers");
652}
653#endif
654
655
656static int arlan_hw_tx(struct net_device *dev, char *buf, int length)
657{
658 int i;
659
660 struct arlan_private *priv = netdev_priv(dev);
661 volatile struct arlan_shmem __iomem *arlan = priv->card;
662 struct arlan_conf_stru *conf = priv->Conf;
663
664 int tailStarts = 0x800;
665 int headEnds = 0x0;
666
667
668 ARLAN_DEBUG_ENTRY("arlan_hw_tx");
669 if (TXHEAD(dev).offset)
670 headEnds = (((TXHEAD(dev).offset + TXHEAD(dev).length - offsetof(struct arlan_shmem, txBuffer)) / 64) + 1) * 64;
671 if (TXTAIL(dev).offset)
672 tailStarts = 0x800 - (((TXTAIL(dev).offset - offsetof(struct arlan_shmem, txBuffer)) / 64) + 2) * 64;
673
674
675 if (!TXHEAD(dev).offset && length < tailStarts)
676 {
677 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
678 printk(KERN_ERR "TXHEAD insert, tailStart %d\n", tailStarts);
679
680 TXHEAD(dev).offset =
681 offsetof(struct arlan_shmem, txBuffer);
682 TXHEAD(dev).length = length - ARLAN_FAKE_HDR_LEN;
683 for (i = 0; i < 6; i++)
684 TXHEAD(dev).dest[i] = buf[i];
685 TXHEAD(dev).clear = conf->txClear;
686 TXHEAD(dev).retries = conf->txRetries; /* 0 is use default */
687 TXHEAD(dev).routing = conf->txRouting;
688 TXHEAD(dev).scrambled = conf->txScrambled;
689 memcpy_toio((char __iomem *)arlan + TXHEAD(dev).offset, buf + ARLAN_FAKE_HDR_LEN, TXHEAD(dev).length);
690 }
691 else if (!TXTAIL(dev).offset && length < (0x800 - headEnds))
692 {
693 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
694 printk(KERN_ERR "TXTAIL insert, headEnd %d\n", headEnds);
695
696 TXTAIL(dev).offset =
697 offsetof(struct arlan_shmem, txBuffer) + 0x800 - (length / 64 + 2) * 64;
698 TXTAIL(dev).length = length - ARLAN_FAKE_HDR_LEN;
699 for (i = 0; i < 6; i++)
700 TXTAIL(dev).dest[i] = buf[i];
701 TXTAIL(dev).clear = conf->txClear;
702 TXTAIL(dev).retries = conf->txRetries;
703 TXTAIL(dev).routing = conf->txRouting;
704 TXTAIL(dev).scrambled = conf->txScrambled;
705 memcpy_toio(((char __iomem *)arlan + TXTAIL(dev).offset), buf + ARLAN_FAKE_HDR_LEN, TXTAIL(dev).length);
706 }
707 else
708 {
709 netif_stop_queue (dev);
710 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
711 printk(KERN_ERR "TX TAIL & HEAD full, return, tailStart %d headEnd %d\n", tailStarts, headEnds);
712 return -1;
713 }
714 priv->out_bytes += length;
715 priv->out_bytes10 += length;
716 if (conf->measure_rate < 1)
717 conf->measure_rate = 1;
718 if (time_after(jiffies, priv->out_time + conf->measure_rate * HZ))
719 {
720 conf->out_speed = priv->out_bytes / conf->measure_rate;
721 priv->out_bytes = 0;
722 priv->out_time = jiffies;
723 }
724 if (time_after(jiffies, priv->out_time10 + conf->measure_rate * 10*HZ))
725 {
726 conf->out_speed10 = priv->out_bytes10 / (10 * conf->measure_rate);
727 priv->out_bytes10 = 0;
728 priv->out_time10 = jiffies;
729 }
730 if (TXHEAD(dev).offset && TXTAIL(dev).offset)
731 {
732 netif_stop_queue (dev);
733 return 0;
734 }
735 else
736 netif_start_queue (dev);
737
738
739 IFDEBUG(ARLAN_DEBUG_HEADER_DUMP)
740 printk(KERN_WARNING "%s Transmit t %2x:%2x:%2x:%2x:%2x:%2x f %2x:%2x:%2x:%2x:%2x:%2x \n", dev->name,
741 (unsigned char) buf[0], (unsigned char) buf[1], (unsigned char) buf[2], (unsigned char) buf[3],
742 (unsigned char) buf[4], (unsigned char) buf[5], (unsigned char) buf[6], (unsigned char) buf[7],
743 (unsigned char) buf[8], (unsigned char) buf[9], (unsigned char) buf[10], (unsigned char) buf[11]);
744
745 IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk(KERN_ERR "TX command prepare for buffer %d\n", priv->txLast);
746
747 arlan_command(dev, ARLAN_COMMAND_TX);
748
749 priv->tx_last_sent = jiffies;
750
751 IFDEBUG(ARLAN_DEBUG_TX_CHAIN) printk("%s TX Qued %d bytes \n", dev->name, length);
752
753 ARLAN_DEBUG_EXIT("arlan_hw_tx");
754
755 return 0;
756}
757
758
759static int arlan_hw_config(struct net_device *dev)
760{
761 struct arlan_private *priv = netdev_priv(dev);
762 volatile struct arlan_shmem __iomem *arlan = priv->card;
763 struct arlan_conf_stru *conf = priv->Conf;
764
765 ARLAN_DEBUG_ENTRY("arlan_hw_config");
766
767 printk(KERN_NOTICE "%s arlan configure called \n", dev->name);
768 if (arlan_EEPROM_bad)
769 printk(KERN_NOTICE "arlan configure with eeprom bad option \n");
770
771
772 WRITESHM(arlan->spreadingCode, conf->spreadingCode, u_char);
773 WRITESHM(arlan->channelSet, conf->channelSet, u_char);
774
775 if (arlan_EEPROM_bad)
776 WRITESHM(arlan->defaultChannelSet, conf->channelSet, u_char);
777
778 WRITESHM(arlan->channelNumber, conf->channelNumber, u_char);
779
780 WRITESHM(arlan->scramblingDisable, conf->scramblingDisable, u_char);
781 WRITESHM(arlan->txAttenuation, conf->txAttenuation, u_char);
782
783 WRITESHM(arlan->systemId, conf->systemId, u_int);
784
785 WRITESHM(arlan->maxRetries, conf->maxRetries, u_char);
786 WRITESHM(arlan->receiveMode, conf->receiveMode, u_char);
787 WRITESHM(arlan->priority, conf->priority, u_char);
788 WRITESHM(arlan->rootOrRepeater, conf->rootOrRepeater, u_char);
789 WRITESHM(arlan->SID, conf->SID, u_int);
790
791 WRITESHM(arlan->registrationMode, conf->registrationMode, u_char);
792
793 WRITESHM(arlan->registrationFill, conf->registrationFill, u_char);
794 WRITESHM(arlan->localTalkAddress, conf->localTalkAddress, u_char);
795 WRITESHM(arlan->codeFormat, conf->codeFormat, u_char);
796 WRITESHM(arlan->numChannels, conf->numChannels, u_char);
797 WRITESHM(arlan->channel1, conf->channel1, u_char);
798 WRITESHM(arlan->channel2, conf->channel2, u_char);
799 WRITESHM(arlan->channel3, conf->channel3, u_char);
800 WRITESHM(arlan->channel4, conf->channel4, u_char);
801 WRITESHM(arlan->radioNodeId, conf->radioNodeId, u_short);
802 WRITESHM(arlan->SID, conf->SID, u_int);
803 WRITESHM(arlan->waitTime, conf->waitTime, u_short);
804 WRITESHM(arlan->lParameter, conf->lParameter, u_short);
805 memcpy_toio(&(arlan->_15), &(conf->_15), 3);
806 WRITESHM(arlan->_15, conf->_15, u_short);
807 WRITESHM(arlan->headerSize, conf->headerSize, u_short);
808 if (arlan_EEPROM_bad)
809 WRITESHM(arlan->hardwareType, conf->hardwareType, u_char);
810 WRITESHM(arlan->radioType, conf->radioType, u_char);
811 if (arlan_EEPROM_bad)
812 WRITESHM(arlan->radioModule, conf->radioType, u_char);
813
814 memcpy_toio(arlan->encryptionKey + keyStart, encryptionKey, 8);
815 memcpy_toio(arlan->name, conf->siteName, 16);
816
817 WRITESHMB(arlan->commandByte, ARLAN_COM_INT | ARLAN_COM_CONF); /* do configure */
818 memset_io(arlan->commandParameter, 0, 0xf); /* 0xf */
819 memset_io(arlan->commandParameter + 1, 0, 2);
820 if (conf->writeEEPROM)
821 {
822 memset_io(arlan->commandParameter, conf->writeEEPROM, 1);
823// conf->writeEEPROM=0;
824 }
825 if (conf->registrationMode && conf->registrationInterrupts)
826 memset_io(arlan->commandParameter + 3, 1, 1);
827 else
828 memset_io(arlan->commandParameter + 3, 0, 1);
829
830 priv->irq_test_done = 0;
831
832 if (conf->tx_queue_len)
833 dev->tx_queue_len = conf->tx_queue_len;
834 udelay(100);
835
836 ARLAN_DEBUG_EXIT("arlan_hw_config");
837 return 0;
838}
839
840
841static int arlan_read_card_configuration(struct net_device *dev)
842{
843 u_char tlx415;
844 struct arlan_private *priv = netdev_priv(dev);
845 volatile struct arlan_shmem __iomem *arlan = priv->card;
846 struct arlan_conf_stru *conf = priv->Conf;
847
848 ARLAN_DEBUG_ENTRY("arlan_read_card_configuration");
849
850 if (radioNodeId == radioNodeIdUNKNOWN)
851 {
852 READSHM(conf->radioNodeId, arlan->radioNodeId, u_short);
853 }
854 else
855 conf->radioNodeId = radioNodeId;
856
857 if (SID == SIDUNKNOWN)
858 {
859 READSHM(conf->SID, arlan->SID, u_int);
860 }
861 else conf->SID = SID;
862
863 if (spreadingCode == spreadingCodeUNKNOWN)
864 {
865 READSHM(conf->spreadingCode, arlan->spreadingCode, u_char);
866 }
867 else
868 conf->spreadingCode = spreadingCode;
869
870 if (channelSet == channelSetUNKNOWN)
871 {
872 READSHM(conf->channelSet, arlan->channelSet, u_char);
873 }
874 else conf->channelSet = channelSet;
875
876 if (channelNumber == channelNumberUNKNOWN)
877 {
878 READSHM(conf->channelNumber, arlan->channelNumber, u_char);
879 }
880 else conf->channelNumber = channelNumber;
881
882 READSHM(conf->scramblingDisable, arlan->scramblingDisable, u_char);
883 READSHM(conf->txAttenuation, arlan->txAttenuation, u_char);
884
885 if (systemId == systemIdUNKNOWN)
886 {
887 READSHM(conf->systemId, arlan->systemId, u_int);
888 }
889 else conf->systemId = systemId;
890
891 READSHM(conf->maxDatagramSize, arlan->maxDatagramSize, u_short);
892 READSHM(conf->maxFrameSize, arlan->maxFrameSize, u_short);
893 READSHM(conf->maxRetries, arlan->maxRetries, u_char);
894 READSHM(conf->receiveMode, arlan->receiveMode, u_char);
895 READSHM(conf->priority, arlan->priority, u_char);
896 READSHM(conf->rootOrRepeater, arlan->rootOrRepeater, u_char);
897
898 if (SID == SIDUNKNOWN)
899 {
900 READSHM(conf->SID, arlan->SID, u_int);
901 }
902 else conf->SID = SID;
903
904 if (registrationMode == registrationModeUNKNOWN)
905 {
906 READSHM(conf->registrationMode, arlan->registrationMode, u_char);
907 }
908 else conf->registrationMode = registrationMode;
909
910 READSHM(conf->registrationFill, arlan->registrationFill, u_char);
911 READSHM(conf->localTalkAddress, arlan->localTalkAddress, u_char);
912 READSHM(conf->codeFormat, arlan->codeFormat, u_char);
913 READSHM(conf->numChannels, arlan->numChannels, u_char);
914 READSHM(conf->channel1, arlan->channel1, u_char);
915 READSHM(conf->channel2, arlan->channel2, u_char);
916 READSHM(conf->channel3, arlan->channel3, u_char);
917 READSHM(conf->channel4, arlan->channel4, u_char);
918 READSHM(conf->waitTime, arlan->waitTime, u_short);
919 READSHM(conf->lParameter, arlan->lParameter, u_short);
920 READSHM(conf->_15, arlan->_15, u_short);
921 READSHM(conf->headerSize, arlan->headerSize, u_short);
922 READSHM(conf->hardwareType, arlan->hardwareType, u_char);
923 READSHM(conf->radioType, arlan->radioModule, u_char);
924
925 if (conf->radioType == 0)
926 conf->radioType = 0xc;
927
928 WRITESHM(arlan->configStatus, 0xA5, u_char);
929 READSHM(tlx415, arlan->configStatus, u_char);
930
931 if (tlx415 != 0xA5)
932 printk(KERN_INFO "%s tlx415 chip \n", dev->name);
933
934 conf->txClear = 0;
935 conf->txRetries = 1;
936 conf->txRouting = 1;
937 conf->txScrambled = 0;
938 conf->rxParameter = 1;
939 conf->txTimeoutMs = 4000;
940 conf->waitCardTimeout = 100000;
941 conf->receiveMode = ARLAN_RCV_CLEAN;
942 memcpy_fromio(conf->siteName, arlan->name, 16);
943 conf->siteName[16] = '\0';
944 conf->retries = retries;
945 conf->tx_delay_ms = tx_delay_ms;
946 conf->ReTransmitPacketMaxSize = 200;
947 conf->waitReTransmitPacketMaxSize = 200;
948 conf->txAckTimeoutMs = 900;
949 conf->fastReTransCount = 3;
950
951 ARLAN_DEBUG_EXIT("arlan_read_card_configuration");
952
953 return 0;
954}
955
956
957static int lastFoundAt = 0xbe000;
958
959
960/*
961 * This is the real probe routine. Linux has a history of friendly device
962 * probes on the ISA bus. A good device probes avoids doing writes, and
963 * verifies that the correct device exists and functions.
964 */
965#define ARLAN_SHMEM_SIZE 0x2000
966static int __init arlan_check_fingerprint(unsigned long memaddr)
967{
968 static const char probeText[] = "TELESYSTEM SLW INC. ARLAN \0";
969 volatile struct arlan_shmem __iomem *arlan = (struct arlan_shmem *) memaddr;
970 unsigned long paddr = virt_to_phys((void *) memaddr);
971 char tempBuf[49];
972
973 ARLAN_DEBUG_ENTRY("arlan_check_fingerprint");
974
975 if (!request_mem_region(paddr, ARLAN_SHMEM_SIZE, "arlan")) {
976 // printk(KERN_WARNING "arlan: memory region %lx excluded from probing \n",paddr);
977 return -ENODEV;
978 }
979
980 memcpy_fromio(tempBuf, arlan->textRegion, 29);
981 tempBuf[30] = 0;
982
983 /* check for card at this address */
984 if (0 != strncmp(tempBuf, probeText, 29)){
985 release_mem_region(paddr, ARLAN_SHMEM_SIZE);
986 return -ENODEV;
987 }
988
989// printk(KERN_INFO "arlan found at 0x%x \n",memaddr);
990 ARLAN_DEBUG_EXIT("arlan_check_fingerprint");
991
992 return 0;
993}
994
995static int arlan_change_mtu(struct net_device *dev, int new_mtu)
996{
997 struct arlan_private *priv = netdev_priv(dev);
998 struct arlan_conf_stru *conf = priv->Conf;
999
1000 ARLAN_DEBUG_ENTRY("arlan_change_mtu");
1001 if (new_mtu > 2032)
1002 return -EINVAL;
1003 dev->mtu = new_mtu;
1004 if (new_mtu < 256)
1005 new_mtu = 256; /* cards book suggests 1600 */
1006 conf->maxDatagramSize = new_mtu;
1007 conf->maxFrameSize = new_mtu + 48;
1008
1009 arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_CONF);
1010 printk(KERN_NOTICE "%s mtu changed to %d \n", dev->name, new_mtu);
1011
1012 ARLAN_DEBUG_EXIT("arlan_change_mtu");
1013
1014 return 0;
1015}
1016
1017static int arlan_mac_addr(struct net_device *dev, void *p)
1018{
1019 struct sockaddr *addr = p;
1020
1021
1022 ARLAN_DEBUG_ENTRY("arlan_mac_addr");
1023 return -EINVAL;
1024
1025 if (netif_running(dev))
1026 return -EBUSY;
1027 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1028
1029 ARLAN_DEBUG_EXIT("arlan_mac_addr");
1030 return 0;
1031}
1032
1033static const struct net_device_ops arlan_netdev_ops = {
1034 .ndo_open = arlan_open,
1035 .ndo_stop = arlan_close,
1036 .ndo_start_xmit = arlan_tx,
1037 .ndo_get_stats = arlan_statistics,
1038 .ndo_set_multicast_list = arlan_set_multicast,
1039 .ndo_change_mtu = arlan_change_mtu,
1040 .ndo_set_mac_address = arlan_mac_addr,
1041 .ndo_tx_timeout = arlan_tx_timeout,
1042 .ndo_validate_addr = eth_validate_addr,
1043};
1044
1045static int __init arlan_setup_device(struct net_device *dev, int num)
1046{
1047 struct arlan_private *ap = netdev_priv(dev);
1048 int err;
1049
1050 ARLAN_DEBUG_ENTRY("arlan_setup_device");
1051
1052 ap->conf = (struct arlan_shmem *)(ap+1);
1053
1054 dev->tx_queue_len = tx_queue_len;
1055 dev->netdev_ops = &arlan_netdev_ops;
1056 dev->watchdog_timeo = 3*HZ;
1057
1058 ap->irq_test_done = 0;
1059 ap->Conf = &arlan_conf[num];
1060
1061 ap->Conf->pre_Command_Wait = 40;
1062 ap->Conf->rx_tweak1 = 30;
1063 ap->Conf->rx_tweak2 = 0;
1064
1065
1066 err = register_netdev(dev);
1067 if (err) {
1068 release_mem_region(virt_to_phys((void *) dev->mem_start),
1069 ARLAN_SHMEM_SIZE);
1070 free_netdev(dev);
1071 return err;
1072 }
1073 arlan_device[num] = dev;
1074 ARLAN_DEBUG_EXIT("arlan_setup_device");
1075 return 0;
1076}
1077
1078static int __init arlan_probe_here(struct net_device *dev,
1079 unsigned long memaddr)
1080{
1081 struct arlan_private *ap = netdev_priv(dev);
1082
1083 ARLAN_DEBUG_ENTRY("arlan_probe_here");
1084
1085 if (arlan_check_fingerprint(memaddr))
1086 return -ENODEV;
1087
1088 printk(KERN_NOTICE "%s: Arlan found at %llx, \n ", dev->name,
1089 (u64) virt_to_phys((void*)memaddr));
1090
1091 ap->card = (void *) memaddr;
1092 dev->mem_start = memaddr;
1093 dev->mem_end = memaddr + ARLAN_SHMEM_SIZE-1;
1094
1095 if (dev->irq < 2)
1096 {
1097 READSHM(dev->irq, ap->card->irqLevel, u_char);
1098 } else if (dev->irq == 2)
1099 dev->irq = 9;
1100
1101 arlan_read_card_configuration(dev);
1102
1103 ARLAN_DEBUG_EXIT("arlan_probe_here");
1104 return 0;
1105}
1106
1107
1108static int arlan_open(struct net_device *dev)
1109{
1110 struct arlan_private *priv = netdev_priv(dev);
1111 volatile struct arlan_shmem __iomem *arlan = priv->card;
1112 int ret = 0;
1113
1114 ARLAN_DEBUG_ENTRY("arlan_open");
1115
1116 ret = request_irq(dev->irq, &arlan_interrupt, 0, dev->name, dev);
1117 if (ret)
1118 {
1119 printk(KERN_ERR "%s: unable to get IRQ %d .\n",
1120 dev->name, dev->irq);
1121 return ret;
1122 }
1123
1124
1125 priv->bad = 0;
1126 priv->lastReset = 0;
1127 priv->reset = 0;
1128 memcpy_fromio(dev->dev_addr, arlan->lanCardNodeId, 6);
1129 memset(dev->broadcast, 0xff, 6);
1130 dev->tx_queue_len = tx_queue_len;
1131 priv->interrupt_processing_active = 0;
1132 spin_lock_init(&priv->lock);
1133
1134 netif_start_queue (dev);
1135
1136 priv->registrationLostCount = 0;
1137 priv->registrationLastSeen = jiffies;
1138 priv->txLast = 0;
1139 priv->tx_command_given = 0;
1140 priv->rx_command_given = 0;
1141
1142 priv->reRegisterExp = 1;
1143 priv->tx_last_sent = jiffies - 1;
1144 priv->tx_last_cleared = jiffies;
1145 priv->Conf->writeEEPROM = 0;
1146 priv->Conf->registrationInterrupts = 1;
1147
1148 init_timer(&priv->timer);
1149 priv->timer.expires = jiffies + HZ / 10;
1150 priv->timer.data = (unsigned long) dev;
1151 priv->timer.function = &arlan_registration_timer; /* timer handler */
1152
1153 arlan_command(dev, ARLAN_COMMAND_POWERUP | ARLAN_COMMAND_LONG_WAIT_NOW);
1154 mdelay(200);
1155 add_timer(&priv->timer);
1156
1157 ARLAN_DEBUG_EXIT("arlan_open");
1158 return 0;
1159}
1160
1161
1162static void arlan_tx_timeout (struct net_device *dev)
1163{
1164 printk(KERN_ERR "%s: arlan transmit timed out, kernel decided\n", dev->name);
1165 /* Try to restart the adaptor. */
1166 arlan_command(dev, ARLAN_COMMAND_CLEAN_AND_RESET);
1167 // dev->trans_start = jiffies;
1168 // netif_start_queue (dev);
1169}
1170
1171
1172static netdev_tx_t arlan_tx(struct sk_buff *skb, struct net_device *dev)
1173{
1174 short length;
1175 unsigned char *buf;
1176
1177 ARLAN_DEBUG_ENTRY("arlan_tx");
1178
1179 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1180 buf = skb->data;
1181
1182 if (length + 0x12 > 0x800) {
1183 printk(KERN_ERR "TX RING overflow \n");
1184 netif_stop_queue (dev);
1185 }
1186
1187 if (arlan_hw_tx(dev, buf, length) == -1)
1188 goto bad_end;
1189
1190 dev->trans_start = jiffies;
1191
1192 dev_kfree_skb(skb);
1193
1194 arlan_process_interrupt(dev);
1195 ARLAN_DEBUG_EXIT("arlan_tx");
1196 return NETDEV_TX_OK;
1197
1198bad_end:
1199 arlan_process_interrupt(dev);
1200 netif_stop_queue (dev);
1201 ARLAN_DEBUG_EXIT("arlan_tx");
1202 return NETDEV_TX_BUSY;
1203}
1204
1205
1206static inline int DoNotReTransmitCrap(struct net_device *dev)
1207{
1208 struct arlan_private *priv = netdev_priv(dev);
1209
1210 if (TXLAST(dev).length < priv->Conf->ReTransmitPacketMaxSize)
1211 return 1;
1212 return 0;
1213
1214}
1215
1216static inline int DoNotWaitReTransmitCrap(struct net_device *dev)
1217{
1218 struct arlan_private *priv = netdev_priv(dev);
1219
1220 if (TXLAST(dev).length < priv->Conf->waitReTransmitPacketMaxSize)
1221 return 1;
1222 return 0;
1223}
1224
1225static inline void arlan_queue_retransmit(struct net_device *dev)
1226{
1227 struct arlan_private *priv = netdev_priv(dev);
1228
1229 ARLAN_DEBUG_ENTRY("arlan_queue_retransmit");
1230
1231 if (DoNotWaitReTransmitCrap(dev))
1232 {
1233 arlan_drop_tx(dev);
1234 } else
1235 priv->ReTransmitRequested++;
1236
1237 ARLAN_DEBUG_EXIT("arlan_queue_retransmit");
1238}
1239
1240static inline void RetryOrFail(struct net_device *dev)
1241{
1242 struct arlan_private *priv = netdev_priv(dev);
1243
1244 ARLAN_DEBUG_ENTRY("RetryOrFail");
1245
1246 if (priv->retransmissions > priv->Conf->retries ||
1247 DoNotReTransmitCrap(dev))
1248 {
1249 arlan_drop_tx(dev);
1250 }
1251 else if (priv->bad <= priv->Conf->fastReTransCount)
1252 {
1253 arlan_retransmit_now(dev);
1254 }
1255 else arlan_queue_retransmit(dev);
1256
1257 ARLAN_DEBUG_EXIT("RetryOrFail");
1258}
1259
1260
1261static void arlan_tx_done_interrupt(struct net_device *dev, int status)
1262{
1263 struct arlan_private *priv = netdev_priv(dev);
1264
1265 ARLAN_DEBUG_ENTRY("arlan_tx_done_interrupt");
1266
1267 priv->tx_last_cleared = jiffies;
1268 priv->tx_command_given = 0;
1269 switch (status)
1270 {
1271 case 1:
1272 {
1273 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1274 printk("arlan intr: transmit OK\n");
1275 dev->stats.tx_packets++;
1276 priv->bad = 0;
1277 priv->reset = 0;
1278 priv->retransmissions = 0;
1279 if (priv->Conf->tx_delay_ms)
1280 {
1281 priv->tx_done_delayed = jiffies + (priv->Conf->tx_delay_ms * HZ) / 1000 + 1;
1282 }
1283 else
1284 {
1285 TXLAST(dev).offset = 0;
1286 if (priv->txLast)
1287 priv->txLast = 0;
1288 else if (TXTAIL(dev).offset)
1289 priv->txLast = 1;
1290 if (TXLAST(dev).offset)
1291 {
1292 arlan_retransmit_now(dev);
1293 dev->trans_start = jiffies;
1294 }
1295 if (!TXHEAD(dev).offset || !TXTAIL(dev).offset)
1296 {
1297 netif_wake_queue (dev);
1298 }
1299 }
1300 }
1301 break;
1302
1303 case 2:
1304 {
1305 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1306 printk("arlan intr: transmit timed out\n");
1307 priv->bad += 1;
1308 //arlan_queue_retransmit(dev);
1309 RetryOrFail(dev);
1310 }
1311 break;
1312
1313 case 3:
1314 {
1315 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1316 printk("arlan intr: transmit max retries\n");
1317 priv->bad += 1;
1318 priv->reset = 0;
1319 //arlan_queue_retransmit(dev);
1320 RetryOrFail(dev);
1321 }
1322 break;
1323
1324 case 4:
1325 {
1326 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1327 printk("arlan intr: transmit aborted\n");
1328 priv->bad += 1;
1329 arlan_queue_retransmit(dev);
1330 //RetryOrFail(dev);
1331 }
1332 break;
1333
1334 case 5:
1335 {
1336 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1337 printk("arlan intr: transmit not registered\n");
1338 priv->bad += 1;
1339 //debug=101;
1340 arlan_queue_retransmit(dev);
1341 }
1342 break;
1343
1344 case 6:
1345 {
1346 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1347 printk("arlan intr: transmit destination full\n");
1348 priv->bad += 1;
1349 priv->reset = 0;
1350 //arlan_drop_tx(dev);
1351 arlan_queue_retransmit(dev);
1352 }
1353 break;
1354
1355 case 7:
1356 {
1357 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1358 printk("arlan intr: transmit unknown ack\n");
1359 priv->bad += 1;
1360 priv->reset = 0;
1361 arlan_queue_retransmit(dev);
1362 }
1363 break;
1364
1365 case 8:
1366 {
1367 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1368 printk("arlan intr: transmit dest mail box full\n");
1369 priv->bad += 1;
1370 priv->reset = 0;
1371 //arlan_drop_tx(dev);
1372 arlan_queue_retransmit(dev);
1373 }
1374 break;
1375
1376 case 9:
1377 {
1378 IFDEBUG(ARLAN_DEBUG_TX_CHAIN)
1379 printk("arlan intr: transmit root dest not reg.\n");
1380 priv->bad += 1;
1381 priv->reset = 1;
1382 //arlan_drop_tx(dev);
1383 arlan_queue_retransmit(dev);
1384 }
1385 break;
1386
1387 default:
1388 {
1389 printk(KERN_ERR "arlan intr: transmit status unknown\n");
1390 priv->bad += 1;
1391 priv->reset = 1;
1392 arlan_drop_tx(dev);
1393 }
1394 }
1395
1396 ARLAN_DEBUG_EXIT("arlan_tx_done_interrupt");
1397}
1398
1399
1400static void arlan_rx_interrupt(struct net_device *dev, u_char rxStatus, u_short rxOffset, u_short pkt_len)
1401{
1402 char *skbtmp;
1403 int i = 0;
1404
1405 struct arlan_private *priv = netdev_priv(dev);
1406 volatile struct arlan_shmem __iomem *arlan = priv->card;
1407 struct arlan_conf_stru *conf = priv->Conf;
1408
1409
1410 ARLAN_DEBUG_ENTRY("arlan_rx_interrupt");
1411 // by spec, not WRITESHMB(arlan->rxStatus,0x00);
1412 // prohibited here arlan_command(dev, ARLAN_COMMAND_RX);
1413
1414 if (pkt_len < 10 || pkt_len > 2048)
1415 {
1416 printk(KERN_WARNING "%s: got too short or long packet, len %d \n", dev->name, pkt_len);
1417 return;
1418 }
1419 if (rxOffset + pkt_len > 0x2000)
1420 {
1421 printk("%s: got too long packet, len %d offset %x\n", dev->name, pkt_len, rxOffset);
1422 return;
1423 }
1424 priv->in_bytes += pkt_len;
1425 priv->in_bytes10 += pkt_len;
1426 if (conf->measure_rate < 1)
1427 conf->measure_rate = 1;
1428 if (time_after(jiffies, priv->in_time + conf->measure_rate * HZ))
1429 {
1430 conf->in_speed = priv->in_bytes / conf->measure_rate;
1431 priv->in_bytes = 0;
1432 priv->in_time = jiffies;
1433 }
1434 if (time_after(jiffies, priv->in_time10 + conf->measure_rate * 10*HZ))
1435 {
1436 conf->in_speed10 = priv->in_bytes10 / (10 * conf->measure_rate);
1437 priv->in_bytes10 = 0;
1438 priv->in_time10 = jiffies;
1439 }
1440 DEBUGSHM(1, "arlan rcv pkt rxStatus= %d ", arlan->rxStatus, u_char);
1441 switch (rxStatus)
1442 {
1443 case 1:
1444 case 2:
1445 case 3:
1446 {
1447 /* Malloc up new buffer. */
1448 struct sk_buff *skb;
1449
1450 DEBUGSHM(50, "arlan recv pkt offs=%d\n", arlan->rxOffset, u_short);
1451 DEBUGSHM(1, "arlan rxFrmType = %d \n", arlan->rxFrmType, u_char);
1452 DEBUGSHM(1, KERN_INFO "arlan rx scrambled = %d \n", arlan->scrambled, u_char);
1453
1454 /* here we do multicast filtering to avoid slow 8-bit memcopy */
1455#ifdef ARLAN_MULTICAST
1456 if (!(dev->flags & IFF_ALLMULTI) &&
1457 !(dev->flags & IFF_PROMISC) &&
1458 dev->mc_list)
1459 {
1460 char hw_dst_addr[6];
1461 struct dev_mc_list *dmi = dev->mc_list;
1462 int i;
1463
1464 memcpy_fromio(hw_dst_addr, arlan->ultimateDestAddress, 6);
1465 if (hw_dst_addr[0] == 0x01)
1466 {
1467 if (mdebug)
1468 if (hw_dst_addr[1] == 0x00)
1469 printk(KERN_ERR "%s mcast 0x0100 \n", dev->name);
1470 else if (hw_dst_addr[1] == 0x40)
1471 printk(KERN_ERR "%s m/bcast 0x0140 \n", dev->name);
1472 while (dmi)
1473 {
1474 if (dmi->dmi_addrlen == 6) {
1475 if (arlan_debug & ARLAN_DEBUG_HEADER_DUMP)
1476 printk(KERN_ERR "%s mcl %pM\n",
1477 dev->name, dmi->dmi_addr);
1478 for (i = 0; i < 6; i++)
1479 if (dmi->dmi_addr[i] != hw_dst_addr[i])
1480 break;
1481 if (i == 6)
1482 break;
1483 } else
1484 printk(KERN_ERR "%s: invalid multicast address length given.\n", dev->name);
1485 dmi = dmi->next;
1486 }
1487 /* we reach here if multicast filtering is on and packet
1488 * is multicast and not for receive */
1489 goto end_of_interrupt;
1490 }
1491 }
1492#endif // ARLAN_MULTICAST
1493 /* multicast filtering ends here */
1494 pkt_len += ARLAN_FAKE_HDR_LEN;
1495
1496 skb = dev_alloc_skb(pkt_len + 4);
1497 if (skb == NULL)
1498 {
1499 printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n", dev->name);
1500 dev->stats.rx_dropped++;
1501 break;
1502 }
1503 skb_reserve(skb, 2);
1504 skbtmp = skb_put(skb, pkt_len);
1505
1506 memcpy_fromio(skbtmp + ARLAN_FAKE_HDR_LEN, ((char __iomem *) arlan) + rxOffset, pkt_len - ARLAN_FAKE_HDR_LEN);
1507 memcpy_fromio(skbtmp, arlan->ultimateDestAddress, 6);
1508 memcpy_fromio(skbtmp + 6, arlan->rxSrc, 6);
1509 WRITESHMB(arlan->rxStatus, 0x00);
1510 arlan_command(dev, ARLAN_COMMAND_RX);
1511
1512 IFDEBUG(ARLAN_DEBUG_HEADER_DUMP)
1513 {
1514 char immedDestAddress[6];
1515 char immedSrcAddress[6];
1516 memcpy_fromio(immedDestAddress, arlan->immedDestAddress, 6);
1517 memcpy_fromio(immedSrcAddress, arlan->immedSrcAddress, 6);
1518
1519 printk(KERN_WARNING "%s t %pM f %pM imd %pM ims %pM\n",
1520 dev->name, skbtmp,
1521 &skbtmp[6],
1522 immedDestAddress,
1523 immedSrcAddress);
1524 }
1525 skb->protocol = eth_type_trans(skb, dev);
1526 IFDEBUG(ARLAN_DEBUG_HEADER_DUMP)
1527 if (skb->protocol != 0x608 && skb->protocol != 0x8)
1528 {
1529 for (i = 0; i <= 22; i++)
1530 printk("%02x:", (u_char) skbtmp[i + 12]);
1531 printk(KERN_ERR "\n");
1532 printk(KERN_WARNING "arlan kernel pkt type trans %x \n", skb->protocol);
1533 }
1534 netif_rx(skb);
1535 dev->stats.rx_packets++;
1536 dev->stats.rx_bytes += pkt_len;
1537 }
1538 break;
1539
1540 default:
1541 printk(KERN_ERR "arlan intr: received unknown status\n");
1542 dev->stats.rx_crc_errors++;
1543 break;
1544 }
1545 ARLAN_DEBUG_EXIT("arlan_rx_interrupt");
1546}
1547
1548static void arlan_process_interrupt(struct net_device *dev)
1549{
1550 struct arlan_private *priv = netdev_priv(dev);
1551 volatile struct arlan_shmem __iomem *arlan = priv->card;
1552 u_char rxStatus = READSHMB(arlan->rxStatus);
1553 u_char txStatus = READSHMB(arlan->txStatus);
1554 u_short rxOffset = READSHMS(arlan->rxOffset);
1555 u_short pkt_len = READSHMS(arlan->rxLength);
1556 int interrupt_count = 0;
1557
1558 ARLAN_DEBUG_ENTRY("arlan_process_interrupt");
1559
1560 if (test_and_set_bit(0, (void *) &priv->interrupt_processing_active))
1561 {
1562 if (arlan_debug & ARLAN_DEBUG_CHAIN_LOCKS)
1563 printk(KERN_ERR "interrupt chain reentering \n");
1564 goto end_int_process;
1565 }
1566 while ((rxStatus || txStatus || priv->interrupt_ack_requested)
1567 && (interrupt_count < 5))
1568 {
1569 if (rxStatus)
1570 priv->last_rx_int_ack_time = jiffies;
1571
1572 arlan_command(dev, ARLAN_COMMAND_INT_ACK);
1573 arlan_command(dev, ARLAN_COMMAND_INT_ENABLE);
1574
1575 IFDEBUG(ARLAN_DEBUG_INTERRUPT)
1576 printk(KERN_ERR "%s: got IRQ rx %x tx %x comm %x rxOff %x rxLen %x \n",
1577 dev->name, rxStatus, txStatus, READSHMB(arlan->commandByte),
1578 rxOffset, pkt_len);
1579
1580 if (rxStatus == 0 && txStatus == 0)
1581 {
1582 if (priv->irq_test_done)
1583 {
1584 if (!registrationBad(dev))
1585 IFDEBUG(ARLAN_DEBUG_INTERRUPT) printk(KERN_ERR "%s unknown interrupt(nop? regLost ?) reason tx %d rx %d ",
1586 dev->name, txStatus, rxStatus);
1587 } else {
1588 IFDEBUG(ARLAN_DEBUG_INTERRUPT)
1589 printk(KERN_INFO "%s irq $%d test OK \n", dev->name, dev->irq);
1590
1591 }
1592 priv->interrupt_ack_requested = 0;
1593 goto ends;
1594 }
1595 if (txStatus != 0)
1596 {
1597 WRITESHMB(arlan->txStatus, 0x00);
1598 arlan_tx_done_interrupt(dev, txStatus);
1599 goto ends;
1600 }
1601 if (rxStatus == 1 || rxStatus == 2)
1602 { /* a packet waiting */
1603 arlan_rx_interrupt(dev, rxStatus, rxOffset, pkt_len);
1604 goto ends;
1605 }
1606 if (rxStatus > 2 && rxStatus < 0xff)
1607 {
1608 WRITESHMB(arlan->rxStatus, 0x00);
1609 printk(KERN_ERR "%s unknown rxStatus reason tx %d rx %d ",
1610 dev->name, txStatus, rxStatus);
1611 goto ends;
1612 }
1613 if (rxStatus == 0xff)
1614 {
1615 WRITESHMB(arlan->rxStatus, 0x00);
1616 arlan_command(dev, ARLAN_COMMAND_RX);
1617 if (registrationBad(dev))
1618 netif_device_detach(dev);
1619 if (!registrationBad(dev))
1620 {
1621 priv->registrationLastSeen = jiffies;
1622 if (!netif_queue_stopped(dev) && !priv->under_reset && !priv->under_config)
1623 netif_wake_queue (dev);
1624 }
1625 goto ends;
1626 }
1627ends:
1628
1629 arlan_command_process(dev);
1630
1631 rxStatus = READSHMB(arlan->rxStatus);
1632 txStatus = READSHMB(arlan->txStatus);
1633 rxOffset = READSHMS(arlan->rxOffset);
1634 pkt_len = READSHMS(arlan->rxLength);
1635
1636
1637 priv->irq_test_done = 1;
1638
1639 interrupt_count++;
1640 }
1641 priv->interrupt_processing_active = 0;
1642
1643end_int_process:
1644 arlan_command_process(dev);
1645
1646 ARLAN_DEBUG_EXIT("arlan_process_interrupt");
1647 return;
1648}
1649
1650static irqreturn_t arlan_interrupt(int irq, void *dev_id)
1651{
1652 struct net_device *dev = dev_id;
1653 struct arlan_private *priv = netdev_priv(dev);
1654 volatile struct arlan_shmem __iomem *arlan = priv->card;
1655 u_char rxStatus = READSHMB(arlan->rxStatus);
1656 u_char txStatus = READSHMB(arlan->txStatus);
1657
1658 ARLAN_DEBUG_ENTRY("arlan_interrupt");
1659
1660
1661 if (!rxStatus && !txStatus)
1662 priv->interrupt_ack_requested++;
1663
1664 arlan_process_interrupt(dev);
1665
1666 priv->irq_test_done = 1;
1667
1668 ARLAN_DEBUG_EXIT("arlan_interrupt");
1669 return IRQ_HANDLED;
1670
1671}
1672
1673
1674static int arlan_close(struct net_device *dev)
1675{
1676 struct arlan_private *priv = netdev_priv(dev);
1677
1678 ARLAN_DEBUG_ENTRY("arlan_close");
1679
1680 del_timer_sync(&priv->timer);
1681
1682 arlan_command(dev, ARLAN_COMMAND_POWERDOWN);
1683
1684 IFDEBUG(ARLAN_DEBUG_STARTUP)
1685 printk(KERN_NOTICE "%s: Closing device\n", dev->name);
1686
1687 netif_stop_queue(dev);
1688 free_irq(dev->irq, dev);
1689
1690 ARLAN_DEBUG_EXIT("arlan_close");
1691 return 0;
1692}
1693
1694#ifdef ARLAN_DEBUGGING
1695static long alignLong(volatile u_char * ptr)
1696{
1697 long ret;
1698 memcpy_fromio(&ret, (void *) ptr, 4);
1699 return ret;
1700}
1701#endif
1702
1703/*
1704 * Get the current statistics.
1705 * This may be called with the card open or closed.
1706 */
1707
1708static struct net_device_stats *arlan_statistics(struct net_device *dev)
1709{
1710 struct arlan_private *priv = netdev_priv(dev);
1711 volatile struct arlan_shmem __iomem *arlan = priv->card;
1712
1713
1714 ARLAN_DEBUG_ENTRY("arlan_statistics");
1715
1716 /* Update the statistics from the device registers. */
1717
1718 READSHM(dev->stats.collisions, arlan->numReTransmissions, u_int);
1719 READSHM(dev->stats.rx_crc_errors, arlan->numCRCErrors, u_int);
1720 READSHM(dev->stats.rx_dropped, arlan->numFramesDiscarded, u_int);
1721 READSHM(dev->stats.rx_fifo_errors, arlan->numRXBufferOverflows, u_int);
1722 READSHM(dev->stats.rx_frame_errors, arlan->numReceiveFramesLost, u_int);
1723 READSHM(dev->stats.rx_over_errors, arlan->numRXOverruns, u_int);
1724 READSHM(dev->stats.rx_packets, arlan->numDatagramsReceived, u_int);
1725 READSHM(dev->stats.tx_aborted_errors, arlan->numAbortErrors, u_int);
1726 READSHM(dev->stats.tx_carrier_errors, arlan->numStatusTimeouts, u_int);
1727 READSHM(dev->stats.tx_dropped, arlan->numDatagramsDiscarded, u_int);
1728 READSHM(dev->stats.tx_fifo_errors, arlan->numTXUnderruns, u_int);
1729 READSHM(dev->stats.tx_packets, arlan->numDatagramsTransmitted, u_int);
1730 READSHM(dev->stats.tx_window_errors, arlan->numHoldOffs, u_int);
1731
1732 ARLAN_DEBUG_EXIT("arlan_statistics");
1733
1734 return &dev->stats;
1735}
1736
1737
1738static void arlan_set_multicast(struct net_device *dev)
1739{
1740 struct arlan_private *priv = netdev_priv(dev);
1741 volatile struct arlan_shmem __iomem *arlan = priv->card;
1742 struct arlan_conf_stru *conf = priv->Conf;
1743 int board_conf_needed = 0;
1744
1745
1746 ARLAN_DEBUG_ENTRY("arlan_set_multicast");
1747
1748 if (dev->flags & IFF_PROMISC)
1749 {
1750 unsigned char recMode;
1751 READSHM(recMode, arlan->receiveMode, u_char);
1752 conf->receiveMode = (ARLAN_RCV_PROMISC | ARLAN_RCV_CONTROL);
1753 if (conf->receiveMode != recMode)
1754 board_conf_needed = 1;
1755 }
1756 else
1757 {
1758 /* turn off promiscuous mode */
1759 unsigned char recMode;
1760 READSHM(recMode, arlan->receiveMode, u_char);
1761 conf->receiveMode = ARLAN_RCV_CLEAN | ARLAN_RCV_CONTROL;
1762 if (conf->receiveMode != recMode)
1763 board_conf_needed = 1;
1764 }
1765 if (board_conf_needed)
1766 arlan_command(dev, ARLAN_COMMAND_CONF);
1767
1768 ARLAN_DEBUG_EXIT("arlan_set_multicast");
1769}
1770
1771
1772struct net_device * __init arlan_probe(int unit)
1773{
1774 struct net_device *dev;
1775 int err;
1776 int m;
1777
1778 ARLAN_DEBUG_ENTRY("arlan_probe");
1779
1780 if (arlans_found == MAX_ARLANS)
1781 return ERR_PTR(-ENODEV);
1782
1783 /*
1784 * Reserve space for local data and a copy of the shared memory
1785 * that is used by the /proc interface.
1786 */
1787 dev = alloc_etherdev(sizeof(struct arlan_private)
1788 + sizeof(struct arlan_shmem));
1789 if (!dev)
1790 return ERR_PTR(-ENOMEM);
1791
1792 if (unit >= 0) {
1793 sprintf(dev->name, "eth%d", unit);
1794 netdev_boot_setup_check(dev);
1795
1796 if (dev->mem_start) {
1797 if (arlan_probe_here(dev, dev->mem_start) == 0)
1798 goto found;
1799 goto not_found;
1800 }
1801
1802 }
1803
1804
1805 for (m = (int)phys_to_virt(lastFoundAt) + ARLAN_SHMEM_SIZE;
1806 m <= (int)phys_to_virt(0xDE000);
1807 m += ARLAN_SHMEM_SIZE)
1808 {
1809 if (arlan_probe_here(dev, m) == 0)
1810 {
1811 lastFoundAt = (int)virt_to_phys((void*)m);
1812 goto found;
1813 }
1814 }
1815
1816 if (lastFoundAt == 0xbe000)
1817 printk(KERN_ERR "arlan: No Arlan devices found \n");
1818
1819 not_found:
1820 free_netdev(dev);
1821 return ERR_PTR(-ENODEV);
1822
1823 found:
1824 err = arlan_setup_device(dev, arlans_found);
1825 if (err)
1826 dev = ERR_PTR(err);
1827 else if (!arlans_found++)
1828 printk(KERN_INFO "Arlan driver %s\n", arlan_version);
1829
1830 return dev;
1831}
1832
1833#ifdef MODULE
1834int __init init_module(void)
1835{
1836 int i = 0;
1837
1838 ARLAN_DEBUG_ENTRY("init_module");
1839
1840 if (channelSet != channelSetUNKNOWN || channelNumber != channelNumberUNKNOWN || systemId != systemIdUNKNOWN)
1841 return -EINVAL;
1842
1843 for (i = 0; i < MAX_ARLANS; i++) {
1844 struct net_device *dev = arlan_probe(i);
1845
1846 if (IS_ERR(dev))
1847 return PTR_ERR(dev);
1848 }
1849 init_arlan_proc();
1850 printk(KERN_INFO "Arlan driver %s\n", arlan_version);
1851 ARLAN_DEBUG_EXIT("init_module");
1852 return 0;
1853}
1854
1855
1856void __exit cleanup_module(void)
1857{
1858 int i = 0;
1859 struct net_device *dev;
1860
1861 ARLAN_DEBUG_ENTRY("cleanup_module");
1862
1863 IFDEBUG(ARLAN_DEBUG_SHUTDOWN)
1864 printk(KERN_INFO "arlan: unloading module\n");
1865
1866 cleanup_arlan_proc();
1867
1868 for (i = 0; i < MAX_ARLANS; i++)
1869 {
1870 dev = arlan_device[i];
1871 if (dev) {
1872 arlan_command(dev, ARLAN_COMMAND_POWERDOWN );
1873
1874 unregister_netdev(dev);
1875 release_mem_region(virt_to_phys((void *) dev->mem_start),
1876 ARLAN_SHMEM_SIZE);
1877 free_netdev(dev);
1878 arlan_device[i] = NULL;
1879 }
1880 }
1881
1882 ARLAN_DEBUG_EXIT("cleanup_module");
1883}
1884
1885
1886#endif
1887MODULE_LICENSE("GPL");
diff --git a/drivers/net/wireless/arlan-proc.c b/drivers/net/wireless/arlan-proc.c
deleted file mode 100644
index a8b689635a3b..000000000000
--- a/drivers/net/wireless/arlan-proc.c
+++ /dev/null
@@ -1,1253 +0,0 @@
1#include "arlan.h"
2
3#include <linux/sysctl.h>
4
5#ifdef CONFIG_PROC_FS
6
7/* void enableReceive(struct net_device* dev);
8*/
9
10
11
12#define ARLAN_STR_SIZE 0x2ff0
13#define DEV_ARLAN_INFO 1
14#define DEV_ARLAN 1
15#define SARLG(type,var) {\
16 pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n", #var, READSHMB(priva->card->var)); \
17 }
18
19#define SARLBN(type,var,nn) {\
20 pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x",#var);\
21 for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
22 pos += sprintf(arlan_drive_info+pos, "\n"); \
23 }
24
25#define SARLBNpln(type,var,nn) {\
26 for (i=0; i < nn; i++ ) pos += sprintf(arlan_drive_info+pos, "%02x",READSHMB(priva->card->var[i]));\
27 }
28
29#define SARLSTR(var,nn) {\
30 char tmpStr[400];\
31 int tmpLn = nn;\
32 if (nn > 399 ) tmpLn = 399; \
33 memcpy(tmpStr,(char *) priva->conf->var,tmpLn);\
34 tmpStr[tmpLn] = 0; \
35 pos += sprintf(arlan_drive_info+pos, "%s\t=\t%s \n",#var,priva->conf->var);\
36 }
37
38#define SARLUC(var) SARLG(u_char, var)
39#define SARLUCN(var,nn) SARLBN(u_char,var, nn)
40#define SARLUS(var) SARLG(u_short, var)
41#define SARLUSN(var,nn) SARLBN(u_short,var, nn)
42#define SARLUI(var) SARLG(u_int, var)
43
44#define SARLUSA(var) {\
45 u_short tmpVar;\
46 memcpy(&tmpVar, (short *) priva->conf->var,2); \
47 pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
48}
49
50#define SARLUIA(var) {\
51 u_int tmpVar;\
52 memcpy(&tmpVar, (int* )priva->conf->var,4); \
53 pos += sprintf(arlan_drive_info+pos, "%s\t=\t0x%x\n",#var, tmpVar);\
54}
55
56
57static const char *arlan_diagnostic_info_string(struct net_device *dev)
58{
59
60 struct arlan_private *priv = netdev_priv(dev);
61 volatile struct arlan_shmem __iomem *arlan = priv->card;
62 u_char diagnosticInfo;
63
64 READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
65
66 switch (diagnosticInfo)
67 {
68 case 0xFF:
69 return "Diagnostic info is OK";
70 case 0xFE:
71 return "ERROR EPROM Checksum error ";
72 case 0xFD:
73 return "ERROR Local Ram Test Failed ";
74 case 0xFC:
75 return "ERROR SCC failure ";
76 case 0xFB:
77 return "ERROR BackBone failure ";
78 case 0xFA:
79 return "ERROR transceiver not found ";
80 case 0xF9:
81 return "ERROR no more address space ";
82 case 0xF8:
83 return "ERROR Checksum error ";
84 case 0xF7:
85 return "ERROR Missing SS Code";
86 case 0xF6:
87 return "ERROR Invalid config format";
88 case 0xF5:
89 return "ERROR Reserved errorcode F5";
90 case 0xF4:
91 return "ERROR Invalid spreading code/channel number";
92 case 0xF3:
93 return "ERROR Load Code Error";
94 case 0xF2:
95 return "ERROR Reserver errorcode F2 ";
96 case 0xF1:
97 return "ERROR Invalid command receivec by LAN card ";
98 case 0xF0:
99 return "ERROR Invalid parameter found in command ";
100 case 0xEF:
101 return "ERROR On-chip timer failure ";
102 case 0xEE:
103 return "ERROR T410 timer failure ";
104 case 0xED:
105 return "ERROR Too Many TxEnable commands ";
106 case 0xEC:
107 return "ERROR EEPROM error on radio module ";
108 default:
109 return "ERROR unknown Diagnostic info reply code ";
110 }
111}
112
113static const char *arlan_hardware_type_string(struct net_device *dev)
114{
115 u_char hardwareType;
116 struct arlan_private *priv = netdev_priv(dev);
117 volatile struct arlan_shmem __iomem *arlan = priv->card;
118
119 READSHM(hardwareType, arlan->hardwareType, u_char);
120 switch (hardwareType)
121 {
122 case 0x00:
123 return "type A450";
124 case 0x01:
125 return "type A650 ";
126 case 0x04:
127 return "type TMA coproc";
128 case 0x0D:
129 return "type A650E ";
130 case 0x18:
131 return "type TMA coproc Australian";
132 case 0x19:
133 return "type A650A ";
134 case 0x26:
135 return "type TMA coproc European";
136 case 0x2E:
137 return "type A655 ";
138 case 0x2F:
139 return "type A655A ";
140 case 0x30:
141 return "type A655E ";
142 case 0x0B:
143 return "type A670 ";
144 case 0x0C:
145 return "type A670E ";
146 case 0x2D:
147 return "type A670A ";
148 case 0x0F:
149 return "type A411T";
150 case 0x16:
151 return "type A411TA";
152 case 0x1B:
153 return "type A440T";
154 case 0x1C:
155 return "type A412T";
156 case 0x1E:
157 return "type A412TA";
158 case 0x22:
159 return "type A411TE";
160 case 0x24:
161 return "type A412TE";
162 case 0x27:
163 return "type A671T ";
164 case 0x29:
165 return "type A671TA ";
166 case 0x2B:
167 return "type A671TE ";
168 case 0x31:
169 return "type A415T ";
170 case 0x33:
171 return "type A415TA ";
172 case 0x35:
173 return "type A415TE ";
174 case 0x37:
175 return "type A672";
176 case 0x39:
177 return "type A672A ";
178 case 0x3B:
179 return "type A672T";
180 case 0x6B:
181 return "type IC2200";
182 default:
183 return "type A672T";
184 }
185}
186#ifdef ARLAN_DEBUGGING
187static void arlan_print_diagnostic_info(struct net_device *dev)
188{
189 int i;
190 u_char diagnosticInfo;
191 u_short diagnosticOffset;
192 u_char hardwareType;
193 struct arlan_private *priv = netdev_priv(dev);
194 volatile struct arlan_shmem __iomem *arlan = priv->card;
195
196 // ARLAN_DEBUG_ENTRY("arlan_print_diagnostic_info");
197
198 if (READSHMB(arlan->configuredStatusFlag) == 0)
199 printk("Arlan: Card NOT configured\n");
200 else
201 printk("Arlan: Card is configured\n");
202
203 READSHM(diagnosticInfo, arlan->diagnosticInfo, u_char);
204 READSHM(diagnosticOffset, arlan->diagnosticOffset, u_short);
205
206 printk(KERN_INFO "%s\n", arlan_diagnostic_info_string(dev));
207
208 if (diagnosticInfo != 0xff)
209 printk("%s arlan: Diagnostic Offset %d \n", dev->name, diagnosticOffset);
210
211 printk("arlan: LAN CODE ID = ");
212 for (i = 0; i < 6; i++)
213 DEBUGSHM(1, "%03d:", arlan->lanCardNodeId[i], u_char);
214 printk("\n");
215
216 printk("arlan: Arlan BroadCast address = ");
217 for (i = 0; i < 6; i++)
218 DEBUGSHM(1, "%03d:", arlan->broadcastAddress[i], u_char);
219 printk("\n");
220
221 READSHM(hardwareType, arlan->hardwareType, u_char);
222 printk(KERN_INFO "%s\n", arlan_hardware_type_string(dev));
223
224
225 DEBUGSHM(1, "arlan: channelNumber=%d\n", arlan->channelNumber, u_char);
226 DEBUGSHM(1, "arlan: channelSet=%d\n", arlan->channelSet, u_char);
227 DEBUGSHM(1, "arlan: spreadingCode=%d\n", arlan->spreadingCode, u_char);
228 DEBUGSHM(1, "arlan: radioNodeId=%d\n", arlan->radioNodeId, u_short);
229 DEBUGSHM(1, "arlan: SID =%d\n", arlan->SID, u_short);
230 DEBUGSHM(1, "arlan: rxOffset=%d\n", arlan->rxOffset, u_short);
231
232 DEBUGSHM(1, "arlan: registration mode is %d\n", arlan->registrationMode, u_char);
233
234 printk("arlan: name= ");
235 IFDEBUG(1)
236
237 for (i = 0; i < 16; i++)
238 {
239 char c;
240 READSHM(c, arlan->name[i], char);
241 if (c)
242 printk("%c", c);
243 }
244 printk("\n");
245
246// ARLAN_DEBUG_EXIT("arlan_print_diagnostic_info");
247
248}
249
250
251/****************************** TEST MEMORY **************/
252
253static int arlan_hw_test_memory(struct net_device *dev)
254{
255 u_char *ptr;
256 int i;
257 int memlen = sizeof(struct arlan_shmem) - 0xF; /* avoid control register */
258 volatile char *arlan_mem = (char *) (dev->mem_start);
259 struct arlan_private *priv = netdev_priv(dev);
260 volatile struct arlan_shmem __iomem *arlan = priv->card;
261 char pattern;
262
263 ptr = NULL;
264
265 /* hold card in reset state */
266 setHardwareReset(dev);
267
268 /* test memory */
269 pattern = 0;
270 for (i = 0; i < memlen; i++)
271 WRITESHM(arlan_mem[i], ((u_char) pattern++), u_char);
272
273 pattern = 0;
274 for (i = 0; i < memlen; i++)
275 {
276 char res;
277 READSHM(res, arlan_mem[i], char);
278 if (res != pattern++)
279 {
280 printk(KERN_ERR "Arlan driver memory test 1 failed \n");
281 return -1;
282 }
283 }
284
285 pattern = 0;
286 for (i = 0; i < memlen; i++)
287 WRITESHM(arlan_mem[i], ~(pattern++), char);
288
289 pattern = 0;
290 for (i = 0; i < memlen; i++)
291 {
292 char res;
293 READSHM(res, arlan_mem[i], char);
294 if (res != ~(pattern++))
295 {
296 printk(KERN_ERR "Arlan driver memory test 2 failed \n");
297 return -1;
298 }
299 }
300
301 /* zero memory */
302 for (i = 0; i < memlen; i++)
303 WRITESHM(arlan_mem[i], 0x00, char);
304
305 IFDEBUG(1) printk(KERN_INFO "Arlan: memory tests ok\n");
306
307 /* set reset flag and then release reset */
308 WRITESHM(arlan->resetFlag, 0xff, u_char);
309
310 clearChannelAttention(dev);
311 clearHardwareReset(dev);
312
313 /* wait for reset flag to become zero, we'll wait for two seconds */
314 if (arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW))
315 {
316 printk(KERN_ERR "%s arlan: failed to come back from memory test\n", dev->name);
317 return -1;
318 }
319 return 0;
320}
321
322static int arlan_setup_card_by_book(struct net_device *dev)
323{
324 u_char irqLevel, configuredStatusFlag;
325 struct arlan_private *priv = netdev_priv(dev);
326 volatile struct arlan_shmem __iomem *arlan = priv->card;
327
328// ARLAN_DEBUG_ENTRY("arlan_setup_card");
329
330 READSHM(configuredStatusFlag, arlan->configuredStatusFlag, u_char);
331
332 IFDEBUG(10)
333 if (configuredStatusFlag != 0)
334 IFDEBUG(10) printk("arlan: CARD IS CONFIGURED\n");
335 else
336 IFDEBUG(10) printk("arlan: card is NOT configured\n");
337
338 if (testMemory || (READSHMB(arlan->diagnosticInfo) != 0xff))
339 if (arlan_hw_test_memory(dev))
340 return -1;
341
342 DEBUGSHM(4, "arlan configuredStatus = %d \n", arlan->configuredStatusFlag, u_char);
343 DEBUGSHM(4, "arlan driver diagnostic: 0x%2x\n", arlan->diagnosticInfo, u_char);
344
345 /* issue nop command - no interrupt */
346 arlan_command(dev, ARLAN_COMMAND_NOOP);
347 if (arlan_command(dev, ARLAN_COMMAND_WAIT_NOW) != 0)
348 return -1;
349
350 IFDEBUG(50) printk("1st Noop successfully executed !!\n");
351
352 /* try to turn on the arlan interrupts */
353 clearClearInterrupt(dev);
354 setClearInterrupt(dev);
355 setInterruptEnable(dev);
356
357 /* issue nop command - with interrupt */
358
359 arlan_command(dev, ARLAN_COMMAND_NOOPINT);
360 if (arlan_command(dev, ARLAN_COMMAND_WAIT_NOW) != 0)
361 return -1;
362
363
364 IFDEBUG(50) printk("2nd Noop successfully executed !!\n");
365
366 READSHM(irqLevel, arlan->irqLevel, u_char)
367
368 if (irqLevel != dev->irq)
369 {
370 IFDEBUG(1) printk(KERN_WARNING "arlan dip switches set irq to %d\n", irqLevel);
371 printk(KERN_WARNING "device driver irq set to %d - does not match\n", dev->irq);
372 dev->irq = irqLevel;
373 }
374 else
375 IFDEBUG(2) printk("irq level is OK\n");
376
377
378 IFDEBUG(3) arlan_print_diagnostic_info(dev);
379
380 arlan_command(dev, ARLAN_COMMAND_CONF);
381
382 READSHM(configuredStatusFlag, arlan->configuredStatusFlag, u_char);
383 if (configuredStatusFlag == 0)
384 {
385 printk(KERN_WARNING "arlan configure failed\n");
386 return -1;
387 }
388 arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW);
389 arlan_command(dev, ARLAN_COMMAND_RX);
390 arlan_command(dev, ARLAN_COMMAND_LONG_WAIT_NOW);
391 printk(KERN_NOTICE "%s: arlan driver version %s loaded\n",
392 dev->name, arlan_version);
393
394// ARLAN_DEBUG_EXIT("arlan_setup_card");
395
396 return 0; /* no errors */
397}
398#endif
399
400#ifdef ARLAN_PROC_INTERFACE
401#ifdef ARLAN_PROC_SHM_DUMP
402
403static char arlan_drive_info[ARLAN_STR_SIZE] = "A655\n\0";
404
405static int arlan_sysctl_info(ctl_table * ctl, int write,
406 void __user *buffer, size_t * lenp, loff_t *ppos)
407{
408 int i;
409 int retv, pos, devnum;
410 struct arlan_private *priva = NULL;
411 struct net_device *dev;
412 pos = 0;
413 if (write)
414 {
415 printk("wrirte: ");
416 for (i = 0; i < 100; i++)
417 printk("adi %x \n", arlan_drive_info[i]);
418 }
419 if (ctl->procname == NULL || arlan_drive_info == NULL)
420 {
421 printk(KERN_WARNING " procname is NULL in sysctl_table or arlan_drive_info is NULL \n at arlan module\n ");
422 return -1;
423 }
424 devnum = ctl->procname[5] - '0';
425 if (devnum < 0 || devnum > MAX_ARLANS - 1)
426 {
427 printk(KERN_WARNING "too strange devnum in procfs parse\n ");
428 return -1;
429 }
430 else if (arlan_device[devnum] == NULL)
431 {
432 if (ctl->procname)
433 pos += sprintf(arlan_drive_info + pos, "\t%s\n\n", ctl->procname);
434 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
435 goto final;
436 }
437 else
438 priva = netdev_priv(arlan_device[devnum]);
439
440 if (priva == NULL)
441 {
442 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
443 return -1;
444 }
445 dev = arlan_device[devnum];
446
447 memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
448
449 pos = sprintf(arlan_drive_info, "Arlan info \n");
450 /* Header Signature */
451 SARLSTR(textRegion, 48);
452 SARLUC(resetFlag);
453 pos += sprintf(arlan_drive_info + pos, "diagnosticInfo\t=\t%s \n", arlan_diagnostic_info_string(dev));
454 SARLUC(diagnosticInfo);
455 SARLUS(diagnosticOffset);
456 SARLUCN(_1, 12);
457 SARLUCN(lanCardNodeId, 6);
458 SARLUCN(broadcastAddress, 6);
459 pos += sprintf(arlan_drive_info + pos, "hardwareType =\t %s \n", arlan_hardware_type_string(dev));
460 SARLUC(hardwareType);
461 SARLUC(majorHardwareVersion);
462 SARLUC(minorHardwareVersion);
463 SARLUC(radioModule);
464 SARLUC(defaultChannelSet);
465 SARLUCN(_2, 47);
466
467 /* Control/Status Block - 0x0080 */
468 SARLUC(interruptInProgress);
469 SARLUC(cntrlRegImage);
470
471 SARLUCN(_3, 14);
472 SARLUC(commandByte);
473 SARLUCN(commandParameter, 15);
474
475 /* Receive Status - 0x00a0 */
476 SARLUC(rxStatus);
477 SARLUC(rxFrmType);
478 SARLUS(rxOffset);
479 SARLUS(rxLength);
480 SARLUCN(rxSrc, 6);
481 SARLUC(rxBroadcastFlag);
482 SARLUC(rxQuality);
483 SARLUC(scrambled);
484 SARLUCN(_4, 1);
485
486 /* Transmit Status - 0x00b0 */
487 SARLUC(txStatus);
488 SARLUC(txAckQuality);
489 SARLUC(numRetries);
490 SARLUCN(_5, 14);
491 SARLUCN(registeredRouter, 6);
492 SARLUCN(backboneRouter, 6);
493 SARLUC(registrationStatus);
494 SARLUC(configuredStatusFlag);
495 SARLUCN(_6, 1);
496 SARLUCN(ultimateDestAddress, 6);
497 SARLUCN(immedDestAddress, 6);
498 SARLUCN(immedSrcAddress, 6);
499 SARLUS(rxSequenceNumber);
500 SARLUC(assignedLocaltalkAddress);
501 SARLUCN(_7, 27);
502
503 /* System Parameter Block */
504
505 /* - Driver Parameters (Novell Specific) */
506
507 SARLUS(txTimeout);
508 SARLUS(transportTime);
509 SARLUCN(_8, 4);
510
511 /* - Configuration Parameters */
512 SARLUC(irqLevel);
513 SARLUC(spreadingCode);
514 SARLUC(channelSet);
515 SARLUC(channelNumber);
516 SARLUS(radioNodeId);
517 SARLUCN(_9, 2);
518 SARLUC(scramblingDisable);
519 SARLUC(radioType);
520 SARLUS(routerId);
521 SARLUCN(_10, 9);
522 SARLUC(txAttenuation);
523 SARLUIA(systemId);
524 SARLUS(globalChecksum);
525 SARLUCN(_11, 4);
526 SARLUS(maxDatagramSize);
527 SARLUS(maxFrameSize);
528 SARLUC(maxRetries);
529 SARLUC(receiveMode);
530 SARLUC(priority);
531 SARLUC(rootOrRepeater);
532 SARLUCN(specifiedRouter, 6);
533 SARLUS(fastPollPeriod);
534 SARLUC(pollDecay);
535 SARLUSA(fastPollDelay);
536 SARLUC(arlThreshold);
537 SARLUC(arlDecay);
538 SARLUCN(_12, 1);
539 SARLUS(specRouterTimeout);
540 SARLUCN(_13, 5);
541
542 /* Scrambled Area */
543 SARLUIA(SID);
544 SARLUCN(encryptionKey, 12);
545 SARLUIA(_14);
546 SARLUSA(waitTime);
547 SARLUSA(lParameter);
548 SARLUCN(_15, 3);
549 SARLUS(headerSize);
550 SARLUS(sectionChecksum);
551
552 SARLUC(registrationMode);
553 SARLUC(registrationFill);
554 SARLUS(pollPeriod);
555 SARLUS(refreshPeriod);
556 SARLSTR(name, 16);
557 SARLUCN(NID, 6);
558 SARLUC(localTalkAddress);
559 SARLUC(codeFormat);
560 SARLUC(numChannels);
561 SARLUC(channel1);
562 SARLUC(channel2);
563 SARLUC(channel3);
564 SARLUC(channel4);
565 SARLUCN(SSCode, 59);
566
567/* SARLUCN( _16, 0x140);
568 */
569 /* Statistics Block - 0x0300 */
570 SARLUC(hostcpuLock);
571 SARLUC(lancpuLock);
572 SARLUCN(resetTime, 18);
573 SARLUIA(numDatagramsTransmitted);
574 SARLUIA(numReTransmissions);
575 SARLUIA(numFramesDiscarded);
576 SARLUIA(numDatagramsReceived);
577 SARLUIA(numDuplicateReceivedFrames);
578 SARLUIA(numDatagramsDiscarded);
579 SARLUS(maxNumReTransmitDatagram);
580 SARLUS(maxNumReTransmitFrames);
581 SARLUS(maxNumConsecutiveDuplicateFrames);
582 /* misaligned here so we have to go to characters */
583 SARLUIA(numBytesTransmitted);
584 SARLUIA(numBytesReceived);
585 SARLUIA(numCRCErrors);
586 SARLUIA(numLengthErrors);
587 SARLUIA(numAbortErrors);
588 SARLUIA(numTXUnderruns);
589 SARLUIA(numRXOverruns);
590 SARLUIA(numHoldOffs);
591 SARLUIA(numFramesTransmitted);
592 SARLUIA(numFramesReceived);
593 SARLUIA(numReceiveFramesLost);
594 SARLUIA(numRXBufferOverflows);
595 SARLUIA(numFramesDiscardedAddrMismatch);
596 SARLUIA(numFramesDiscardedSIDMismatch);
597 SARLUIA(numPollsTransmistted);
598 SARLUIA(numPollAcknowledges);
599 SARLUIA(numStatusTimeouts);
600 SARLUIA(numNACKReceived);
601 SARLUS(auxCmd);
602 SARLUCN(dumpPtr, 4);
603 SARLUC(dumpVal);
604 SARLUC(wireTest);
605
606 /* next 4 seems too long for procfs, over single page ?
607 SARLUCN( _17, 0x86);
608 SARLUCN( txBuffer, 0x800);
609 SARLUCN( rxBuffer, 0x800);
610 SARLUCN( _18, 0x0bff);
611 */
612
613 pos += sprintf(arlan_drive_info + pos, "rxRing\t=\t0x");
614 for (i = 0; i < 0x50; i++)
615 pos += sprintf(arlan_drive_info + pos, "%02x", ((char *) priva->conf)[priva->conf->rxOffset + i]);
616 pos += sprintf(arlan_drive_info + pos, "\n");
617
618 SARLUC(configStatus);
619 SARLUC(_22);
620 SARLUC(progIOCtrl);
621 SARLUC(shareMBase);
622 SARLUC(controlRegister);
623
624 pos += sprintf(arlan_drive_info + pos, " total %d chars\n", pos);
625 if (ctl)
626 if (ctl->procname)
627 pos += sprintf(arlan_drive_info + pos, " driver name : %s\n", ctl->procname);
628final:
629 *lenp = pos;
630
631 if (!write)
632 retv = proc_dostring(ctl, write, buffer, lenp, ppos);
633 else
634 {
635 *lenp = 0;
636 return -1;
637 }
638 return retv;
639}
640
641
642static int arlan_sysctl_info161719(ctl_table * ctl, int write,
643 void __user *buffer, size_t * lenp, loff_t *ppos)
644{
645 int i;
646 int retv, pos, devnum;
647 struct arlan_private *priva = NULL;
648
649 pos = 0;
650 devnum = ctl->procname[5] - '0';
651 if (arlan_device[devnum] == NULL)
652 {
653 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
654 goto final;
655 }
656 else
657 priva = netdev_priv(arlan_device[devnum]);
658 if (priva == NULL)
659 {
660 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
661 return -1;
662 }
663 memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
664 SARLUCN(_16, 0xC0);
665 SARLUCN(_17, 0x6A);
666 SARLUCN(_18, 14);
667 SARLUCN(_19, 0x86);
668 SARLUCN(_21, 0x3fd);
669
670final:
671 *lenp = pos;
672 retv = proc_dostring(ctl, write, buffer, lenp, ppos);
673 return retv;
674}
675
676static int arlan_sysctl_infotxRing(ctl_table * ctl, int write,
677 void __user *buffer, size_t * lenp, loff_t *ppos)
678{
679 int i;
680 int retv, pos, devnum;
681 struct arlan_private *priva = NULL;
682
683 pos = 0;
684 devnum = ctl->procname[5] - '0';
685 if (arlan_device[devnum] == NULL)
686 {
687 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
688 goto final;
689 }
690 else
691 priva = netdev_priv(arlan_device[devnum]);
692 if (priva == NULL)
693 {
694 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
695 return -1;
696 }
697 memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
698 SARLBNpln(u_char, txBuffer, 0x800);
699final:
700 *lenp = pos;
701 retv = proc_dostring(ctl, write, buffer, lenp, ppos);
702 return retv;
703}
704
705static int arlan_sysctl_inforxRing(ctl_table * ctl, int write,
706 void __user *buffer, size_t * lenp, loff_t *ppos)
707{
708 int i;
709 int retv, pos, devnum;
710 struct arlan_private *priva = NULL;
711
712 pos = 0;
713 devnum = ctl->procname[5] - '0';
714 if (arlan_device[devnum] == NULL)
715 {
716 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
717 goto final;
718 } else
719 priva = netdev_priv(arlan_device[devnum]);
720 if (priva == NULL)
721 {
722 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
723 return -1;
724 }
725 memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
726 SARLBNpln(u_char, rxBuffer, 0x800);
727final:
728 *lenp = pos;
729 retv = proc_dostring(ctl, write, buffer, lenp, ppos);
730 return retv;
731}
732
733static int arlan_sysctl_info18(ctl_table * ctl, int write,
734 void __user *buffer, size_t * lenp, loff_t *ppos)
735{
736 int i;
737 int retv, pos, devnum;
738 struct arlan_private *priva = NULL;
739
740 pos = 0;
741 devnum = ctl->procname[5] - '0';
742 if (arlan_device[devnum] == NULL)
743 {
744 pos += sprintf(arlan_drive_info + pos, "No device found here \n");
745 goto final;
746 }
747 else
748 priva = netdev_priv(arlan_device[devnum]);
749 if (priva == NULL)
750 {
751 printk(KERN_WARNING " Could not find the device private in arlan procsys, bad\n ");
752 return -1;
753 }
754 memcpy_fromio(priva->conf, priva->card, sizeof(struct arlan_shmem));
755 SARLBNpln(u_char, _18, 0x800);
756
757final:
758 *lenp = pos;
759 retv = proc_dostring(ctl, write, buffer, lenp, ppos);
760 return retv;
761}
762
763
764#endif /* #ifdef ARLAN_PROC_SHM_DUMP */
765
766
767static char conf_reset_result[200];
768
769static int arlan_configure(ctl_table * ctl, int write,
770 void __user *buffer, size_t * lenp, loff_t *ppos)
771{
772 int pos = 0;
773 int devnum = ctl->procname[6] - '0';
774 struct arlan_private *priv;
775
776 if (devnum < 0 || devnum > MAX_ARLANS - 1)
777 {
778 printk(KERN_WARNING "too strange devnum in procfs parse\n ");
779 return -1;
780 }
781 else if (arlan_device[devnum] != NULL)
782 {
783 priv = netdev_priv(arlan_device[devnum]);
784
785 arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_CONF);
786 }
787 else
788 return -1;
789
790 *lenp = pos;
791 return proc_dostring(ctl, write, buffer, lenp, ppos);
792}
793
794static int arlan_sysctl_reset(ctl_table * ctl, int write,
795 void __user *buffer, size_t * lenp, loff_t *ppos)
796{
797 int pos = 0;
798 int devnum = ctl->procname[5] - '0';
799 struct arlan_private *priv;
800
801 if (devnum < 0 || devnum > MAX_ARLANS - 1)
802 {
803 printk(KERN_WARNING "too strange devnum in procfs parse\n ");
804 return -1;
805 }
806 else if (arlan_device[devnum] != NULL)
807 {
808 priv = netdev_priv(arlan_device[devnum]);
809 arlan_command(arlan_device[devnum], ARLAN_COMMAND_CLEAN_AND_RESET);
810
811 } else
812 return -1;
813 *lenp = pos + 3;
814 return proc_dostring(ctl, write, buffer, lenp, ppos);
815}
816
817
818/* Place files in /proc/sys/dev/arlan */
819#define CTBLN(num,card,nam) \
820 { .ctl_name = num,\
821 .procname = #nam,\
822 .data = &(arlan_conf[card].nam),\
823 .maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec}
824#ifdef ARLAN_DEBUGGING
825
826#define ARLAN_PROC_DEBUG_ENTRIES \
827 { .ctl_name = 48, .procname = "entry_exit_debug",\
828 .data = &arlan_entry_and_exit_debug,\
829 .maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec},\
830 { .ctl_name = 49, .procname = "debug", .data = &arlan_debug,\
831 .maxlen = sizeof(int), .mode = 0600, .proc_handler = &proc_dointvec},
832#else
833#define ARLAN_PROC_DEBUG_ENTRIES
834#endif
835
836#define ARLAN_SYSCTL_TABLE_TOTAL(cardNo)\
837 CTBLN(1,cardNo,spreadingCode),\
838 CTBLN(2,cardNo, channelNumber),\
839 CTBLN(3,cardNo, scramblingDisable),\
840 CTBLN(4,cardNo, txAttenuation),\
841 CTBLN(5,cardNo, systemId), \
842 CTBLN(6,cardNo, maxDatagramSize),\
843 CTBLN(7,cardNo, maxFrameSize),\
844 CTBLN(8,cardNo, maxRetries),\
845 CTBLN(9,cardNo, receiveMode),\
846 CTBLN(10,cardNo, priority),\
847 CTBLN(11,cardNo, rootOrRepeater),\
848 CTBLN(12,cardNo, SID),\
849 CTBLN(13,cardNo, registrationMode),\
850 CTBLN(14,cardNo, registrationFill),\
851 CTBLN(15,cardNo, localTalkAddress),\
852 CTBLN(16,cardNo, codeFormat),\
853 CTBLN(17,cardNo, numChannels),\
854 CTBLN(18,cardNo, channel1),\
855 CTBLN(19,cardNo, channel2),\
856 CTBLN(20,cardNo, channel3),\
857 CTBLN(21,cardNo, channel4),\
858 CTBLN(22,cardNo, txClear),\
859 CTBLN(23,cardNo, txRetries),\
860 CTBLN(24,cardNo, txRouting),\
861 CTBLN(25,cardNo, txScrambled),\
862 CTBLN(26,cardNo, rxParameter),\
863 CTBLN(27,cardNo, txTimeoutMs),\
864 CTBLN(28,cardNo, waitCardTimeout),\
865 CTBLN(29,cardNo, channelSet), \
866 {.ctl_name = 30, .procname = "name",\
867 .data = arlan_conf[cardNo].siteName,\
868 .maxlen = 16, .mode = 0600, .proc_handler = &proc_dostring},\
869 CTBLN(31,cardNo,waitTime),\
870 CTBLN(32,cardNo,lParameter),\
871 CTBLN(33,cardNo,_15),\
872 CTBLN(34,cardNo,headerSize),\
873 CTBLN(36,cardNo,tx_delay_ms),\
874 CTBLN(37,cardNo,retries),\
875 CTBLN(38,cardNo,ReTransmitPacketMaxSize),\
876 CTBLN(39,cardNo,waitReTransmitPacketMaxSize),\
877 CTBLN(40,cardNo,fastReTransCount),\
878 CTBLN(41,cardNo,driverRetransmissions),\
879 CTBLN(42,cardNo,txAckTimeoutMs),\
880 CTBLN(43,cardNo,registrationInterrupts),\
881 CTBLN(44,cardNo,hardwareType),\
882 CTBLN(45,cardNo,radioType),\
883 CTBLN(46,cardNo,writeEEPROM),\
884 CTBLN(47,cardNo,writeRadioType),\
885 ARLAN_PROC_DEBUG_ENTRIES\
886 CTBLN(50,cardNo,in_speed),\
887 CTBLN(51,cardNo,out_speed),\
888 CTBLN(52,cardNo,in_speed10),\
889 CTBLN(53,cardNo,out_speed10),\
890 CTBLN(54,cardNo,in_speed_max),\
891 CTBLN(55,cardNo,out_speed_max),\
892 CTBLN(56,cardNo,measure_rate),\
893 CTBLN(57,cardNo,pre_Command_Wait),\
894 CTBLN(58,cardNo,rx_tweak1),\
895 CTBLN(59,cardNo,rx_tweak2),\
896 CTBLN(60,cardNo,tx_queue_len),\
897
898
899
900static ctl_table arlan_conf_table0[] =
901{
902 ARLAN_SYSCTL_TABLE_TOTAL(0)
903
904#ifdef ARLAN_PROC_SHM_DUMP
905 {
906 .ctl_name = 150,
907 .procname = "arlan0-txRing",
908 .data = &arlan_drive_info,
909 .maxlen = ARLAN_STR_SIZE,
910 .mode = 0400,
911 .proc_handler = &arlan_sysctl_infotxRing,
912 },
913 {
914 .ctl_name = 151,
915 .procname = "arlan0-rxRing",
916 .data = &arlan_drive_info,
917 .maxlen = ARLAN_STR_SIZE,
918 .mode = 0400,
919 .proc_handler = &arlan_sysctl_inforxRing,
920 },
921 {
922 .ctl_name = 152,
923 .procname = "arlan0-18",
924 .data = &arlan_drive_info,
925 .maxlen = ARLAN_STR_SIZE,
926 .mode = 0400,
927 .proc_handler = &arlan_sysctl_info18,
928 },
929 {
930 .ctl_name = 153,
931 .procname = "arlan0-ring",
932 .data = &arlan_drive_info,
933 .maxlen = ARLAN_STR_SIZE,
934 .mode = 0400,
935 .proc_handler = &arlan_sysctl_info161719,
936 },
937 {
938 .ctl_name = 154,
939 .procname = "arlan0-shm-cpy",
940 .data = &arlan_drive_info,
941 .maxlen = ARLAN_STR_SIZE,
942 .mode = 0400,
943 .proc_handler = &arlan_sysctl_info,
944 },
945#endif
946 {
947 .ctl_name = 155,
948 .procname = "config0",
949 .data = &conf_reset_result,
950 .maxlen = 100,
951 .mode = 0400,
952 .proc_handler = &arlan_configure
953 },
954 {
955 .ctl_name = 156,
956 .procname = "reset0",
957 .data = &conf_reset_result,
958 .maxlen = 100,
959 .mode = 0400,
960 .proc_handler = &arlan_sysctl_reset,
961 },
962 { .ctl_name = 0 }
963};
964
965static ctl_table arlan_conf_table1[] =
966{
967
968 ARLAN_SYSCTL_TABLE_TOTAL(1)
969
970#ifdef ARLAN_PROC_SHM_DUMP
971 {
972 .ctl_name = 150,
973 .procname = "arlan1-txRing",
974 .data = &arlan_drive_info,
975 .maxlen = ARLAN_STR_SIZE,
976 .mode = 0400,
977 .proc_handler = &arlan_sysctl_infotxRing,
978 },
979 {
980 .ctl_name = 151,
981 .procname = "arlan1-rxRing",
982 .data = &arlan_drive_info,
983 .maxlen = ARLAN_STR_SIZE,
984 .mode = 0400,
985 .proc_handler = &arlan_sysctl_inforxRing,
986 },
987 {
988 .ctl_name = 152,
989 .procname = "arlan1-18",
990 .data = &arlan_drive_info,
991 .maxlen = ARLAN_STR_SIZE,
992 .mode = 0400,
993 .proc_handler = &arlan_sysctl_info18,
994 },
995 {
996 .ctl_name = 153,
997 .procname = "arlan1-ring",
998 .data = &arlan_drive_info,
999 .maxlen = ARLAN_STR_SIZE,
1000 .mode = 0400,
1001 .proc_handler = &arlan_sysctl_info161719,
1002 },
1003 {
1004 .ctl_name = 154,
1005 .procname = "arlan1-shm-cpy",
1006 .data = &arlan_drive_info,
1007 .maxlen = ARLAN_STR_SIZE,
1008 .mode = 0400,
1009 .proc_handler = &arlan_sysctl_info,
1010 },
1011#endif
1012 {
1013 .ctl_name = 155,
1014 .procname = "config1",
1015 .data = &conf_reset_result,
1016 .maxlen = 100,
1017 .mode = 0400,
1018 .proc_handler = &arlan_configure,
1019 },
1020 {
1021 .ctl_name = 156,
1022 .procname = "reset1",
1023 .data = &conf_reset_result,
1024 .maxlen = 100,
1025 .mode = 0400,
1026 .proc_handler = &arlan_sysctl_reset,
1027 },
1028 { .ctl_name = 0 }
1029};
1030
1031static ctl_table arlan_conf_table2[] =
1032{
1033
1034 ARLAN_SYSCTL_TABLE_TOTAL(2)
1035
1036#ifdef ARLAN_PROC_SHM_DUMP
1037 {
1038 .ctl_name = 150,
1039 .procname = "arlan2-txRing",
1040 .data = &arlan_drive_info,
1041 .maxlen = ARLAN_STR_SIZE,
1042 .mode = 0400,
1043 .proc_handler = &arlan_sysctl_infotxRing,
1044 },
1045 {
1046 .ctl_name = 151,
1047 .procname = "arlan2-rxRing",
1048 .data = &arlan_drive_info,
1049 .maxlen = ARLAN_STR_SIZE,
1050 .mode = 0400,
1051 .proc_handler = &arlan_sysctl_inforxRing,
1052 },
1053 {
1054 .ctl_name = 152,
1055 .procname = "arlan2-18",
1056 .data = &arlan_drive_info,
1057 .maxlen = ARLAN_STR_SIZE,
1058 .mode = 0400,
1059 .proc_handler = &arlan_sysctl_info18,
1060 },
1061 {
1062 .ctl_name = 153,
1063 .procname = "arlan2-ring",
1064 .data = &arlan_drive_info,
1065 .maxlen = ARLAN_STR_SIZE,
1066 .mode = 0400,
1067 .proc_handler = &arlan_sysctl_info161719,
1068 },
1069 {
1070 .ctl_name = 154,
1071 .procname = "arlan2-shm-cpy",
1072 .data = &arlan_drive_info,
1073 .maxlen = ARLAN_STR_SIZE,
1074 .mode = 0400,
1075 .proc_handler = &arlan_sysctl_info,
1076 },
1077#endif
1078 {
1079 .ctl_name = 155,
1080 .procname = "config2",
1081 .data = &conf_reset_result,
1082 .maxlen = 100,
1083 .mode = 0400,
1084 .proc_handler = &arlan_configure,
1085 },
1086 {
1087 .ctl_name = 156,
1088 .procname = "reset2",
1089 .data = &conf_reset_result,
1090 .maxlen = 100,
1091 .mode = 0400,
1092 .proc_handler = &arlan_sysctl_reset,
1093 },
1094 { .ctl_name = 0 }
1095};
1096
1097static ctl_table arlan_conf_table3[] =
1098{
1099
1100 ARLAN_SYSCTL_TABLE_TOTAL(3)
1101
1102#ifdef ARLAN_PROC_SHM_DUMP
1103 {
1104 .ctl_name = 150,
1105 .procname = "arlan3-txRing",
1106 .data = &arlan_drive_info,
1107 .maxlen = ARLAN_STR_SIZE,
1108 .mode = 0400,
1109 .proc_handler = &arlan_sysctl_infotxRing,
1110 },
1111 {
1112 .ctl_name = 151,
1113 .procname = "arlan3-rxRing",
1114 .data = &arlan_drive_info,
1115 .maxlen = ARLAN_STR_SIZE,
1116 .mode = 0400,
1117 .proc_handler = &arlan_sysctl_inforxRing,
1118 },
1119 {
1120 .ctl_name = 152,
1121 .procname = "arlan3-18",
1122 .data = &arlan_drive_info,
1123 .maxlen = ARLAN_STR_SIZE,
1124 .mode = 0400,
1125 .proc_handler = &arlan_sysctl_info18,
1126 },
1127 {
1128 .ctl_name = 153,
1129 .procname = "arlan3-ring",
1130 .data = &arlan_drive_info,
1131 .maxlen = ARLAN_STR_SIZE,
1132 .mode = 0400,
1133 .proc_handler = &arlan_sysctl_info161719,
1134 },
1135 {
1136 .ctl_name = 154,
1137 .procname = "arlan3-shm-cpy",
1138 .data = &arlan_drive_info,
1139 .maxlen = ARLAN_STR_SIZE,
1140 .mode = 0400,
1141 .proc_handler = &arlan_sysctl_info,
1142 },
1143#endif
1144 {
1145 .ctl_name = 155,
1146 .procname = "config3",
1147 .data = &conf_reset_result,
1148 .maxlen = 100,
1149 .mode = 0400,
1150 .proc_handler = &arlan_configure,
1151 },
1152 {
1153 .ctl_name = 156,
1154 .procname = "reset3",
1155 .data = &conf_reset_result,
1156 .maxlen = 100,
1157 .mode = 0400,
1158 .proc_handler = &arlan_sysctl_reset,
1159 },
1160 { .ctl_name = 0 }
1161};
1162
1163
1164
1165static ctl_table arlan_table[] =
1166{
1167 {
1168 .ctl_name = 0,
1169 .procname = "arlan0",
1170 .maxlen = 0,
1171 .mode = 0600,
1172 .child = arlan_conf_table0,
1173 },
1174 {
1175 .ctl_name = 0,
1176 .procname = "arlan1",
1177 .maxlen = 0,
1178 .mode = 0600,
1179 .child = arlan_conf_table1,
1180 },
1181 {
1182 .ctl_name = 0,
1183 .procname = "arlan2",
1184 .maxlen = 0,
1185 .mode = 0600,
1186 .child = arlan_conf_table2,
1187 },
1188 {
1189 .ctl_name = 0,
1190 .procname = "arlan3",
1191 .maxlen = 0,
1192 .mode = 0600,
1193 .child = arlan_conf_table3,
1194 },
1195 { .ctl_name = 0 }
1196};
1197
1198#else
1199
1200static ctl_table arlan_table[MAX_ARLANS + 1] =
1201{
1202 { .ctl_name = 0 }
1203};
1204#endif
1205
1206
1207// static int mmtu = 1234;
1208
1209static ctl_table arlan_root_table[] =
1210{
1211 {
1212 .ctl_name = CTL_ARLAN,
1213 .procname = "arlan",
1214 .maxlen = 0,
1215 .mode = 0555,
1216 .child = arlan_table,
1217 },
1218 { .ctl_name = 0 }
1219};
1220
1221/* Make sure that /proc/sys/dev is there */
1222//static ctl_table arlan_device_root_table[] =
1223//{
1224// {CTL_DEV, "dev", NULL, 0, 0555, arlan_root_table},
1225// {0}
1226//};
1227
1228
1229static struct ctl_table_header *arlan_device_sysctl_header;
1230
1231int __init init_arlan_proc(void)
1232{
1233
1234 int i = 0;
1235 if (arlan_device_sysctl_header)
1236 return 0;
1237 for (i = 0; i < MAX_ARLANS && arlan_device[i]; i++)
1238 arlan_table[i].ctl_name = i + 1;
1239 arlan_device_sysctl_header = register_sysctl_table(arlan_root_table);
1240 if (!arlan_device_sysctl_header)
1241 return -1;
1242
1243 return 0;
1244
1245}
1246
1247void __exit cleanup_arlan_proc(void)
1248{
1249 unregister_sysctl_table(arlan_device_sysctl_header);
1250 arlan_device_sysctl_header = NULL;
1251
1252}
1253#endif
diff --git a/drivers/net/wireless/arlan.h b/drivers/net/wireless/arlan.h
deleted file mode 100644
index fb3ad51a1caf..000000000000
--- a/drivers/net/wireless/arlan.h
+++ /dev/null
@@ -1,539 +0,0 @@
1/*
2 * Copyright (C) 1997 Cullen Jennings
3 * Copyright (C) 1998 Elmer.Joandi@ut.ee, +37-255-13500
4 * GNU General Public License applies
5 */
6
7#include <linux/module.h>
8#include <linux/kernel.h>
9#include <linux/types.h>
10#include <linux/skbuff.h>
11#include <linux/if_ether.h> /* For the statistics structure. */
12#include <linux/if_arp.h> /* For ARPHRD_ETHER */
13#include <linux/ptrace.h>
14#include <linux/ioport.h>
15#include <linux/in.h>
16#include <linux/slab.h>
17#include <linux/string.h>
18#include <linux/timer.h>
19
20#include <linux/init.h>
21#include <linux/bitops.h>
22#include <asm/system.h>
23#include <asm/io.h>
24#include <linux/errno.h>
25#include <linux/delay.h>
26#include <linux/netdevice.h>
27#include <linux/etherdevice.h>
28
29
30//#define ARLAN_DEBUGGING 1
31
32#define ARLAN_PROC_INTERFACE
33#define MAX_ARLANS 4 /* not more than 4 ! */
34#define ARLAN_PROC_SHM_DUMP /* shows all card registers, makes driver way larger */
35
36#define ARLAN_MAX_MULTICAST_ADDRS 16
37#define ARLAN_RCV_CLEAN 0
38#define ARLAN_RCV_PROMISC 1
39#define ARLAN_RCV_CONTROL 2
40
41#ifdef CONFIG_PROC_FS
42extern int init_arlan_proc(void);
43extern void cleanup_arlan_proc(void);
44#else
45#define init_arlan_proc() ({ 0; })
46#define cleanup_arlan_proc() do { } while (0)
47#endif
48
49extern struct net_device *arlan_device[MAX_ARLANS];
50extern int arlan_debug;
51extern int arlan_entry_debug;
52extern int arlan_exit_debug;
53extern int testMemory;
54extern int arlan_command(struct net_device * dev, int command);
55
56#define SIDUNKNOWN -1
57#define radioNodeIdUNKNOWN -1
58#define irqUNKNOWN 0
59#define debugUNKNOWN 0
60#define testMemoryUNKNOWN 1
61#define spreadingCodeUNKNOWN 0
62#define channelNumberUNKNOWN 0
63#define channelSetUNKNOWN 0
64#define systemIdUNKNOWN -1
65#define registrationModeUNKNOWN -1
66
67
68#define IFDEBUG( L ) if ( (L) & arlan_debug )
69#define ARLAN_FAKE_HDR_LEN 12
70
71#ifdef ARLAN_DEBUGGING
72 #define DEBUG 1
73 #define ARLAN_ENTRY_EXIT_DEBUGGING 1
74 #define ARLAN_DEBUG(a,b) printk(KERN_DEBUG a, b)
75#else
76 #define ARLAN_DEBUG(a,b)
77#endif
78
79#define ARLAN_SHMEM_SIZE 0x2000
80
81struct arlan_shmem
82{
83 /* Header Signature */
84 volatile char textRegion[48];
85 volatile u_char resetFlag;
86 volatile u_char diagnosticInfo;
87 volatile u_short diagnosticOffset;
88 volatile u_char _1[12];
89 volatile u_char lanCardNodeId[6];
90 volatile u_char broadcastAddress[6];
91 volatile u_char hardwareType;
92 volatile u_char majorHardwareVersion;
93 volatile u_char minorHardwareVersion;
94 volatile u_char radioModule;// shows EEPROM, can be overridden at 0x111
95 volatile u_char defaultChannelSet; // shows EEProm, can be overriiden at 0x10A
96 volatile u_char _2[47];
97
98 /* Control/Status Block - 0x0080 */
99 volatile u_char interruptInProgress; /* not used by lancpu */
100 volatile u_char cntrlRegImage; /* not used by lancpu */
101 volatile u_char _3[13];
102 volatile u_char dumpByte;
103 volatile u_char commandByte; /* non-zero = active */
104 volatile u_char commandParameter[15];
105
106 /* Receive Status - 0x00a0 */
107 volatile u_char rxStatus; /* 1- data, 2-control, 0xff - registr change */
108 volatile u_char rxFrmType;
109 volatile u_short rxOffset;
110 volatile u_short rxLength;
111 volatile u_char rxSrc[6];
112 volatile u_char rxBroadcastFlag;
113 volatile u_char rxQuality;
114 volatile u_char scrambled;
115 volatile u_char _4[1];
116
117 /* Transmit Status - 0x00b0 */
118 volatile u_char txStatus;
119 volatile u_char txAckQuality;
120 volatile u_char numRetries;
121 volatile u_char _5[14];
122 volatile u_char registeredRouter[6];
123 volatile u_char backboneRouter[6];
124 volatile u_char registrationStatus;
125 volatile u_char configuredStatusFlag;
126 volatile u_char _6[1];
127 volatile u_char ultimateDestAddress[6];
128 volatile u_char immedDestAddress[6];
129 volatile u_char immedSrcAddress[6];
130 volatile u_short rxSequenceNumber;
131 volatile u_char assignedLocaltalkAddress;
132 volatile u_char _7[27];
133
134 /* System Parameter Block */
135
136 /* - Driver Parameters (Novell Specific) */
137
138 volatile u_short txTimeout;
139 volatile u_short transportTime;
140 volatile u_char _8[4];
141
142 /* - Configuration Parameters */
143 volatile u_char irqLevel;
144 volatile u_char spreadingCode;
145 volatile u_char channelSet;
146 volatile u_char channelNumber;
147 volatile u_short radioNodeId;
148 volatile u_char _9[2];
149 volatile u_char scramblingDisable;
150 volatile u_char radioType;
151 volatile u_short routerId;
152 volatile u_char _10[9];
153 volatile u_char txAttenuation;
154 volatile u_char systemId[4];
155 volatile u_short globalChecksum;
156 volatile u_char _11[4];
157 volatile u_short maxDatagramSize;
158 volatile u_short maxFrameSize;
159 volatile u_char maxRetries;
160 volatile u_char receiveMode;
161 volatile u_char priority;
162 volatile u_char rootOrRepeater;
163 volatile u_char specifiedRouter[6];
164 volatile u_short fastPollPeriod;
165 volatile u_char pollDecay;
166 volatile u_char fastPollDelay[2];
167 volatile u_char arlThreshold;
168 volatile u_char arlDecay;
169 volatile u_char _12[1];
170 volatile u_short specRouterTimeout;
171 volatile u_char _13[5];
172
173 /* Scrambled Area */
174 volatile u_char SID[4];
175 volatile u_char encryptionKey[12];
176 volatile u_char _14[2];
177 volatile u_char waitTime[2];
178 volatile u_char lParameter[2];
179 volatile u_char _15[3];
180 volatile u_short headerSize;
181 volatile u_short sectionChecksum;
182
183 volatile u_char registrationMode;
184 volatile u_char registrationFill;
185 volatile u_short pollPeriod;
186 volatile u_short refreshPeriod;
187 volatile u_char name[16];
188 volatile u_char NID[6];
189 volatile u_char localTalkAddress;
190 volatile u_char codeFormat;
191 volatile u_char numChannels;
192 volatile u_char channel1;
193 volatile u_char channel2;
194 volatile u_char channel3;
195 volatile u_char channel4;
196 volatile u_char SSCode[59];
197
198 volatile u_char _16[0xC0];
199 volatile u_short auxCmd;
200 volatile u_char dumpPtr[4];
201 volatile u_char dumpVal;
202 volatile u_char _17[0x6A];
203 volatile u_char wireTest;
204 volatile u_char _18[14];
205
206 /* Statistics Block - 0x0300 */
207 volatile u_char hostcpuLock;
208 volatile u_char lancpuLock;
209 volatile u_char resetTime[18];
210
211 volatile u_char numDatagramsTransmitted[4];
212 volatile u_char numReTransmissions[4];
213 volatile u_char numFramesDiscarded[4];
214 volatile u_char numDatagramsReceived[4];
215 volatile u_char numDuplicateReceivedFrames[4];
216 volatile u_char numDatagramsDiscarded[4];
217
218 volatile u_short maxNumReTransmitDatagram;
219 volatile u_short maxNumReTransmitFrames;
220 volatile u_short maxNumConsecutiveDuplicateFrames;
221 /* misaligned here so we have to go to characters */
222
223 volatile u_char numBytesTransmitted[4];
224 volatile u_char numBytesReceived[4];
225 volatile u_char numCRCErrors[4];
226 volatile u_char numLengthErrors[4];
227 volatile u_char numAbortErrors[4];
228 volatile u_char numTXUnderruns[4];
229 volatile u_char numRXOverruns[4];
230 volatile u_char numHoldOffs[4];
231 volatile u_char numFramesTransmitted[4];
232 volatile u_char numFramesReceived[4];
233 volatile u_char numReceiveFramesLost[4];
234 volatile u_char numRXBufferOverflows[4];
235 volatile u_char numFramesDiscardedAddrMismatch[4];
236 volatile u_char numFramesDiscardedSIDMismatch[4];
237 volatile u_char numPollsTransmistted[4];
238 volatile u_char numPollAcknowledges[4];
239 volatile u_char numStatusTimeouts[4];
240 volatile u_char numNACKReceived[4];
241
242 volatile u_char _19[0x86];
243
244 volatile u_char txBuffer[0x800];
245 volatile u_char rxBuffer[0x800];
246
247 volatile u_char _20[0x800];
248 volatile u_char _21[0x3fb];
249 volatile u_char configStatus;
250 volatile u_char _22;
251 volatile u_char progIOCtrl;
252 volatile u_char shareMBase;
253 volatile u_char controlRegister;
254};
255
256struct arlan_conf_stru {
257 int spreadingCode;
258 int channelSet;
259 int channelNumber;
260 int scramblingDisable;
261 int txAttenuation;
262 int systemId;
263 int maxDatagramSize;
264 int maxFrameSize;
265 int maxRetries;
266 int receiveMode;
267 int priority;
268 int rootOrRepeater;
269 int SID;
270 int radioNodeId;
271 int registrationMode;
272 int registrationFill;
273 int localTalkAddress;
274 int codeFormat;
275 int numChannels;
276 int channel1;
277 int channel2;
278 int channel3;
279 int channel4;
280 int txClear;
281 int txRetries;
282 int txRouting;
283 int txScrambled;
284 int rxParameter;
285 int txTimeoutMs;
286 int txAckTimeoutMs;
287 int waitCardTimeout;
288 int waitTime;
289 int lParameter;
290 int _15;
291 int headerSize;
292 int retries;
293 int tx_delay_ms;
294 int waitReTransmitPacketMaxSize;
295 int ReTransmitPacketMaxSize;
296 int fastReTransCount;
297 int driverRetransmissions;
298 int registrationInterrupts;
299 int hardwareType;
300 int radioType;
301 int writeRadioType;
302 int writeEEPROM;
303 char siteName[17];
304 int measure_rate;
305 int in_speed;
306 int out_speed;
307 int in_speed10;
308 int out_speed10;
309 int in_speed_max;
310 int out_speed_max;
311 int pre_Command_Wait;
312 int rx_tweak1;
313 int rx_tweak2;
314 int tx_queue_len;
315};
316
317extern struct arlan_conf_stru arlan_conf[MAX_ARLANS];
318
319struct TxParam
320{
321 volatile short offset;
322 volatile short length;
323 volatile u_char dest[6];
324 volatile unsigned char clear;
325 volatile unsigned char retries;
326 volatile unsigned char routing;
327 volatile unsigned char scrambled;
328};
329
330#define TX_RING_SIZE 2
331/* Information that need to be kept for each board. */
332struct arlan_private {
333 struct arlan_shmem __iomem * card;
334 struct arlan_shmem * conf;
335
336 struct arlan_conf_stru * Conf;
337 int bad;
338 int reset;
339 unsigned long lastReset;
340 struct timer_list timer;
341 struct timer_list tx_delay_timer;
342 struct timer_list tx_retry_timer;
343 struct timer_list rx_check_timer;
344
345 int registrationLostCount;
346 int reRegisterExp;
347 int irq_test_done;
348
349 struct TxParam txRing[TX_RING_SIZE];
350 char reTransmitBuff[0x800];
351 int txLast;
352 unsigned ReTransmitRequested;
353 unsigned long tx_done_delayed;
354 unsigned long registrationLastSeen;
355
356 unsigned long tx_last_sent;
357 unsigned long tx_last_cleared;
358 unsigned long retransmissions;
359 unsigned long interrupt_ack_requested;
360 spinlock_t lock;
361 unsigned long waiting_command_mask;
362 unsigned long card_polling_interval;
363 unsigned long last_command_buff_free_time;
364
365 int under_reset;
366 int under_config;
367 int rx_command_given;
368 int tx_command_given;
369 unsigned long interrupt_processing_active;
370 unsigned long last_rx_int_ack_time;
371 unsigned long in_bytes;
372 unsigned long out_bytes;
373 unsigned long in_time;
374 unsigned long out_time;
375 unsigned long in_time10;
376 unsigned long out_time10;
377 unsigned long in_bytes10;
378 unsigned long out_bytes10;
379 int init_etherdev_alloc;
380};
381
382
383
384#define ARLAN_CLEAR 0x00
385#define ARLAN_RESET 0x01
386#define ARLAN_CHANNEL_ATTENTION 0x02
387#define ARLAN_INTERRUPT_ENABLE 0x04
388#define ARLAN_CLEAR_INTERRUPT 0x08
389#define ARLAN_POWER 0x40
390#define ARLAN_ACCESS 0x80
391
392#define ARLAN_COM_CONF 0x01
393#define ARLAN_COM_RX_ENABLE 0x03
394#define ARLAN_COM_RX_ABORT 0x04
395#define ARLAN_COM_TX_ENABLE 0x05
396#define ARLAN_COM_TX_ABORT 0x06
397#define ARLAN_COM_NOP 0x07
398#define ARLAN_COM_STANDBY 0x08
399#define ARLAN_COM_ACTIVATE 0x09
400#define ARLAN_COM_GOTO_SLOW_POLL 0x0a
401#define ARLAN_COM_INT 0x80
402
403
404#define TXLAST(dev) (((struct arlan_private *)netdev_priv(dev))->txRing[((struct arlan_private *)netdev_priv(dev))->txLast])
405#define TXHEAD(dev) (((struct arlan_private *)netdev_priv(dev))->txRing[0])
406#define TXTAIL(dev) (((struct arlan_private *)netdev_priv(dev))->txRing[1])
407
408#define TXBuffStart(dev) offsetof(struct arlan_shmem, txBuffer)
409#define TXBuffEnd(dev) offsetof(struct arlan_shmem, xxBuffer)
410
411#define READSHM(to,from,atype) {\
412 atype tmp;\
413 memcpy_fromio(&(tmp),&(from),sizeof(atype));\
414 to = tmp;\
415 }
416
417#define READSHMEM(from,atype)\
418 atype from; \
419 READSHM(from, arlan->from, atype);
420
421#define WRITESHM(to,from,atype) \
422 { atype tmpSHM = from;\
423 memcpy_toio(&(to),&tmpSHM,sizeof(atype));\
424 }
425
426#define DEBUGSHM(levelSHM,stringSHM,stuff,atype) \
427 { atype tmpSHM; \
428 memcpy_fromio(&tmpSHM,&(stuff),sizeof(atype));\
429 IFDEBUG(levelSHM) printk(stringSHM,tmpSHM);\
430 }
431
432#define WRITESHMB(to, val) \
433 writeb(val,&(to))
434#define READSHMB(to) \
435 readb(&(to))
436#define WRITESHMS(to, val) \
437 writew(val,&(to))
438#define READSHMS(to) \
439 readw(&(to))
440#define WRITESHMI(to, val) \
441 writel(val,&(to))
442#define READSHMI(to) \
443 readl(&(to))
444
445
446
447
448
449#define registrationBad(dev)\
450 ( ( READSHMB(((struct arlan_private *)netdev_priv(dev))->card->registrationMode) > 0) && \
451 ( READSHMB(((struct arlan_private *)netdev_priv(dev))->card->registrationStatus) == 0) )
452
453
454#define readControlRegister(dev)\
455 READSHMB(((struct arlan_private *)netdev_priv(dev))->card->cntrlRegImage)
456
457#define writeControlRegister(dev, v){\
458 WRITESHMB(((struct arlan_private *)netdev_priv(dev))->card->cntrlRegImage ,((v) &0xF) );\
459 WRITESHMB(((struct arlan_private *)netdev_priv(dev))->card->controlRegister ,(v) );}
460
461
462#define arlan_interrupt_lancpu(dev) {\
463 int cr; \
464 \
465 cr = readControlRegister(dev);\
466 if (cr & ARLAN_CHANNEL_ATTENTION){ \
467 writeControlRegister(dev, (cr & ~ARLAN_CHANNEL_ATTENTION));\
468 }else \
469 writeControlRegister(dev, (cr | ARLAN_CHANNEL_ATTENTION));\
470}
471
472#define clearChannelAttention(dev){ \
473 writeControlRegister(dev,readControlRegister(dev) & ~ARLAN_CHANNEL_ATTENTION);}
474#define setHardwareReset(dev) {\
475 writeControlRegister(dev,readControlRegister(dev) | ARLAN_RESET);}
476#define clearHardwareReset(dev) {\
477 writeControlRegister(dev,readControlRegister(dev) & ~ARLAN_RESET);}
478#define setInterruptEnable(dev){\
479 writeControlRegister(dev,readControlRegister(dev) | ARLAN_INTERRUPT_ENABLE) ;}
480#define clearInterruptEnable(dev){\
481 writeControlRegister(dev,readControlRegister(dev) & ~ARLAN_INTERRUPT_ENABLE) ;}
482#define setClearInterrupt(dev){\
483 writeControlRegister(dev,readControlRegister(dev) | ARLAN_CLEAR_INTERRUPT) ;}
484#define clearClearInterrupt(dev){\
485 writeControlRegister(dev,readControlRegister(dev) & ~ARLAN_CLEAR_INTERRUPT);}
486#define setPowerOff(dev){\
487 writeControlRegister(dev,readControlRegister(dev) | (ARLAN_POWER && ARLAN_ACCESS));\
488 writeControlRegister(dev,readControlRegister(dev) & ~ARLAN_ACCESS);}
489#define setPowerOn(dev){\
490 writeControlRegister(dev,readControlRegister(dev) & ~(ARLAN_POWER)); }
491#define arlan_lock_card_access(dev){\
492 writeControlRegister(dev,readControlRegister(dev) & ~ARLAN_ACCESS);}
493#define arlan_unlock_card_access(dev){\
494 writeControlRegister(dev,readControlRegister(dev) | ARLAN_ACCESS ); }
495
496
497
498
499#define ARLAN_COMMAND_RX 0x000001
500#define ARLAN_COMMAND_NOOP 0x000002
501#define ARLAN_COMMAND_NOOPINT 0x000004
502#define ARLAN_COMMAND_TX 0x000008
503#define ARLAN_COMMAND_CONF 0x000010
504#define ARLAN_COMMAND_RESET 0x000020
505#define ARLAN_COMMAND_TX_ABORT 0x000040
506#define ARLAN_COMMAND_RX_ABORT 0x000080
507#define ARLAN_COMMAND_POWERDOWN 0x000100
508#define ARLAN_COMMAND_POWERUP 0x000200
509#define ARLAN_COMMAND_SLOW_POLL 0x000400
510#define ARLAN_COMMAND_ACTIVATE 0x000800
511#define ARLAN_COMMAND_INT_ACK 0x001000
512#define ARLAN_COMMAND_INT_ENABLE 0x002000
513#define ARLAN_COMMAND_WAIT_NOW 0x004000
514#define ARLAN_COMMAND_LONG_WAIT_NOW 0x008000
515#define ARLAN_COMMAND_STANDBY 0x010000
516#define ARLAN_COMMAND_INT_RACK 0x020000
517#define ARLAN_COMMAND_INT_RENABLE 0x040000
518#define ARLAN_COMMAND_CONF_WAIT 0x080000
519#define ARLAN_COMMAND_TBUSY_CLEAR 0x100000
520#define ARLAN_COMMAND_CLEAN_AND_CONF (ARLAN_COMMAND_TX_ABORT\
521 | ARLAN_COMMAND_RX_ABORT\
522 | ARLAN_COMMAND_CONF)
523#define ARLAN_COMMAND_CLEAN_AND_RESET (ARLAN_COMMAND_TX_ABORT\
524 | ARLAN_COMMAND_RX_ABORT\
525 | ARLAN_COMMAND_RESET)
526
527
528
529#define ARLAN_DEBUG_CHAIN_LOCKS 0x00001
530#define ARLAN_DEBUG_RESET 0x00002
531#define ARLAN_DEBUG_TIMING 0x00004
532#define ARLAN_DEBUG_CARD_STATE 0x00008
533#define ARLAN_DEBUG_TX_CHAIN 0x00010
534#define ARLAN_DEBUG_MULTICAST 0x00020
535#define ARLAN_DEBUG_HEADER_DUMP 0x00040
536#define ARLAN_DEBUG_INTERRUPT 0x00080
537#define ARLAN_DEBUG_STARTUP 0x00100
538#define ARLAN_DEBUG_SHUTDOWN 0x00200
539
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-09 15:05:55 -0400