2 * Copyright (C) 1997 Cullen Jennings
3 * Copyright (C) 1998 Elmer Joandiu, elmer@ylenurme.ee
4 * Gnu Public License applies
5 * This module provides support for the Arlan 655 card made by Aironet
8 #include <linux/config.h>
11 static const char *arlan_version
= "C.Jennigs 97 & Elmer.Joandi@ut.ee Oct'98, http://www.ylenurme.ee/~elmer/655/";
13 struct net_device
*arlan_device
[MAX_ARLANS
];
16 static int SID
= SIDUNKNOWN
;
17 static int radioNodeId
= radioNodeIdUNKNOWN
;
18 static char encryptionKey
[12] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
19 static char *siteName
= siteNameUNKNOWN
;
20 static int mem
= memUNKNOWN
;
21 int arlan_debug
= debugUNKNOWN
;
22 static int probe
= probeUNKNOWN
;
23 static int numDevices
= numDevicesUNKNOWN
;
24 static int spreadingCode
= spreadingCodeUNKNOWN
;
25 static int channelNumber
= channelNumberUNKNOWN
;
26 static int channelSet
= channelSetUNKNOWN
;
27 static int systemId
= systemIdUNKNOWN
;
28 static int registrationMode
= registrationModeUNKNOWN
;
29 static int keyStart
= 0;
30 static int tx_delay_ms
= 0;
31 static int retries
= 5;
33 static int tx_queue_len
= 1;
34 static int arlan_EEPROM_bad
= 0;
35 int arlan_entry_and_exit_debug
= 0;
39 static int arlan_entry_debug
= 0;
40 static int arlan_exit_debug
= 0;
41 static int testMemory
= testMemoryUNKNOWN
;
42 static int irq
= irqUNKNOWN
;
43 static int txScrambled
= 1;
44 static int mdebug
= 0;
47 #if LINUX_VERSION_CODE > 0x20100
48 MODULE_PARM(irq
, "i");
49 MODULE_PARM(mem
, "i");
50 MODULE_PARM(probe
, "i");
51 MODULE_PARM(arlan_debug
, "i");
52 MODULE_PARM(numDevices
, "i");
53 MODULE_PARM(testMemory
, "i");
54 MODULE_PARM(spreadingCode
, "i");
55 MODULE_PARM(channelNumber
, "i");
56 MODULE_PARM(channelSet
, "i");
57 MODULE_PARM(systemId
, "i");
58 MODULE_PARM(registrationMode
, "i");
59 MODULE_PARM(radioNodeId
, "i");
60 MODULE_PARM(SID
, "i");
61 MODULE_PARM(txScrambled
, "i");
62 MODULE_PARM(keyStart
, "i");
63 MODULE_PARM(mdebug
, "i");
64 MODULE_PARM(tx_delay_ms
, "i");
65 MODULE_PARM(retries
, "i");
66 MODULE_PARM(async
, "i");
67 MODULE_PARM(tx_queue_len
, "i");
68 MODULE_PARM(arlan_entry_debug
, "i");
69 MODULE_PARM(arlan_exit_debug
, "i");
70 MODULE_PARM(arlan_entry_and_exit_debug
, "i");
71 MODULE_PARM(arlan_EEPROM_bad
, "i");
73 EXPORT_SYMBOL(arlan_device
);
74 EXPORT_SYMBOL(last_arlan
);
77 // #warning kernel 2.1.110 tested
78 #define myATOMIC_INIT(a,b) atomic_set(&(a),b)
81 #define test_and_set_bit set_bit
82 #if LINUX_VERSION_CODE != 0x20024
83 // #warning kernel 2.0.36 tested
85 #define myATOMIC_INIT(a,b) a = b;
89 struct arlan_conf_stru arlan_conf
[MAX_ARLANS
];
92 static int arlan_probe_here(struct net_device
*dev
, int ioaddr
);
93 static int arlan_open(struct net_device
*dev
);
94 static int arlan_tx(struct sk_buff
*skb
, struct net_device
*dev
);
95 static void arlan_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
);
96 static int arlan_close(struct net_device
*dev
);
97 static struct net_device_stats
*
98 arlan_statistics (struct net_device
*dev
);
99 static void arlan_set_multicast (struct net_device
*dev
);
100 static int arlan_hw_tx (struct net_device
* dev
, char *buf
, int length
);
101 static int arlan_hw_config (struct net_device
* dev
);
102 static void arlan_tx_done_interrupt (struct net_device
* dev
, int status
);
103 static void arlan_rx_interrupt (struct net_device
* dev
, u_char rxStatus
, u_short
, u_short
);
104 static void arlan_process_interrupt (struct net_device
* dev
);
105 static void arlan_tx_timeout (struct net_device
*dev
);
106 int arlan_command(struct net_device
* dev
, int command
);
108 EXPORT_SYMBOL(arlan_command
);
110 extern inline long long arlan_time(void)
112 struct timeval timev
;
113 do_gettimeofday(&timev
);
114 return ((long long) timev
.tv_sec
* 1000000 + timev
.tv_usec
);
117 #ifdef ARLAN_ENTRY_EXIT_DEBUGING
118 #define ARLAN_DEBUG_ENTRY(name) \
120 struct timeval timev;\
121 do_gettimeofday(&timev);\
122 if (arlan_entry_debug || arlan_entry_and_exit_debug)\
123 printk("--->>>" name " %ld " "\n",((long int) timev.tv_sec * 1000000 + timev.tv_usec));\
125 #define ARLAN_DEBUG_EXIT(name) \
127 struct timeval timev;\
128 do_gettimeofday(&timev);\
129 if (arlan_exit_debug || arlan_entry_and_exit_debug)\
130 printk("<<<---" name " %ld " "\n",((long int) timev.tv_sec * 1000000 + timev.tv_usec) );\
133 #define ARLAN_DEBUG_ENTRY(name)
134 #define ARLAN_DEBUG_EXIT(name)
138 #define arlan_interrupt_ack(dev)\
139 clearClearInterrupt(dev);\
140 setClearInterrupt(dev);
143 #define ARLAN_COMMAND_LOCK(dev) \
144 if (atomic_dec_and_test(&((struct arlan_private * )dev->priv)->card_users))\
145 arlan_wait_command_complete_short(dev,__LINE__);
146 #define ARLAN_COMMAND_UNLOCK(dev) \
147 atomic_inc(&((struct arlan_private * )dev->priv)->card_users);
150 #define ARLAN_COMMAND_INC(dev) \
151 {((struct arlan_private *) dev->priv)->under_command++;}
152 #define ARLAN_COMMAND_ZERO(dev) \
153 {((struct arlan_private *) dev->priv)->under_command =0;}
154 #define ARLAN_UNDER_COMMAND(dev)\
155 (((struct arlan_private *) dev->priv)->under_command)
157 #define ARLAN_COMMAND_START(dev) ARLAN_COMMAND_INC(dev)
158 #define ARLAN_COMMAND_END(dev) ARLAN_COMMAND_ZERO(dev)
159 #define ARLAN_TOGGLE_START(dev)\
160 {((struct arlan_private *) dev->priv)->under_toggle++;}
161 #define ARLAN_TOGGLE_END(dev)\
162 {((struct arlan_private *) dev->priv)->under_toggle=0;}
163 #define ARLAN_UNDER_TOGGLE(dev)\
164 (((struct arlan_private *) dev->priv)->under_toggle)
168 extern inline int arlan_drop_tx(struct net_device
*dev
)
170 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
172 priv
->stats
.tx_errors
++;
173 if (priv
->Conf
->tx_delay_ms
)
175 priv
->tx_done_delayed
= jiffies
+ priv
->Conf
->tx_delay_ms
* HZ
/ 1000 + 1;
179 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_TX
;
180 TXHEAD(dev
).offset
= 0;
181 TXTAIL(dev
).offset
= 0;
185 if (!priv
->under_reset
&& !priv
->under_config
)
186 netif_wake_queue (dev
);
192 int arlan_command(struct net_device
*dev
, int command_p
)
195 volatile struct arlan_shmem
*arlan
= ((struct arlan_private
*) dev
->priv
)->card
;
196 struct arlan_conf_stru
*conf
= ((struct arlan_private
*) dev
->priv
)->Conf
;
197 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
200 long long time_mks
= arlan_time();
202 ARLAN_DEBUG_ENTRY("arlan_command");
204 if (priv
->card_polling_interval
)
205 priv
->card_polling_interval
= 1;
207 if (arlan_debug
& ARLAN_DEBUG_CHAIN_LOCKS
)
208 printk(KERN_DEBUG
"arlan_command, %lx lock %x commandByte %x waiting %x incoming %x \n",
209 jiffies
, priv
->command_lock
, READSHMB(arlan
->commandByte
),
210 priv
->waiting_command_mask
, command_p
);
212 priv
->waiting_command_mask
|= command_p
;
214 if (priv
->waiting_command_mask
& ARLAN_COMMAND_RESET
)
215 if (jiffies
- priv
->lastReset
< 5 * HZ
)
216 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_RESET
;
218 if (priv
->waiting_command_mask
& ARLAN_COMMAND_INT_ACK
)
220 arlan_interrupt_ack(dev
);
221 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_INT_ACK
;
223 if (priv
->waiting_command_mask
& ARLAN_COMMAND_INT_ENABLE
)
225 setInterruptEnable(dev
);
226 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_INT_ENABLE
;
229 /* Card access serializing lock */
231 if (test_and_set_bit(0, (void *) &priv
->command_lock
))
233 if (arlan_debug
& ARLAN_DEBUG_CHAIN_LOCKS
)
234 printk(KERN_DEBUG
"arlan_command: entered when command locked \n");
235 goto command_busy_end
;
237 /* Check cards status and waiting */
239 if (priv
->waiting_command_mask
& (ARLAN_COMMAND_LONG_WAIT_NOW
| ARLAN_COMMAND_WAIT_NOW
))
241 while (priv
->waiting_command_mask
& (ARLAN_COMMAND_LONG_WAIT_NOW
| ARLAN_COMMAND_WAIT_NOW
))
243 if (READSHMB(arlan
->resetFlag
) ||
244 READSHMB(arlan
->commandByte
)) /* ||
245 (readControlRegister(dev) & ARLAN_ACCESS))
249 priv
->waiting_command_mask
&= ~(ARLAN_COMMAND_LONG_WAIT_NOW
| ARLAN_COMMAND_WAIT_NOW
);
253 if (priv
->waiting_command_mask
& ARLAN_COMMAND_LONG_WAIT_NOW
)
255 if (udelayed
* 40 > 1000000)
257 printk(KERN_ERR
"%s long wait too long \n", dev
->name
);
258 priv
->waiting_command_mask
|= ARLAN_COMMAND_RESET
;
262 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_WAIT_NOW
)
264 if (udelayed
* 40 > 1000)
266 printk(KERN_ERR
"%s short wait too long \n", dev
->name
);
275 while ((READSHMB(arlan
->resetFlag
) ||
276 READSHMB(arlan
->commandByte
)) &&
277 conf
->pre_Command_Wait
> (i
++) * 10)
281 if ((READSHMB(arlan
->resetFlag
) ||
282 READSHMB(arlan
->commandByte
)) &&
283 !(priv
->waiting_command_mask
& ARLAN_COMMAND_RESET
))
288 if (priv
->waiting_command_mask
& ARLAN_COMMAND_RESET
)
289 priv
->under_reset
= 1;
290 if (priv
->waiting_command_mask
& ARLAN_COMMAND_CONF
)
291 priv
->under_config
= 1;
293 /* Issuing command */
294 arlan_lock_card_access(dev
);
295 if (priv
->waiting_command_mask
& ARLAN_COMMAND_POWERUP
)
297 // if (readControlRegister(dev) & (ARLAN_ACCESS && ARLAN_POWER))
299 arlan_interrupt_lancpu(dev
);
300 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_POWERUP
;
301 priv
->waiting_command_mask
|= ARLAN_COMMAND_RESET
;
302 priv
->card_polling_interval
= HZ
/ 10;
304 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_ACTIVATE
)
306 WRITESHMB(arlan
->commandByte
, ARLAN_COM_ACTIVATE
);
307 arlan_interrupt_lancpu(dev
);
308 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_ACTIVATE
;
309 priv
->card_polling_interval
= HZ
/ 10;
311 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_RX_ABORT
)
313 if (priv
->rx_command_given
)
315 WRITESHMB(arlan
->commandByte
, ARLAN_COM_RX_ABORT
);
316 arlan_interrupt_lancpu(dev
);
317 priv
->rx_command_given
= 0;
319 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_RX_ABORT
;
320 priv
->card_polling_interval
= 1;
322 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_TX_ABORT
)
324 if (priv
->tx_command_given
)
326 WRITESHMB(arlan
->commandByte
, ARLAN_COM_TX_ABORT
);
327 arlan_interrupt_lancpu(dev
);
328 priv
->tx_command_given
= 0;
330 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_TX_ABORT
;
331 priv
->card_polling_interval
= 1;
333 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_RESET
)
336 netif_stop_queue (dev
);
339 if (priv
->tx_command_given
|| priv
->rx_command_given
)
341 printk(KERN_ERR
"%s: Reset under tx or rx command \n", dev
->name
);
343 netif_stop_queue (dev
);
344 if (arlan_debug
& ARLAN_DEBUG_RESET
)
345 printk(KERN_ERR
"%s: Doing chip reset\n", dev
->name
);
346 priv
->lastReset
= jiffies
;
347 WRITESHM(arlan
->commandByte
, 0, u_char
);
348 /* hold card in reset state */
349 setHardwareReset(dev
);
350 /* set reset flag and then release reset */
351 WRITESHM(arlan
->resetFlag
, 0xff, u_char
);
352 clearChannelAttention(dev
);
353 clearHardwareReset(dev
);
355 priv
->card_polling_interval
= HZ
/ 4;
356 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_RESET
;
357 priv
->waiting_command_mask
|= ARLAN_COMMAND_INT_RACK
;
358 // priv->waiting_command_mask |= ARLAN_COMMAND_INT_RENABLE;
359 // priv->waiting_command_mask |= ARLAN_COMMAND_RX;
361 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_INT_RACK
)
363 clearHardwareReset(dev
);
364 clearClearInterrupt(dev
);
365 setClearInterrupt(dev
);
366 setInterruptEnable(dev
);
367 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_INT_RACK
;
368 priv
->waiting_command_mask
|= ARLAN_COMMAND_CONF
;
369 priv
->under_config
= 1;
370 priv
->under_reset
= 0;
372 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_INT_RENABLE
)
374 setInterruptEnable(dev
);
375 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_INT_RENABLE
;
377 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_CONF
)
379 if (priv
->tx_command_given
|| priv
->rx_command_given
)
381 printk(KERN_ERR
"%s: Reset under tx or rx command \n", dev
->name
);
384 setInterruptEnable(dev
);
385 arlan_hw_config(dev
);
386 arlan_interrupt_lancpu(dev
);
387 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_CONF
;
388 priv
->card_polling_interval
= HZ
/ 10;
389 // priv->waiting_command_mask |= ARLAN_COMMAND_INT_RACK;
390 // priv->waiting_command_mask |= ARLAN_COMMAND_INT_ENABLE;
391 priv
->waiting_command_mask
|= ARLAN_COMMAND_CONF_WAIT
;
393 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_CONF_WAIT
)
395 if (READSHMB(arlan
->configuredStatusFlag
) != 0 &&
396 READSHMB(arlan
->diagnosticInfo
) == 0xff)
398 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_CONF_WAIT
;
399 priv
->waiting_command_mask
|= ARLAN_COMMAND_RX
;
400 priv
->waiting_command_mask
|= ARLAN_COMMAND_TBUSY_CLEAR
;
401 priv
->card_polling_interval
= HZ
/ 10;
402 priv
->tx_command_given
= 0;
403 priv
->under_config
= 0;
407 priv
->card_polling_interval
= 1;
408 if (arlan_debug
& ARLAN_DEBUG_TIMING
)
409 printk(KERN_ERR
"configure delayed \n");
412 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_RX
)
414 if (!registrationBad(dev
))
416 setInterruptEnable(dev
);
417 memset_io((void *) arlan
->commandParameter
, 0, 0xf);
418 WRITESHMB(arlan
->commandByte
, ARLAN_COM_INT
| ARLAN_COM_RX_ENABLE
);
419 WRITESHMB(arlan
->commandParameter
[0], conf
->rxParameter
);
420 arlan_interrupt_lancpu(dev
);
421 priv
->rx_command_given
= 0; // mnjah, bad
422 priv
->last_rx_time
= arlan_time();
423 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_RX
;
424 priv
->card_polling_interval
= 1;
427 priv
->card_polling_interval
= 2;
429 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_TBUSY_CLEAR
)
431 if ( !registrationBad(dev
) &&
432 (netif_queue_stopped(dev
) || !netif_running(dev
)) )
434 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_TBUSY_CLEAR
;
435 netif_wake_queue (dev
);
438 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_TX
)
440 if (!test_and_set_bit(0, (void *) &priv
->tx_command_given
))
442 if ((time_mks
- priv
->last_tx_time
> conf
->rx_tweak1
) ||
443 (time_mks
- priv
->last_rx_int_ack_time
< conf
->rx_tweak2
))
445 setInterruptEnable(dev
);
446 memset_io((void *) arlan
->commandParameter
, 0, 0xf);
447 WRITESHMB(arlan
->commandByte
, ARLAN_COM_TX_ENABLE
| ARLAN_COM_INT
);
448 memcpy_toio((void *) arlan
->commandParameter
, &TXLAST(dev
), 14);
449 // for ( i=1 ; i < 15 ; i++) printk("%02x:",READSHMB(arlan->commandParameter[i]));
450 priv
->last_command_was_rx
= 0;
451 priv
->tx_last_sent
= jiffies
;
452 arlan_interrupt_lancpu(dev
);
453 priv
->last_tx_time
= arlan_time();
454 priv
->tx_command_given
= 1;
455 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_TX
;
456 priv
->card_polling_interval
= 1;
460 priv
->tx_command_given
= 0;
461 priv
->card_polling_interval
= 1;
464 else if (arlan_debug
& ARLAN_DEBUG_CHAIN_LOCKS
)
465 printk(KERN_ERR
"tx command when tx chain locked \n");
467 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_NOOPINT
)
470 WRITESHMB(arlan
->commandByte
, ARLAN_COM_NOP
| ARLAN_COM_INT
);
472 arlan_interrupt_lancpu(dev
);
473 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_NOOPINT
;
474 priv
->card_polling_interval
= HZ
/ 3;
476 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_NOOP
)
478 WRITESHMB(arlan
->commandByte
, ARLAN_COM_NOP
);
479 arlan_interrupt_lancpu(dev
);
480 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_NOOP
;
481 priv
->card_polling_interval
= HZ
/ 3;
483 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_SLOW_POLL
)
485 WRITESHMB(arlan
->commandByte
, ARLAN_COM_GOTO_SLOW_POLL
);
486 arlan_interrupt_lancpu(dev
);
487 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_SLOW_POLL
;
488 priv
->card_polling_interval
= HZ
/ 3;
490 else if (priv
->waiting_command_mask
& ARLAN_COMMAND_POWERDOWN
)
493 if (arlan_debug
& ARLAN_DEBUG_CARD_STATE
)
494 printk(KERN_WARNING
"%s: Arlan Going Standby\n", dev
->name
);
495 priv
->waiting_command_mask
&= ~ARLAN_COMMAND_POWERDOWN
;
496 priv
->card_polling_interval
= 3 * HZ
;
498 arlan_unlock_card_access(dev
);
499 for (i
= 0; READSHMB(arlan
->commandByte
) && i
< 20; i
++)
501 if (READSHMB(arlan
->commandByte
))
502 if (arlan_debug
& ARLAN_DEBUG_CARD_STATE
)
503 printk(KERN_ERR
"card busy leaving command %x \n", priv
->waiting_command_mask
);
505 priv
->command_lock
= 0;
506 ARLAN_DEBUG_EXIT("arlan_command");
507 priv
->last_command_buff_free_time
= jiffies
;
511 if (jiffies
- priv
->last_command_buff_free_time
> HZ
)
512 priv
->waiting_command_mask
|= ARLAN_COMMAND_CLEAN_AND_RESET
;
514 if (arlan_debug
& ARLAN_DEBUG_CARD_STATE
)
515 printk(KERN_ERR
"%s arlan_command card busy end \n", dev
->name
);
516 priv
->command_lock
= 0;
517 ARLAN_DEBUG_EXIT("arlan_command");
521 printk(KERN_ERR
"%s arlan_command bad end \n", dev
->name
);
523 priv
->command_lock
= 0;
524 ARLAN_DEBUG_EXIT("arlan_command");
529 if (arlan_debug
& ARLAN_DEBUG_CARD_STATE
)
530 printk(KERN_ERR
"%s arlan_command command busy end \n", dev
->name
);
531 ARLAN_DEBUG_EXIT("arlan_command");
536 extern inline void arlan_command_process(struct net_device
*dev
)
538 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
541 while (priv
->waiting_command_mask
&& times
< 8)
543 if (priv
->waiting_command_mask
)
545 if (arlan_command(dev
, 0))
549 /* if long command, we wont repeat trying */ ;
550 if (priv
->card_polling_interval
> 1)
557 extern inline void arlan_retransmit_now(struct net_device
*dev
)
559 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
562 ARLAN_DEBUG_ENTRY("arlan_retransmit_now");
563 if (TXLAST(dev
).offset
== 0)
565 if (TXHEAD(dev
).offset
)
568 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
) printk(KERN_DEBUG
"TX buff switch to head \n");
571 else if (TXTAIL(dev
).offset
)
573 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
) printk(KERN_DEBUG
"TX buff switch to tail \n");
577 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
) printk(KERN_ERR
"ReTransmit buff empty");
579 netif_wake_queue (dev
);
583 arlan_command(dev
, ARLAN_COMMAND_TX
);
587 priv
->Conf
->driverRetransmissions
++;
588 priv
->retransmissions
++;
590 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
) printk("Retransmit %d bytes \n", TXLAST(dev
).length
);
592 ARLAN_DEBUG_EXIT("arlan_retransmit_now");
597 static void arlan_registration_timer(unsigned long data
)
599 struct net_device
*dev
= (struct net_device
*) data
;
600 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
602 int lostTime
= ((int) (jiffies
- priv
->registrationLastSeen
)) * 1000 / HZ
;
603 int bh_mark_needed
= 0;
607 priv
->timer_chain_active
= 1;
610 if (registrationBad(dev
))
613 priv
->registrationLostCount
++;
614 if (lostTime
> 7000 && lostTime
< 7200)
616 printk(KERN_NOTICE
"%s registration Lost \n", dev
->name
);
618 if (lostTime
/ priv
->reRegisterExp
> 2000)
619 arlan_command(dev
, ARLAN_COMMAND_CLEAN_AND_CONF
);
620 if (lostTime
/ (priv
->reRegisterExp
) > 3500)
621 arlan_command(dev
, ARLAN_COMMAND_CLEAN_AND_RESET
);
622 if (priv
->reRegisterExp
< 400)
623 priv
->reRegisterExp
+= 2;
627 arlan_command(dev
, ARLAN_COMMAND_CLEAN_AND_RESET
);
632 if (priv
->Conf
->registrationMode
&& lostTime
> 10000 &&
633 priv
->registrationLostCount
)
635 printk(KERN_NOTICE
"%s registration is back after %d milliseconds\n", dev
->name
,
636 ((int) (jiffies
- priv
->registrationLastSeen
) * 1000) / HZ
);
638 priv
->registrationLastSeen
= jiffies
;
639 priv
->registrationLostCount
= 0;
640 priv
->reRegisterExp
= 1;
641 if (!netif_running(dev
) )
642 netif_wake_queue(dev
);
643 if (priv
->tx_last_sent
> priv
->tx_last_cleared
&&
644 jiffies
- priv
->tx_last_sent
> 5*HZ
){
645 arlan_command(dev
, ARLAN_COMMAND_CLEAN_AND_RESET
);
646 priv
->tx_last_cleared
= jiffies
;
651 if (!registrationBad(dev
) && priv
->ReTransmitRequested
)
653 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
654 printk(KERN_ERR
"Retransmit from timer \n");
655 priv
->ReTransmitRequested
= 0;
656 arlan_retransmit_now(dev
);
658 if (!registrationBad(dev
) &&
659 priv
->tx_done_delayed
< jiffies
&&
660 priv
->tx_done_delayed
!= 0)
662 TXLAST(dev
).offset
= 0;
665 else if (TXTAIL(dev
).offset
)
667 if (TXLAST(dev
).offset
)
669 arlan_retransmit_now(dev
);
670 dev
->trans_start
= jiffies
;
672 if (!(TXHEAD(dev
).offset
&& TXTAIL(dev
).offset
))
675 netif_wake_queue (dev
);
677 priv
->tx_done_delayed
= 0;
683 netif_wake_queue (dev
);
685 arlan_process_interrupt(dev
);
687 if (next_tick
< priv
->card_polling_interval
)
688 next_tick
= priv
->card_polling_interval
;
690 priv
->timer_chain_active
= 0;
691 priv
->timer
.expires
= jiffies
+ next_tick
;
693 add_timer(&priv
->timer
);
697 #ifdef ARLAN_DEBUGING
699 static void arlan_print_registers(struct net_device
*dev
, int line
)
701 volatile struct arlan_shmem
*arlan
= ((struct arlan_private
*) dev
->priv
)->card
;
703 u_char hostcpuLock
, lancpuLock
, controlRegister
, cntrlRegImage
,
704 txStatus
, rxStatus
, interruptInProgress
, commandByte
;
707 ARLAN_DEBUG_ENTRY("arlan_print_registers");
708 READSHM(interruptInProgress
, arlan
->interruptInProgress
, u_char
);
709 READSHM(hostcpuLock
, arlan
->hostcpuLock
, u_char
);
710 READSHM(lancpuLock
, arlan
->lancpuLock
, u_char
);
711 READSHM(controlRegister
, arlan
->controlRegister
, u_char
);
712 READSHM(cntrlRegImage
, arlan
->cntrlRegImage
, u_char
);
713 READSHM(txStatus
, arlan
->txStatus
, u_char
);
714 READSHM(rxStatus
, arlan
->rxStatus
, u_char
);
715 READSHM(commandByte
, arlan
->commandByte
, u_char
);
717 printk(KERN_WARNING
"line %04d IP %02x HL %02x LL %02x CB %02x CR %02x CRI %02x TX %02x RX %02x\n",
718 line
, interruptInProgress
, hostcpuLock
, lancpuLock
, commandByte
,
719 controlRegister
, cntrlRegImage
, txStatus
, rxStatus
);
721 ARLAN_DEBUG_EXIT("arlan_print_registers");
726 static int arlan_hw_tx(struct net_device
*dev
, char *buf
, int length
)
730 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
731 volatile struct arlan_shmem
*arlan
= priv
->card
;
732 struct arlan_conf_stru
*conf
= priv
->Conf
;
734 int tailStarts
= 0x800;
738 ARLAN_DEBUG_ENTRY("arlan_hw_tx");
739 if (TXHEAD(dev
).offset
)
740 headEnds
= (((TXHEAD(dev
).offset
+ TXHEAD(dev
).length
- (((int) arlan
->txBuffer
) - ((int) arlan
))) / 64) + 1) * 64;
741 if (TXTAIL(dev
).offset
)
742 tailStarts
= 0x800 - (((TXTAIL(dev
).offset
- (((int) arlan
->txBuffer
) - ((int) arlan
))) / 64) + 2) * 64;
745 if (!TXHEAD(dev
).offset
&& length
< tailStarts
)
747 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
748 printk(KERN_ERR
"TXHEAD insert, tailStart %d\n", tailStarts
);
751 (((int) arlan
->txBuffer
) - ((int) arlan
));
752 TXHEAD(dev
).length
= length
- ARLAN_FAKE_HDR_LEN
;
753 for (i
= 0; i
< 6; i
++)
754 TXHEAD(dev
).dest
[i
] = buf
[i
];
755 TXHEAD(dev
).clear
= conf
->txClear
;
756 TXHEAD(dev
).retries
= conf
->txRetries
; /* 0 is use default */
757 TXHEAD(dev
).routing
= conf
->txRouting
;
758 TXHEAD(dev
).scrambled
= conf
->txScrambled
;
759 memcpy_toio(((char *) arlan
+ TXHEAD(dev
).offset
), buf
+ ARLAN_FAKE_HDR_LEN
, TXHEAD(dev
).length
);
761 else if (!TXTAIL(dev
).offset
&& length
< (0x800 - headEnds
))
763 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
764 printk(KERN_ERR
"TXTAIL insert, headEnd %d\n", headEnds
);
767 (((int) arlan
->txBuffer
) - ((int) arlan
)) + 0x800 - (length
/ 64 + 2) * 64;
768 TXTAIL(dev
).length
= length
- ARLAN_FAKE_HDR_LEN
;
769 for (i
= 0; i
< 6; i
++)
770 TXTAIL(dev
).dest
[i
] = buf
[i
];
771 TXTAIL(dev
).clear
= conf
->txClear
;
772 TXTAIL(dev
).retries
= conf
->txRetries
;
773 TXTAIL(dev
).routing
= conf
->txRouting
;
774 TXTAIL(dev
).scrambled
= conf
->txScrambled
;
775 memcpy_toio(((char *) arlan
+ TXTAIL(dev
).offset
), buf
+ ARLAN_FAKE_HDR_LEN
, TXTAIL(dev
).length
);
779 netif_stop_queue (dev
);
781 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
782 printk(KERN_ERR
"TX TAIL & HEAD full, return, tailStart %d headEnd %d\n", tailStarts
, headEnds
);
784 priv
->out_bytes
+= length
;
785 priv
->out_bytes10
+= length
;
786 if (conf
->measure_rate
< 1)
787 conf
->measure_rate
= 1;
788 if (jiffies
- priv
->out_time
> conf
->measure_rate
* HZ
)
790 conf
->out_speed
= priv
->out_bytes
/ conf
->measure_rate
;
792 priv
->out_time
= jiffies
;
794 if (jiffies
- priv
->out_time10
> conf
->measure_rate
* HZ
* 10)
796 conf
->out_speed10
= priv
->out_bytes10
/ (10 * conf
->measure_rate
);
797 priv
->out_bytes10
= 0;
798 priv
->out_time10
= jiffies
;
800 if (TXHEAD(dev
).offset
&& TXTAIL(dev
).offset
)
802 netif_stop_queue (dev
);
806 netif_start_queue (dev
);
809 IFDEBUG(ARLAN_DEBUG_HEADER_DUMP
)
810 printk(KERN_WARNING
"%s Transmit t %2x:%2x:%2x:%2x:%2x:%2x f %2x:%2x:%2x:%2x:%2x:%2x \n", dev
->name
,
811 (unsigned char) buf
[0], (unsigned char) buf
[1], (unsigned char) buf
[2], (unsigned char) buf
[3],
812 (unsigned char) buf
[4], (unsigned char) buf
[5], (unsigned char) buf
[6], (unsigned char) buf
[7],
813 (unsigned char) buf
[8], (unsigned char) buf
[9], (unsigned char) buf
[10], (unsigned char) buf
[11]);
815 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
) printk(KERN_ERR
"TX command prepare for buffer %d\n", priv
->txLast
);
817 arlan_command(dev
, ARLAN_COMMAND_TX
);
819 priv
->last_command_was_rx
= 0;
820 priv
->tx_last_sent
= jiffies
;
823 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
) printk("%s TX Qued %d bytes \n", dev
->name
, length
);
825 ARLAN_DEBUG_EXIT("arlan_hw_tx");
831 static int arlan_hw_config(struct net_device
*dev
)
833 volatile struct arlan_shmem
*arlan
= ((struct arlan_private
*) dev
->priv
)->card
;
834 struct arlan_conf_stru
*conf
= ((struct arlan_private
*) dev
->priv
)->Conf
;
835 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
837 ARLAN_DEBUG_ENTRY("arlan_hw_config");
839 printk(KERN_NOTICE
"%s arlan configure called \n", dev
->name
);
840 if (arlan_EEPROM_bad
)
841 printk(KERN_NOTICE
"arlan configure with eeprom bad option \n");
844 WRITESHM(arlan
->spreadingCode
, conf
->spreadingCode
, u_char
);
845 WRITESHM(arlan
->channelSet
, conf
->channelSet
, u_char
);
847 if (arlan_EEPROM_bad
)
848 WRITESHM(arlan
->defaultChannelSet
, conf
->channelSet
, u_char
);
850 WRITESHM(arlan
->channelNumber
, conf
->channelNumber
, u_char
);
852 WRITESHM(arlan
->scramblingDisable
, conf
->scramblingDisable
, u_char
);
853 WRITESHM(arlan
->txAttenuation
, conf
->txAttenuation
, u_char
);
855 WRITESHM(arlan
->systemId
, conf
->systemId
, u_int
);
857 WRITESHM(arlan
->maxRetries
, conf
->maxRetries
, u_char
);
858 WRITESHM(arlan
->receiveMode
, conf
->receiveMode
, u_char
);
859 WRITESHM(arlan
->priority
, conf
->priority
, u_char
);
860 WRITESHM(arlan
->rootOrRepeater
, conf
->rootOrRepeater
, u_char
);
861 WRITESHM(arlan
->SID
, conf
->SID
, u_int
);
863 WRITESHM(arlan
->registrationMode
, conf
->registrationMode
, u_char
);
865 WRITESHM(arlan
->registrationFill
, conf
->registrationFill
, u_char
);
866 WRITESHM(arlan
->localTalkAddress
, conf
->localTalkAddress
, u_char
);
867 WRITESHM(arlan
->codeFormat
, conf
->codeFormat
, u_char
);
868 WRITESHM(arlan
->numChannels
, conf
->numChannels
, u_char
);
869 WRITESHM(arlan
->channel1
, conf
->channel1
, u_char
);
870 WRITESHM(arlan
->channel2
, conf
->channel2
, u_char
);
871 WRITESHM(arlan
->channel3
, conf
->channel3
, u_char
);
872 WRITESHM(arlan
->channel4
, conf
->channel4
, u_char
);
873 WRITESHM(arlan
->radioNodeId
, conf
->radioNodeId
, u_short
);
874 WRITESHM(arlan
->SID
, conf
->SID
, u_int
);
875 WRITESHM(arlan
->waitTime
, conf
->waitTime
, u_short
);
876 WRITESHM(arlan
->lParameter
, conf
->lParameter
, u_short
);
877 memcpy_toio(&(arlan
->_15
), &(conf
->_15
), 3);
878 WRITESHM(arlan
->_15
, conf
->_15
, u_short
);
879 WRITESHM(arlan
->headerSize
, conf
->headerSize
, u_short
);
880 if (arlan_EEPROM_bad
)
881 WRITESHM(arlan
->hardwareType
, conf
->hardwareType
, u_char
);
882 WRITESHM(arlan
->radioType
, conf
->radioType
, u_char
);
883 if (arlan_EEPROM_bad
)
884 WRITESHM(arlan
->radioModule
, conf
->radioType
, u_char
);
886 memcpy_toio(arlan
->encryptionKey
+ keyStart
, encryptionKey
, 8);
887 memcpy_toio(arlan
->name
, conf
->siteName
, 16);
889 WRITESHMB(arlan
->commandByte
, ARLAN_COM_INT
| ARLAN_COM_CONF
); /* do configure */
890 memset_io(arlan
->commandParameter
, 0, 0xf); /* 0xf */
891 memset_io(arlan
->commandParameter
+ 1, 0, 2);
892 if (conf
->writeEEPROM
)
894 memset_io(arlan
->commandParameter
, conf
->writeEEPROM
, 1);
895 // conf->writeEEPROM=0;
897 if (conf
->registrationMode
&& conf
->registrationInterrupts
)
898 memset_io(arlan
->commandParameter
+ 3, 1, 1);
900 memset_io(arlan
->commandParameter
+ 3, 0, 1);
902 priv
->irq_test_done
= 0;
904 if (conf
->tx_queue_len
)
905 dev
->tx_queue_len
= conf
->tx_queue_len
;
908 ARLAN_DEBUG_EXIT("arlan_hw_config");
913 static int arlan_read_card_configuration(struct net_device
*dev
)
916 volatile struct arlan_shmem
*arlan
= ((struct arlan_private
*) dev
->priv
)->card
;
917 struct arlan_conf_stru
*conf
= ((struct arlan_private
*) dev
->priv
)->Conf
;
919 ARLAN_DEBUG_ENTRY("arlan_read_card_configuration");
921 if (radioNodeId
== radioNodeIdUNKNOWN
)
923 READSHM(conf
->radioNodeId
, arlan
->radioNodeId
, u_short
);
926 conf
->radioNodeId
= radioNodeId
;
928 if (SID
== SIDUNKNOWN
)
930 READSHM(conf
->SID
, arlan
->SID
, u_int
);
932 else conf
->SID
= SID
;
934 if (spreadingCode
== spreadingCodeUNKNOWN
)
936 READSHM(conf
->spreadingCode
, arlan
->spreadingCode
, u_char
);
939 conf
->spreadingCode
= spreadingCode
;
941 if (channelSet
== channelSetUNKNOWN
)
943 READSHM(conf
->channelSet
, arlan
->channelSet
, u_char
);
945 else conf
->channelSet
= channelSet
;
947 if (channelNumber
== channelNumberUNKNOWN
)
949 READSHM(conf
->channelNumber
, arlan
->channelNumber
, u_char
);
951 else conf
->channelNumber
= channelNumber
;
953 READSHM(conf
->scramblingDisable
, arlan
->scramblingDisable
, u_char
);
954 READSHM(conf
->txAttenuation
, arlan
->txAttenuation
, u_char
);
956 if (systemId
== systemIdUNKNOWN
)
958 READSHM(conf
->systemId
, arlan
->systemId
, u_int
);
960 else conf
->systemId
= systemId
;
962 READSHM(conf
->maxDatagramSize
, arlan
->maxDatagramSize
, u_short
);
963 READSHM(conf
->maxFrameSize
, arlan
->maxFrameSize
, u_short
);
964 READSHM(conf
->maxRetries
, arlan
->maxRetries
, u_char
);
965 READSHM(conf
->receiveMode
, arlan
->receiveMode
, u_char
);
966 READSHM(conf
->priority
, arlan
->priority
, u_char
);
967 READSHM(conf
->rootOrRepeater
, arlan
->rootOrRepeater
, u_char
);
969 if (SID
== SIDUNKNOWN
)
971 READSHM(conf
->SID
, arlan
->SID
, u_int
);
973 else conf
->SID
= SID
;
975 if (registrationMode
== registrationModeUNKNOWN
)
977 READSHM(conf
->registrationMode
, arlan
->registrationMode
, u_char
);
979 else conf
->registrationMode
= registrationMode
;
981 READSHM(conf
->registrationFill
, arlan
->registrationFill
, u_char
);
982 READSHM(conf
->localTalkAddress
, arlan
->localTalkAddress
, u_char
);
983 READSHM(conf
->codeFormat
, arlan
->codeFormat
, u_char
);
984 READSHM(conf
->numChannels
, arlan
->numChannels
, u_char
);
985 READSHM(conf
->channel1
, arlan
->channel1
, u_char
);
986 READSHM(conf
->channel2
, arlan
->channel2
, u_char
);
987 READSHM(conf
->channel3
, arlan
->channel3
, u_char
);
988 READSHM(conf
->channel4
, arlan
->channel4
, u_char
);
989 READSHM(conf
->waitTime
, arlan
->waitTime
, u_short
);
990 READSHM(conf
->lParameter
, arlan
->lParameter
, u_short
);
991 READSHM(conf
->_15
, arlan
->_15
, u_short
);
992 READSHM(conf
->headerSize
, arlan
->headerSize
, u_short
);
993 READSHM(conf
->hardwareType
, arlan
->hardwareType
, u_char
);
994 READSHM(conf
->radioType
, arlan
->radioModule
, u_char
);
996 if (conf
->radioType
== 0)
997 conf
->radioType
= 0xc;
999 WRITESHM(arlan
->configStatus
, 0xA5, u_char
);
1000 READSHM(tlx415
, arlan
->configStatus
, u_char
);
1003 printk(KERN_INFO
"%s tlx415 chip \n", dev
->name
);
1006 conf
->txRetries
= 1;
1007 conf
->txRouting
= 1;
1008 conf
->txScrambled
= 0;
1009 conf
->rxParameter
= 1;
1010 conf
->txTimeoutMs
= 4000;
1011 conf
->waitCardTimeout
= 100000;
1012 conf
->receiveMode
= ARLAN_RCV_CLEAN
;
1013 memcpy_fromio(conf
->siteName
, arlan
->name
, 16);
1014 conf
->siteName
[16] = '\0';
1015 conf
->retries
= retries
;
1016 conf
->tx_delay_ms
= tx_delay_ms
;
1017 conf
->async
= async
;
1018 conf
->ReTransmitPacketMaxSize
= 200;
1019 conf
->waitReTransmitPacketMaxSize
= 200;
1020 conf
->txAckTimeoutMs
= 900;
1021 conf
->fastReTransCount
= 3;
1023 ARLAN_DEBUG_EXIT("arlan_read_card_configuration");
1029 static int lastFoundAt
= 0xbe000;
1033 * This is the real probe routine. Linux has a history of friendly device
1034 * probes on the ISA bus. A good device probes avoids doing writes, and
1035 * verifies that the correct device exists and functions.
1038 static int __init
arlan_check_fingerprint(int memaddr
)
1040 static char probeText
[] = "TELESYSTEM SLW INC. ARLAN \0";
1042 volatile struct arlan_shmem
*arlan
= (struct arlan_shmem
*) memaddr
;
1044 ARLAN_DEBUG_ENTRY("arlan_check_fingerprint");
1045 if (check_mem_region(virt_to_phys((void *)memaddr
),0x2000 )){
1046 // printk(KERN_WARNING "arlan: memory region %lx excluded from probing \n",virt_to_phys((void*)memaddr));
1049 memcpy_fromio(tempBuf
, arlan
->textRegion
, 29);
1052 /* check for card at this address */
1053 if (0 != strncmp(tempBuf
, probeText
, 29)){
1054 // not release_mem_region(virt_to_phys((void*)memaddr),0x2000);
1058 // printk(KERN_INFO "arlan found at 0x%x \n",memaddr);
1059 ARLAN_DEBUG_EXIT("arlan_check_fingerprint");
1066 int __init
arlan_probe_everywhere(struct net_device
*dev
)
1072 ARLAN_DEBUG_ENTRY("arlan_probe_everywhere");
1073 if (mem
!= 0 && numDevices
== 1) /* Check a single specified location. */
1075 if (arlan_probe_here(dev
, (int) phys_to_virt( mem
) ) == 0)
1080 for (m
= (int)phys_to_virt(lastFoundAt
) + 0x2000; m
<= (int)phys_to_virt(0xDE000); m
+= 0x2000)
1082 if (arlan_probe_here(dev
, m
) == 0)
1085 lastFoundAt
= (int)virt_to_phys((void*)m
);
1090 if (found
== 0 && probed
!= 0)
1092 if (lastFoundAt
== 0xbe000)
1093 printk(KERN_ERR
"arlan: No Arlan devices found \n");
1099 ARLAN_DEBUG_EXIT("arlan_probe_everywhere");
1104 int __init
arlan_find_devices(void)
1109 ARLAN_DEBUG_ENTRY("arlan_find_devices");
1110 if (mem
!= 0 && numDevices
== 1) /* Check a single specified location. */
1112 for (m
=(int) phys_to_virt(0xc0000); m
<=(int) phys_to_virt(0xDE000); m
+= 0x2000)
1114 if (arlan_check_fingerprint(m
) == 0)
1117 ARLAN_DEBUG_EXIT("arlan_find_devices");
1123 static int arlan_change_mtu(struct net_device
*dev
, int new_mtu
)
1125 struct arlan_conf_stru
*conf
= ((struct arlan_private
*) dev
->priv
)->Conf
;
1127 ARLAN_DEBUG_ENTRY("arlan_change_mtu");
1128 if ((new_mtu
< 68) || (new_mtu
> 2032))
1132 new_mtu
= 256; /* cards book suggests 1600 */
1133 conf
->maxDatagramSize
= new_mtu
;
1134 conf
->maxFrameSize
= new_mtu
+ 48;
1136 arlan_command(dev
, ARLAN_COMMAND_CLEAN_AND_CONF
);
1137 printk(KERN_NOTICE
"%s mtu changed to %d \n", dev
->name
, new_mtu
);
1139 ARLAN_DEBUG_EXIT("arlan_change_mtu");
1144 static int arlan_mac_addr(struct net_device
*dev
, void *p
)
1146 struct sockaddr
*addr
= p
;
1149 ARLAN_DEBUG_ENTRY("arlan_mac_addr");
1152 if (!netif_running(dev
))
1154 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1156 ARLAN_DEBUG_EXIT("arlan_mac_addr");
1164 arlan_allocate_device(int num
, struct net_device
*devs
)
1167 struct net_device
*dev
;
1169 ARLAN_DEBUG_ENTRY("arlan_allocate_device");
1172 dev
= init_etherdev(0, sizeof(struct arlan_private
));
1176 dev
->priv
= kmalloc(sizeof(struct arlan_private
), GFP_KERNEL
);
1179 if (dev
== NULL
|| dev
->priv
== NULL
)
1181 printk(KERN_CRIT
"init_etherdev failed ");
1185 memset(dev
->priv
,0,sizeof(struct arlan_private
));
1187 ((struct arlan_private
*) dev
->priv
)->conf
=
1188 kmalloc(sizeof(struct arlan_shmem
), GFP_KERNEL
);
1190 if (dev
== NULL
|| dev
->priv
== NULL
||
1191 ((struct arlan_private
*) dev
->priv
)->conf
== NULL
)
1194 printk(KERN_CRIT
" No memory at arlan_allocate_device \n");
1196 /* Fill in the 'dev' fields. */
1201 dev
->flags
= 0; /* IFF_BROADCAST & IFF_MULTICAST & IFF_PROMISC; */
1204 dev
->tx_queue_len
= tx_queue_len
;
1206 dev
->tx_queue_len
= tx_queue_len
;
1207 dev
->open
= arlan_open
;
1208 dev
->stop
= arlan_close
;
1209 dev
->hard_start_xmit
= arlan_tx
;
1210 dev
->get_stats
= arlan_statistics
;
1211 dev
->set_multicast_list
= arlan_set_multicast
;
1212 dev
->change_mtu
= arlan_change_mtu
;
1213 dev
->set_mac_address
= arlan_mac_addr
;
1214 dev
->tx_timeout
= arlan_tx_timeout
;
1215 dev
->watchdog_timeo
= 3*HZ
;
1217 ((struct arlan_private
*) dev
->priv
)->irq_test_done
= 0;
1218 arlan_device
[num
] = dev
;
1219 ((struct arlan_private
*) arlan_device
[num
]->priv
)->Conf
= &(arlan_conf
[num
]);
1221 ((struct arlan_private
*) dev
->priv
)->Conf
->pre_Command_Wait
= 40;
1222 ((struct arlan_private
*) dev
->priv
)->Conf
->rx_tweak1
= 30;
1223 ((struct arlan_private
*) dev
->priv
)->Conf
->rx_tweak2
= 0;
1225 ARLAN_DEBUG_EXIT("arlan_allocate_device");
1230 int __init
arlan_probe_here(struct net_device
*dev
, int memaddr
)
1232 volatile struct arlan_shmem
*arlan
;
1234 ARLAN_DEBUG_ENTRY("arlan_probe_here");
1236 if (arlan_check_fingerprint(memaddr
))
1239 printk(KERN_NOTICE
"%s: Arlan found at %x, \n ", dev
->name
, (int) virt_to_phys((void*)memaddr
));
1241 if (!arlan_allocate_device(arlans_found
, dev
))
1244 ((struct arlan_private
*) dev
->priv
)->card
= (struct arlan_shmem
*) memaddr
;
1245 arlan
= (void *) memaddr
;
1247 dev
->mem_start
= memaddr
;
1248 dev
->mem_end
= memaddr
+ 0x1FFF;
1252 READSHM(dev
->irq
, arlan
->irqLevel
, u_char
);
1253 } else if (dev
->irq
== 2)
1256 arlan_read_card_configuration(dev
);
1258 ARLAN_DEBUG_EXIT("arlan_probe_here");
1265 static int arlan_open(struct net_device
*dev
)
1267 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
1268 volatile struct arlan_shmem
*arlan
= priv
->card
;
1271 ARLAN_DEBUG_ENTRY("arlan_open");
1273 if (dev
->mem_start
== 0)
1274 ret
= arlan_probe_everywhere(dev
);
1278 arlan
= ((struct arlan_private
*) dev
->priv
)->card
;
1279 if (request_irq(dev
->irq
, &arlan_interrupt
, 0, dev
->name
, dev
))
1281 printk(KERN_ERR
"%s: unable to get IRQ %d .\n",
1282 dev
->name
, dev
->irq
);
1288 priv
->lastReset
= 0;
1290 priv
->open_time
= jiffies
;
1291 memcpy_fromio(dev
->dev_addr
, arlan
->lanCardNodeId
, 6);
1292 memset(dev
->broadcast
, 0xff, 6);
1294 dev
->tx_queue_len
= tx_queue_len
;
1295 priv
->interrupt_processing_active
= 0;
1296 priv
->command_lock
= 0;
1298 netif_start_queue (dev
);
1300 init_MUTEX(&priv
->card_lock
);
1301 myATOMIC_INIT(priv
->card_users
, 1); /* damn 2.0.33 */
1302 priv
->registrationLostCount
= 0;
1303 priv
->registrationLastSeen
= jiffies
;
1305 priv
->tx_command_given
= 0;
1306 priv
->rx_command_given
= 0;
1308 priv
->reRegisterExp
= 1;
1310 priv
->nof_tx_ack
= 0;
1311 priv
->last_command_was_rx
= 0;
1312 priv
->tx_last_sent
= jiffies
- 1;
1313 priv
->tx_last_cleared
= jiffies
;
1314 priv
->Conf
->writeEEPROM
= 0;
1315 priv
->Conf
->registrationInterrupts
= 1;
1317 init_timer(&priv
->timer
);
1318 priv
->timer
.expires
= jiffies
+ HZ
/ 10;
1319 priv
->timer
.data
= (unsigned long) dev
;
1320 priv
->timer
.function
= &arlan_registration_timer
; /* timer handler */
1322 arlan_command(dev
, ARLAN_COMMAND_POWERUP
| ARLAN_COMMAND_LONG_WAIT_NOW
);
1324 add_timer(&priv
->timer
);
1327 #ifdef CONFIG_PROC_FS
1329 if (arlan_device
[0])
1333 ARLAN_DEBUG_EXIT("arlan_open");
1338 static void arlan_tx_timeout (struct net_device
*dev
)
1340 printk(KERN_ERR
"%s: arlan transmit timed out, kernel decided\n", dev
->name
);
1341 /* Try to restart the adaptor. */
1342 arlan_command(dev
, ARLAN_COMMAND_CLEAN_AND_RESET
);
1343 // dev->trans_start = jiffies;
1344 // netif_start_queue (dev);
1348 static int arlan_tx(struct sk_buff
*skb
, struct net_device
*dev
)
1350 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
1354 ARLAN_DEBUG_ENTRY("arlan_tx");
1356 length
= ETH_ZLEN
< skb
->len
? skb
->len
: ETH_ZLEN
;
1359 if (priv
->txOffset
+ length
+ 0x12 > 0x800) {
1360 printk(KERN_ERR
"TX RING overflow \n");
1361 netif_stop_queue (dev
);
1364 if (arlan_hw_tx(dev
, buf
, length
) == -1)
1367 dev
->trans_start
= jiffies
;
1371 arlan_process_interrupt(dev
);
1372 priv
->tx_chain_active
= 0;
1373 ARLAN_DEBUG_EXIT("arlan_tx");
1377 arlan_process_interrupt(dev
);
1378 priv
->tx_chain_active
= 0;
1379 netif_stop_queue (dev
);
1380 ARLAN_DEBUG_EXIT("arlan_tx");
1385 extern inline int DoNotReTransmitCrap(struct net_device
*dev
)
1387 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
1389 if (TXLAST(dev
).length
< priv
->Conf
->ReTransmitPacketMaxSize
)
1395 extern inline int DoNotWaitReTransmitCrap(struct net_device
*dev
)
1397 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
1399 if (TXLAST(dev
).length
< priv
->Conf
->waitReTransmitPacketMaxSize
)
1404 extern inline void arlan_queue_retransmit(struct net_device
*dev
)
1406 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
1408 ARLAN_DEBUG_ENTRY("arlan_queue_retransmit");
1410 if (DoNotWaitReTransmitCrap(dev
))
1414 priv
->ReTransmitRequested
++;
1416 ARLAN_DEBUG_EXIT("arlan_queue_retransmit");
1419 extern inline void RetryOrFail(struct net_device
*dev
)
1421 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
1423 ARLAN_DEBUG_ENTRY("RetryOrFail");
1425 if (priv
->retransmissions
> priv
->Conf
->retries
||
1426 DoNotReTransmitCrap(dev
))
1430 else if (priv
->bad
<= priv
->Conf
->fastReTransCount
)
1432 arlan_retransmit_now(dev
);
1434 else arlan_queue_retransmit(dev
);
1436 ARLAN_DEBUG_EXIT("RetryOrFail");
1440 static void arlan_tx_done_interrupt(struct net_device
*dev
, int status
)
1442 struct arlan_private
*priv
= ((struct arlan_private
*) dev
->priv
);
1444 ARLAN_DEBUG_ENTRY("arlan_tx_done_interrupt");
1446 priv
->tx_last_cleared
= jiffies
;
1447 priv
->tx_command_given
= 0;
1453 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1454 printk("arlan intr: transmit OK\n");
1455 priv
->stats
.tx_packets
++;
1458 priv
->retransmissions
= 0;
1459 if (priv
->Conf
->tx_delay_ms
)
1461 priv
->tx_done_delayed
= jiffies
+ (priv
->Conf
->tx_delay_ms
* HZ
) / 1000 + 1;;
1465 TXLAST(dev
).offset
= 0;
1468 else if (TXTAIL(dev
).offset
)
1470 if (TXLAST(dev
).offset
)
1472 arlan_retransmit_now(dev
);
1473 dev
->trans_start
= jiffies
;
1475 if (!TXHEAD(dev
).offset
|| !TXTAIL(dev
).offset
)
1478 netif_wake_queue (dev
);
1486 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1487 printk("arlan intr: transmit timed out\n");
1489 //arlan_queue_retransmit(dev);
1496 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1497 printk("arlan intr: transmit max retries\n");
1500 //arlan_queue_retransmit(dev);
1507 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1508 printk("arlan intr: transmit aborted\n");
1510 arlan_queue_retransmit(dev
);
1517 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1518 printk("arlan intr: transmit not registered\n");
1521 arlan_queue_retransmit(dev
);
1527 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1528 printk("arlan intr: transmit destination full\n");
1531 //arlan_drop_tx(dev);
1532 arlan_queue_retransmit(dev
);
1538 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1539 printk("arlan intr: transmit unknown ack\n");
1542 arlan_queue_retransmit(dev
);
1548 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1549 printk("arlan intr: transmit dest mail box full\n");
1552 //arlan_drop_tx(dev);
1553 arlan_queue_retransmit(dev
);
1559 IFDEBUG(ARLAN_DEBUG_TX_CHAIN
)
1560 printk("arlan intr: transmit root dest not reg.\n");
1563 //arlan_drop_tx(dev);
1564 arlan_queue_retransmit(dev
);
1570 printk(KERN_ERR
"arlan intr: transmit status unknown\n");
1577 ARLAN_DEBUG_EXIT("arlan_tx_done_interrupt");
1581 static void arlan_rx_interrupt(struct net_device
*dev
, u_char rxStatus
, u_short rxOffset
, u_short pkt_len
)
1586 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
1587 volatile struct arlan_shmem
*arlan
= priv
->card
;
1588 struct arlan_conf_stru
*conf
= priv
->Conf
;
1591 ARLAN_DEBUG_ENTRY("arlan_rx_interrupt");
1592 // by spec, not WRITESHMB(arlan->rxStatus,0x00);
1593 // prohibited here arlan_command(dev, ARLAN_COMMAND_RX);
1595 if (pkt_len
< 10 || pkt_len
> 2048)
1597 printk(KERN_WARNING
"%s: got too short or long packet, len %d \n", dev
->name
, pkt_len
);
1600 if (rxOffset
+ pkt_len
> 0x2000)
1602 printk("%s: got too long packet, len %d offset %x\n", dev
->name
, pkt_len
, rxOffset
);
1605 priv
->in_bytes
+= pkt_len
;
1606 priv
->in_bytes10
+= pkt_len
;
1607 if (conf
->measure_rate
< 1)
1608 conf
->measure_rate
= 1;
1609 if (jiffies
- priv
->in_time
> conf
->measure_rate
* HZ
)
1611 conf
->in_speed
= priv
->in_bytes
/ conf
->measure_rate
;
1613 priv
->in_time
= jiffies
;
1615 if (jiffies
- priv
->in_time10
> conf
->measure_rate
* HZ
* 10)
1617 conf
->in_speed10
= priv
->in_bytes10
/ (10 * conf
->measure_rate
);
1618 priv
->in_bytes10
= 0;
1619 priv
->in_time10
= jiffies
;
1621 DEBUGSHM(1, "arlan rcv pkt rxStatus= %d ", arlan
->rxStatus
, u_char
);
1628 /* Malloc up new buffer. */
1629 struct sk_buff
*skb
;
1631 DEBUGSHM(50, "arlan recv pkt offs=%d\n", arlan
->rxOffset
, u_short
);
1632 DEBUGSHM(1, "arlan rxFrmType = %d \n", arlan
->rxFrmType
, u_char
);
1633 DEBUGSHM(1, KERN_INFO
"arlan rx scrambled = %d \n", arlan
->scrambled
, u_char
);
1635 /* here we do multicast filtering to avoid slow 8-bit memcopy */
1636 #ifdef ARLAN_MULTICAST
1637 if (!(dev
->flags
& IFF_ALLMULTI
) &&
1638 !(dev
->flags
& IFF_PROMISC
) &&
1641 char hw_dst_addr
[6];
1642 struct dev_mc_list
*dmi
= dev
->mc_list
;
1645 memcpy_fromio(hw_dst_addr
, arlan
->ultimateDestAddress
, 6);
1646 if (hw_dst_addr
[0] == 0x01)
1649 if (hw_dst_addr
[1] == 0x00)
1650 printk(KERN_ERR
"%s mcast 0x0100 \n", dev
->name
);
1651 else if (hw_dst_addr
[1] == 0x40)
1652 printk(KERN_ERR
"%s m/bcast 0x0140 \n", dev
->name
);
1654 { if (dmi
->dmi_addrlen
== 6)
1656 if (arlan_debug
& ARLAN_DEBUG_HEADER_DUMP
)
1657 printk(KERN_ERR
"%s mcl %2x:%2x:%2x:%2x:%2x:%2x \n", dev
->name
,
1658 dmi
->dmi_addr
[0], dmi
->dmi_addr
[1], dmi
->dmi_addr
[2],
1659 dmi
->dmi_addr
[3], dmi
->dmi_addr
[4], dmi
->dmi_addr
[5]);
1660 for (i
= 0; i
< 6; i
++)
1661 if (dmi
->dmi_addr
[i
] != hw_dst_addr
[i
])
1667 printk(KERN_ERR
"%s: invalid multicast address length given.\n", dev
->name
);
1670 /* we reach here if multicast filtering is on and packet
1671 * is multicast and not for receive */
1672 goto end_of_interupt
;
1675 #endif // ARLAN_MULTICAST
1676 /* multicast filtering ends here */
1677 pkt_len
+= ARLAN_FAKE_HDR_LEN
;
1679 skb
= dev_alloc_skb(pkt_len
+ 4);
1682 printk(KERN_ERR
"%s: Memory squeeze, dropping packet.\n", dev
->name
);
1683 priv
->stats
.rx_dropped
++;
1686 skb_reserve(skb
, 2);
1688 skbtmp
= skb_put(skb
, pkt_len
);
1690 memcpy_fromio(skbtmp
+ ARLAN_FAKE_HDR_LEN
, ((char *) arlan
) + rxOffset
, pkt_len
- ARLAN_FAKE_HDR_LEN
);
1691 memcpy_fromio(skbtmp
, arlan
->ultimateDestAddress
, 6);
1692 memcpy_fromio(skbtmp
+ 6, arlan
->rxSrc
, 6);
1693 WRITESHMB(arlan
->rxStatus
, 0x00);
1694 arlan_command(dev
, ARLAN_COMMAND_RX
);
1696 IFDEBUG(ARLAN_DEBUG_HEADER_DUMP
)
1698 char immedDestAddress
[6];
1699 char immedSrcAddress
[6];
1700 memcpy_fromio(immedDestAddress
, arlan
->immedDestAddress
, 6);
1701 memcpy_fromio(immedSrcAddress
, arlan
->immedSrcAddress
, 6);
1703 printk(KERN_WARNING
"%s t %2x:%2x:%2x:%2x:%2x:%2x f %2x:%2x:%2x:%2x:%2x:%2x imd %2x:%2x:%2x:%2x:%2x:%2x ims %2x:%2x:%2x:%2x:%2x:%2x\n", dev
->name
,
1704 (unsigned char) skbtmp
[0], (unsigned char) skbtmp
[1], (unsigned char) skbtmp
[2], (unsigned char) skbtmp
[3],
1705 (unsigned char) skbtmp
[4], (unsigned char) skbtmp
[5], (unsigned char) skbtmp
[6], (unsigned char) skbtmp
[7],
1706 (unsigned char) skbtmp
[8], (unsigned char) skbtmp
[9], (unsigned char) skbtmp
[10], (unsigned char) skbtmp
[11],
1707 immedDestAddress
[0], immedDestAddress
[1], immedDestAddress
[2],
1708 immedDestAddress
[3], immedDestAddress
[4], immedDestAddress
[5],
1709 immedSrcAddress
[0], immedSrcAddress
[1], immedSrcAddress
[2],
1710 immedSrcAddress
[3], immedSrcAddress
[4], immedSrcAddress
[5]);
1712 skb
->protocol
= eth_type_trans(skb
, dev
);
1713 IFDEBUG(ARLAN_DEBUG_HEADER_DUMP
)
1714 if (skb
->protocol
!= 0x608 && skb
->protocol
!= 0x8)
1716 for (i
= 0; i
<= 22; i
++)
1717 printk("%02x:", (u_char
) skbtmp
[i
+ 12]);
1718 printk(KERN_ERR
"\n");
1719 printk(KERN_WARNING
"arlan kernel pkt type trans %x \n", skb
->protocol
);
1722 priv
->stats
.rx_packets
++;
1727 printk(KERN_ERR
"arlan intr: recieved unknown status\n");
1728 priv
->stats
.rx_crc_errors
++;
1731 ARLAN_DEBUG_EXIT("arlan_rx_interrupt");
1734 static void arlan_process_interrupt(struct net_device
*dev
)
1736 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
1737 volatile struct arlan_shmem
*arlan
= priv
->card
;
1738 u_char rxStatus
= READSHMB(arlan
->rxStatus
);
1739 u_char txStatus
= READSHMB(arlan
->txStatus
);
1740 u_short rxOffset
= READSHMS(arlan
->rxOffset
);
1741 u_short pkt_len
= READSHMS(arlan
->rxLength
);
1742 int interrupt_count
= 0;
1744 ARLAN_DEBUG_ENTRY("arlan_process_interrupt");
1746 if (test_and_set_bit(0, (void *) &priv
->interrupt_processing_active
))
1748 if (arlan_debug
& ARLAN_DEBUG_CHAIN_LOCKS
)
1749 printk(KERN_ERR
"interrupt chain reentering \n");
1750 goto end_int_process
;
1752 while ((rxStatus
|| txStatus
|| priv
->interrupt_ack_requested
)
1753 && (interrupt_count
< 5))
1756 priv
->last_rx_int_ack_time
= arlan_time();
1758 arlan_command(dev
, ARLAN_COMMAND_INT_ACK
);
1759 arlan_command(dev
, ARLAN_COMMAND_INT_ENABLE
);
1761 IFDEBUG(ARLAN_DEBUG_INTERRUPT
)
1762 printk(KERN_ERR
"%s: got IRQ rx %x tx %x comm %x rxOff %x rxLen %x \n",
1763 dev
->name
, rxStatus
, txStatus
, READSHMB(arlan
->commandByte
),
1766 if (rxStatus
== 0 && txStatus
== 0)
1768 priv
->last_command_was_rx
= 0;
1769 if (priv
->irq_test_done
)
1771 if (!registrationBad(dev
))
1772 IFDEBUG(ARLAN_DEBUG_INTERRUPT
) printk(KERN_ERR
"%s unknown interrupt(nop? regLost ?) reason tx %d rx %d ",
1773 dev
->name
, txStatus
, rxStatus
);
1775 IFDEBUG(ARLAN_DEBUG_INTERRUPT
)
1776 printk(KERN_INFO
"%s irq $%d test OK \n", dev
->name
, dev
->irq
);
1779 priv
->interrupt_ack_requested
= 0;
1784 WRITESHMB(arlan
->txStatus
, 0x00);
1785 arlan_tx_done_interrupt(dev
, txStatus
);
1788 if (rxStatus
== 1 || rxStatus
== 2)
1789 { /* a packet waiting */
1790 arlan_rx_interrupt(dev
, rxStatus
, rxOffset
, pkt_len
);
1793 if (rxStatus
> 2 && rxStatus
< 0xff)
1795 priv
->last_command_was_rx
= 0;
1796 WRITESHMB(arlan
->rxStatus
, 0x00);
1797 printk(KERN_ERR
"%s unknown rxStatus reason tx %d rx %d ",
1798 dev
->name
, txStatus
, rxStatus
);
1801 if (rxStatus
== 0xff)
1803 priv
->last_command_was_rx
= 0;
1804 WRITESHMB(arlan
->rxStatus
, 0x00);
1805 arlan_command(dev
, ARLAN_COMMAND_RX
);
1806 if (registrationBad(dev
))
1807 netif_device_detach(dev
);
1808 if (!registrationBad(dev
))
1810 priv
->registrationLastSeen
= jiffies
;
1811 if (!netif_queue_stopped(dev
) && !priv
->under_reset
&& !priv
->under_config
)
1812 netif_wake_queue (dev
);
1818 arlan_command_process(dev
);
1820 rxStatus
= READSHMB(arlan
->rxStatus
);
1821 txStatus
= READSHMB(arlan
->txStatus
);
1822 rxOffset
= READSHMS(arlan
->rxOffset
);
1823 pkt_len
= READSHMS(arlan
->rxLength
);
1826 priv
->irq_test_done
= 1;
1830 priv
->interrupt_processing_active
= 0;
1833 arlan_command_process(dev
);
1835 ARLAN_DEBUG_EXIT("arlan_process_interrupt");
1839 static void arlan_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
1841 struct net_device
*dev
= dev_id
;
1842 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
1843 volatile struct arlan_shmem
*arlan
= priv
->card
;
1844 u_char rxStatus
= READSHMB(arlan
->rxStatus
);
1845 u_char txStatus
= READSHMB(arlan
->txStatus
);
1847 ARLAN_DEBUG_ENTRY("arlan_interrupt");
1850 if (!rxStatus
&& !txStatus
)
1851 priv
->interrupt_ack_requested
++;
1853 arlan_process_interrupt(dev
);
1855 priv
->irq_test_done
= 1;
1857 ARLAN_DEBUG_EXIT("arlan_interrupt");
1863 static int arlan_close(struct net_device
*dev
)
1865 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
1869 printk(KERN_CRIT
"arlan: No Device\n");
1872 priv
= (struct arlan_private
*) dev
->priv
;
1875 printk(KERN_CRIT
"arlan: No Device priv \n");
1878 ARLAN_DEBUG_ENTRY("arlan_close");
1880 del_timer(&priv
->timer
);
1882 arlan_command(dev
, ARLAN_COMMAND_POWERDOWN
);
1884 IFDEBUG(ARLAN_DEBUG_STARTUP
)
1885 printk(KERN_NOTICE
"%s: Closing device\n", dev
->name
);
1887 priv
->open_time
= 0;
1888 netif_stop_queue(dev
);
1889 free_irq(dev
->irq
, dev
);
1892 ARLAN_DEBUG_EXIT("arlan_close");
1896 #ifdef ARLAN_DEBUGING
1897 static long alignLong(volatile u_char
* ptr
)
1900 memcpy_fromio(&ret
, (void *) ptr
, 4);
1906 * Get the current statistics.
1907 * This may be called with the card open or closed.
1910 static struct net_device_stats
*arlan_statistics(struct net_device
*dev
)
1912 struct arlan_private
*priv
= (struct arlan_private
*) dev
->priv
;
1913 volatile struct arlan_shmem
*arlan
= ((struct arlan_private
*) dev
->priv
)->card
;
1916 ARLAN_DEBUG_ENTRY("arlan_statistics");
1918 /* Update the statistics from the device registers. */
1920 READSHM(priv
->stats
.collisions
, arlan
->numReTransmissions
, u_int
);
1921 READSHM(priv
->stats
.rx_crc_errors
, arlan
->numCRCErrors
, u_int
);
1922 READSHM(priv
->stats
.rx_dropped
, arlan
->numFramesDiscarded
, u_int
);
1923 READSHM(priv
->stats
.rx_fifo_errors
, arlan
->numRXBufferOverflows
, u_int
);
1924 READSHM(priv
->stats
.rx_frame_errors
, arlan
->numReceiveFramesLost
, u_int
);
1925 READSHM(priv
->stats
.rx_over_errors
, arlan
->numRXOverruns
, u_int
);
1926 READSHM(priv
->stats
.rx_packets
, arlan
->numDatagramsReceived
, u_int
);
1927 READSHM(priv
->stats
.tx_aborted_errors
, arlan
->numAbortErrors
, u_int
);
1928 READSHM(priv
->stats
.tx_carrier_errors
, arlan
->numStatusTimeouts
, u_int
);
1929 READSHM(priv
->stats
.tx_dropped
, arlan
->numDatagramsDiscarded
, u_int
);
1930 READSHM(priv
->stats
.tx_fifo_errors
, arlan
->numTXUnderruns
, u_int
);
1931 READSHM(priv
->stats
.tx_packets
, arlan
->numDatagramsTransmitted
, u_int
);
1932 READSHM(priv
->stats
.tx_window_errors
, arlan
->numHoldOffs
, u_int
);
1934 ARLAN_DEBUG_EXIT("arlan_statistics");
1936 return &priv
->stats
;
1940 static void arlan_set_multicast(struct net_device
*dev
)
1942 volatile struct arlan_shmem
*arlan
= ((struct arlan_private
*) dev
->priv
)->card
;
1943 struct arlan_conf_stru
*conf
= ((struct arlan_private
*) dev
->priv
)->Conf
;
1944 int board_conf_needed
= 0;
1947 ARLAN_DEBUG_ENTRY("arlan_set_multicast");
1949 if (dev
->flags
& IFF_PROMISC
)
1951 unsigned char recMode
;
1952 READSHM(recMode
, arlan
->receiveMode
, u_char
);
1953 conf
->receiveMode
= (ARLAN_RCV_PROMISC
| ARLAN_RCV_CONTROL
);
1954 if (conf
->receiveMode
!= recMode
)
1955 board_conf_needed
= 1;
1959 /* turn off promiscuous mode */
1960 unsigned char recMode
;
1961 READSHM(recMode
, arlan
->receiveMode
, u_char
);
1962 conf
->receiveMode
= ARLAN_RCV_CLEAN
| ARLAN_RCV_CONTROL
;
1963 if (conf
->receiveMode
!= recMode
)
1964 board_conf_needed
= 1;
1966 if (board_conf_needed
)
1967 arlan_command(dev
, ARLAN_COMMAND_CONF
);
1969 ARLAN_DEBUG_EXIT("arlan_set_multicast");
1973 int __init
arlan_probe(struct net_device
*dev
)
1975 printk("Arlan driver %s\n", arlan_version
);
1977 if (arlan_probe_everywhere(dev
))
1982 if (arlans_found
== 1)
1983 siteName
= kmalloc(100, GFP_KERNEL
);
1989 int init_module(void)
1993 ARLAN_DEBUG_ENTRY("init_module");
1995 if (channelSet
!= channelSetUNKNOWN
|| channelNumber
!= channelNumberUNKNOWN
|| systemId
!= systemIdUNKNOWN
)
1997 printk(KERN_WARNING
"arlan: wrong module params for multiple devices\n ");
2000 numDevices
= arlan_find_devices();
2001 if (numDevices
== 0)
2003 printk(KERN_ERR
"arlan: no devices found \n");
2007 siteName
= kmalloc(100, GFP_KERNEL
);
2010 printk(KERN_ERR
"arlan: No memory for site name.\n");
2013 for (i
= 0; i
< numDevices
&& i
< MAX_ARLANS
; i
++)
2015 if (!arlan_allocate_device(i
, NULL
))
2017 if (arlan_device
[i
] == NULL
)
2019 printk(KERN_CRIT
"arlan: Not Enough memory \n");
2023 arlan_probe_everywhere(arlan_device
[i
]);
2024 // arlan_command(arlan_device[i], ARLAN_COMMAND_POWERDOWN );
2026 printk(KERN_INFO
"Arlan driver %s\n", arlan_version
);
2027 ARLAN_DEBUG_EXIT("init_module");
2032 void cleanup_module(void)
2036 ARLAN_DEBUG_ENTRY("cleanup_module");
2038 IFDEBUG(ARLAN_DEBUG_SHUTDOWN
)
2039 printk(KERN_INFO
"arlan: unloading module\n");
2040 for (i
= 0; i
< MAX_ARLANS
; i
++)
2042 if (arlan_device
[i
])
2044 arlan_command(arlan_device
[i
], ARLAN_COMMAND_POWERDOWN
);
2046 // release_mem_region(virt_to_phys(arlan_device[i]->mem_start), 0x2000 );
2047 unregister_netdev(arlan_device
[i
]);
2048 if (arlan_device
[i
]->priv
)
2050 if (((struct arlan_private
*) arlan_device
[i
]->priv
)->conf
)
2051 kfree(((struct arlan_private
*) arlan_device
[i
]->priv
)->conf
);
2052 kfree(arlan_device
[i
]);
2054 arlan_device
[i
] = NULL
;
2057 ARLAN_DEBUG_EXIT("cleanup_module");