2 * Wavelan Pcmcia driver
6 * Reorganisation and extension of the driver.
7 * Original copyright follow. See wavelan_cs.p.h for details.
9 * This code is derived from Anthony D. Joseph's code and all the changes here
10 * are also under the original copyright below.
12 * This code supports version 2.00 of WaveLAN/PCMCIA cards (2.4GHz), and
13 * can work on Linux 2.0.36 with support of David Hinds' PCMCIA Card Services
15 * Joe Finney (joe@comp.lancs.ac.uk) at Lancaster University in UK added
16 * critical code in the routine to initialize the Modem Management Controller.
18 * Thanks to Alan Cox and Bruce Janson for their advice.
20 * -- Yunzhou Li (scip4166@nus.sg)
22 #ifdef WAVELAN_ROAMING
23 * Roaming support added 07/22/98 by Justin Seger (jseger@media.mit.edu)
24 * based on patch by Joe Finney from Lancaster University.
27 * Lucent (formerly AT&T GIS, formerly NCR) WaveLAN PCMCIA card: An
28 * Ethernet-like radio transceiver controlled by an Intel 82593 coprocessor.
30 * A non-shared memory PCMCIA ethernet driver for linux
32 * ISA version modified to support PCMCIA by Anthony Joseph (adj@lcs.mit.edu)
35 * Joseph O'Sullivan & John Langford (josullvn@cs.cmu.edu & jcl@cs.cmu.edu)
37 * Apr 2 '98 made changes to bring the i82593 control/int handling in line
38 * with offical specs...
40 ****************************************************************************
43 * Massachusetts Institute of Technology
45 * Permission to use, copy, modify, and distribute this program
46 * for any purpose and without fee is hereby granted, provided
47 * that this copyright and permission notice appear on all copies
48 * and supporting documentation, the name of M.I.T. not be used
49 * in advertising or publicity pertaining to distribution of the
50 * program without specific prior permission, and notice be given
51 * in supporting documentation that copying and distribution is
52 * by permission of M.I.T. M.I.T. makes no representations about
53 * the suitability of this software for any purpose. It is pro-
54 * vided "as is" without express or implied warranty.
55 ****************************************************************************
59 /* Do *NOT* add other headers here, you are guaranteed to be wrong - Jean II */
60 #include "wavelan_cs.p.h" /* Private header */
62 #ifdef WAVELAN_ROAMING
63 static void wl_cell_expiry(unsigned long data
);
64 static void wl_del_wavepoint(wavepoint_history
*wavepoint
, struct net_local
*lp
);
65 static void wv_nwid_filter(unsigned char mode
, net_local
*lp
);
66 #endif /* WAVELAN_ROAMING */
68 /************************* MISC SUBROUTINES **************************/
70 * Subroutines which won't fit in one of the following category
71 * (wavelan modem or i82593)
74 /******************* MODEM MANAGEMENT SUBROUTINES *******************/
76 * Useful subroutines to manage the modem of the wavelan
79 /*------------------------------------------------------------------*/
81 * Read from card's Host Adaptor Status Register.
84 hasr_read(u_long base
)
86 return(inb(HASR(base
)));
89 /*------------------------------------------------------------------*/
91 * Write to card's Host Adapter Command Register.
94 hacr_write(u_long base
,
97 outb(hacr
, HACR(base
));
100 /*------------------------------------------------------------------*/
102 * Write to card's Host Adapter Command Register. Include a delay for
103 * those times when it is needed.
106 hacr_write_slow(u_long base
,
109 hacr_write(base
, hacr
);
110 /* delay might only be needed sometimes */
112 } /* hacr_write_slow */
114 /*------------------------------------------------------------------*/
116 * Read the Parameter Storage Area from the WaveLAN card's memory
119 psa_read(struct net_device
* dev
,
120 int o
, /* offset in PSA */
121 u_char
* b
, /* buffer to fill */
122 int n
) /* size to read */
124 net_local
*lp
= netdev_priv(dev
);
125 u_char __iomem
*ptr
= lp
->mem
+ PSA_ADDR
+ (o
<< 1);
130 /* Due to a lack of address decode pins, the WaveLAN PCMCIA card
131 * only supports reading even memory addresses. That means the
132 * increment here MUST be two.
133 * Because of that, we can't use memcpy_fromio()...
139 /*------------------------------------------------------------------*/
141 * Write the Parameter Storage Area to the WaveLAN card's memory
144 psa_write(struct net_device
* dev
,
145 int o
, /* Offset in psa */
146 u_char
* b
, /* Buffer in memory */
147 int n
) /* Length of buffer */
149 net_local
*lp
= netdev_priv(dev
);
150 u_char __iomem
*ptr
= lp
->mem
+ PSA_ADDR
+ (o
<< 1);
152 unsigned int base
= dev
->base_addr
;
153 /* As there seem to have no flag PSA_BUSY as in the ISA model, we are
154 * oblige to verify this address to know when the PSA is ready... */
155 volatile u_char __iomem
*verify
= lp
->mem
+ PSA_ADDR
+
156 (psaoff(0, psa_comp_number
) << 1);
158 /* Authorize writing to PSA */
159 hacr_write(base
, HACR_PWR_STAT
| HACR_ROM_WEN
);
167 /* I don't have the spec, so I don't know what the correct
168 * sequence to write is. This hack seem to work for me... */
170 while((readb(verify
) != PSA_COMP_PCMCIA_915
) && (count
++ < 100))
174 /* Put the host interface back in standard state */
175 hacr_write(base
, HACR_DEFAULT
);
179 /*------------------------------------------------------------------*/
181 * Calculate the PSA CRC
182 * Thanks to Valster, Nico <NVALSTER@wcnd.nl.lucent.com> for the code
183 * NOTE: By specifying a length including the CRC position the
184 * returned value should be zero. (i.e. a correct checksum in the PSA)
186 * The Windows drivers don't use the CRC, but the AP and the PtP tool
190 psa_crc(unsigned char * psa
, /* The PSA */
191 int size
) /* Number of short for CRC */
193 int byte_cnt
; /* Loop on the PSA */
194 u_short crc_bytes
= 0; /* Data in the PSA */
195 int bit_cnt
; /* Loop on the bits of the short */
197 for(byte_cnt
= 0; byte_cnt
< size
; byte_cnt
++ )
199 crc_bytes
^= psa
[byte_cnt
]; /* Its an xor */
201 for(bit_cnt
= 1; bit_cnt
< 9; bit_cnt
++ )
203 if(crc_bytes
& 0x0001)
204 crc_bytes
= (crc_bytes
>> 1) ^ 0xA001;
212 #endif /* SET_PSA_CRC */
214 /*------------------------------------------------------------------*/
216 * update the checksum field in the Wavelan's PSA
219 update_psa_checksum(struct net_device
* dev
)
225 /* read the parameter storage area */
226 psa_read(dev
, 0, (unsigned char *) &psa
, sizeof(psa
));
228 /* update the checksum */
229 crc
= psa_crc((unsigned char *) &psa
,
230 sizeof(psa
) - sizeof(psa
.psa_crc
[0]) - sizeof(psa
.psa_crc
[1])
231 - sizeof(psa
.psa_crc_status
));
233 psa
.psa_crc
[0] = crc
& 0xFF;
234 psa
.psa_crc
[1] = (crc
& 0xFF00) >> 8;
237 psa_write(dev
, (char *)&psa
.psa_crc
- (char *)&psa
,
238 (unsigned char *)&psa
.psa_crc
, 2);
240 #ifdef DEBUG_IOCTL_INFO
241 printk (KERN_DEBUG
"%s: update_psa_checksum(): crc = 0x%02x%02x\n",
242 dev
->name
, psa
.psa_crc
[0], psa
.psa_crc
[1]);
244 /* Check again (luxury !) */
245 crc
= psa_crc((unsigned char *) &psa
,
246 sizeof(psa
) - sizeof(psa
.psa_crc_status
));
249 printk(KERN_WARNING
"%s: update_psa_checksum(): CRC does not agree with PSA data (even after recalculating)\n", dev
->name
);
250 #endif /* DEBUG_IOCTL_INFO */
251 #endif /* SET_PSA_CRC */
252 } /* update_psa_checksum */
254 /*------------------------------------------------------------------*/
256 * Write 1 byte to the MMC.
265 /* Wait for MMC to go idle */
266 while((count
++ < 100) && (inb(HASR(base
)) & HASR_MMI_BUSY
))
269 outb((u_char
)((o
<< 1) | MMR_MMI_WR
), MMR(base
));
273 /*------------------------------------------------------------------*/
275 * Routine to write bytes to the Modem Management Controller.
276 * We start by the end because it is the way it should be !
279 mmc_write(u_long base
,
288 mmc_out(base
, --o
, *(--b
));
291 /*------------------------------------------------------------------*/
293 * Read 1 byte from the MMC.
294 * Optimised version for 1 byte, avoid using memory...
302 while((count
++ < 100) && (inb(HASR(base
)) & HASR_MMI_BUSY
))
304 outb(o
<< 1, MMR(base
)); /* Set the read address */
306 outb(0, MMD(base
)); /* Required dummy write */
308 while((count
++ < 100) && (inb(HASR(base
)) & HASR_MMI_BUSY
))
310 return (u_char
) (inb(MMD(base
))); /* Now do the actual read */
313 /*------------------------------------------------------------------*/
315 * Routine to read bytes from the Modem Management Controller.
316 * The implementation is complicated by a lack of address lines,
317 * which prevents decoding of the low-order bit.
318 * (code has just been moved in the above function)
319 * We start by the end because it is the way it should be !
322 mmc_read(u_long base
,
331 *(--b
) = mmc_in(base
, --o
);
334 /*------------------------------------------------------------------*/
336 * Get the type of encryption available...
339 mmc_encr(u_long base
) /* i/o port of the card */
343 temp
= mmc_in(base
, mmroff(0, mmr_des_avail
));
344 if((temp
!= MMR_DES_AVAIL_DES
) && (temp
!= MMR_DES_AVAIL_AES
))
350 /*------------------------------------------------------------------*/
352 * Wait for the frequency EEprom to complete a command...
355 fee_wait(u_long base
, /* i/o port of the card */
356 int delay
, /* Base delay to wait for */
357 int number
) /* Number of time to wait */
359 int count
= 0; /* Wait only a limited time */
361 while((count
++ < number
) &&
362 (mmc_in(base
, mmroff(0, mmr_fee_status
)) & MMR_FEE_STATUS_BUSY
))
366 /*------------------------------------------------------------------*/
368 * Read bytes from the Frequency EEprom (frequency select cards).
371 fee_read(u_long base
, /* i/o port of the card */
372 u_short o
, /* destination offset */
373 u_short
* b
, /* data buffer */
374 int n
) /* number of registers */
376 b
+= n
; /* Position at the end of the area */
378 /* Write the address */
379 mmc_out(base
, mmwoff(0, mmw_fee_addr
), o
+ n
- 1);
381 /* Loop on all buffer */
384 /* Write the read command */
385 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_READ
);
387 /* Wait until EEprom is ready (should be quick !) */
388 fee_wait(base
, 10, 100);
391 *--b
= ((mmc_in(base
, mmroff(0, mmr_fee_data_h
)) << 8) |
392 mmc_in(base
, mmroff(0, mmr_fee_data_l
)));
397 /*------------------------------------------------------------------*/
399 * Write bytes from the Frequency EEprom (frequency select cards).
400 * This is a bit complicated, because the frequency eeprom has to
401 * be unprotected and the write enabled.
405 fee_write(u_long base
, /* i/o port of the card */
406 u_short o
, /* destination offset */
407 u_short
* b
, /* data buffer */
408 int n
) /* number of registers */
410 b
+= n
; /* Position at the end of the area */
412 #ifdef EEPROM_IS_PROTECTED /* disabled */
413 #ifdef DOESNT_SEEM_TO_WORK /* disabled */
414 /* Ask to read the protected register */
415 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_PRREAD
);
417 fee_wait(base
, 10, 100);
419 /* Read the protected register */
420 printk("Protected 2 : %02X-%02X\n",
421 mmc_in(base
, mmroff(0, mmr_fee_data_h
)),
422 mmc_in(base
, mmroff(0, mmr_fee_data_l
)));
423 #endif /* DOESNT_SEEM_TO_WORK */
425 /* Enable protected register */
426 mmc_out(base
, mmwoff(0, mmw_fee_addr
), MMW_FEE_ADDR_EN
);
427 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_PREN
);
429 fee_wait(base
, 10, 100);
432 mmc_out(base
, mmwoff(0, mmw_fee_addr
), o
+ n
);
433 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_PRWRITE
);
434 #ifdef DOESNT_SEEM_TO_WORK /* disabled */
436 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_PRCLEAR
);
437 #endif /* DOESNT_SEEM_TO_WORK */
439 fee_wait(base
, 10, 100);
440 #endif /* EEPROM_IS_PROTECTED */
443 mmc_out(base
, mmwoff(0, mmw_fee_addr
), MMW_FEE_ADDR_EN
);
444 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_WREN
);
446 fee_wait(base
, 10, 100);
448 /* Write the EEprom address */
449 mmc_out(base
, mmwoff(0, mmw_fee_addr
), o
+ n
- 1);
451 /* Loop on all buffer */
454 /* Write the value */
455 mmc_out(base
, mmwoff(0, mmw_fee_data_h
), (*--b
) >> 8);
456 mmc_out(base
, mmwoff(0, mmw_fee_data_l
), *b
& 0xFF);
458 /* Write the write command */
459 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_WRITE
);
461 /* Wavelan doc says : wait at least 10 ms for EEBUSY = 0 */
463 fee_wait(base
, 10, 100);
467 mmc_out(base
, mmwoff(0, mmw_fee_addr
), MMW_FEE_ADDR_DS
);
468 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_WDS
);
470 fee_wait(base
, 10, 100);
472 #ifdef EEPROM_IS_PROTECTED /* disabled */
473 /* Reprotect EEprom */
474 mmc_out(base
, mmwoff(0, mmw_fee_addr
), 0x00);
475 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
), MMW_FEE_CTRL_PRWRITE
);
477 fee_wait(base
, 10, 100);
478 #endif /* EEPROM_IS_PROTECTED */
481 /******************* WaveLAN Roaming routines... ********************/
483 #ifdef WAVELAN_ROAMING /* Conditional compile, see wavelan_cs.h */
485 static unsigned char WAVELAN_BEACON_ADDRESS
[] = {0x09,0x00,0x0e,0x20,0x03,0x00};
487 static void wv_roam_init(struct net_device
*dev
)
489 net_local
*lp
= netdev_priv(dev
);
491 /* Do not remove this unless you have a good reason */
492 printk(KERN_NOTICE
"%s: Warning, you have enabled roaming on"
493 " device %s !\n", dev
->name
, dev
->name
);
494 printk(KERN_NOTICE
"Roaming is currently an experimental unsupported feature"
495 " of the Wavelan driver.\n");
496 printk(KERN_NOTICE
"It may work, but may also make the driver behave in"
497 " erratic ways or crash.\n");
499 lp
->wavepoint_table
.head
=NULL
; /* Initialise WavePoint table */
500 lp
->wavepoint_table
.num_wavepoints
=0;
501 lp
->wavepoint_table
.locked
=0;
502 lp
->curr_point
=NULL
; /* No default WavePoint */
505 lp
->cell_timer
.data
=(long)lp
; /* Start cell expiry timer */
506 lp
->cell_timer
.function
=wl_cell_expiry
;
507 lp
->cell_timer
.expires
=jiffies
+CELL_TIMEOUT
;
508 add_timer(&lp
->cell_timer
);
510 wv_nwid_filter(NWID_PROMISC
,lp
) ; /* Enter NWID promiscuous mode */
511 /* to build up a good WavePoint */
513 printk(KERN_DEBUG
"WaveLAN: Roaming enabled on device %s\n",dev
->name
);
516 static void wv_roam_cleanup(struct net_device
*dev
)
518 wavepoint_history
*ptr
,*old_ptr
;
519 net_local
*lp
= netdev_priv(dev
);
521 printk(KERN_DEBUG
"WaveLAN: Roaming Disabled on device %s\n",dev
->name
);
523 /* Fixme : maybe we should check that the timer exist before deleting it */
524 del_timer(&lp
->cell_timer
); /* Remove cell expiry timer */
525 ptr
=lp
->wavepoint_table
.head
; /* Clear device's WavePoint table */
530 wl_del_wavepoint(old_ptr
,lp
);
534 /* Enable/Disable NWID promiscuous mode on a given device */
535 static void wv_nwid_filter(unsigned char mode
, net_local
*lp
)
540 #ifdef WAVELAN_ROAMING_DEBUG
541 printk(KERN_DEBUG
"WaveLAN: NWID promisc %s, device %s\n",(mode
==NWID_PROMISC
) ? "on" : "off", lp
->dev
->name
);
544 /* Disable interrupts & save flags */
545 spin_lock_irqsave(&lp
->spinlock
, flags
);
547 m
.w
.mmw_loopt_sel
= (mode
==NWID_PROMISC
) ? MMW_LOOPT_SEL_DIS_NWID
: 0x00;
548 mmc_write(lp
->dev
->base_addr
, (char *)&m
.w
.mmw_loopt_sel
- (char *)&m
, (unsigned char *)&m
.w
.mmw_loopt_sel
, 1);
550 if(mode
==NWID_PROMISC
)
555 /* ReEnable interrupts & restore flags */
556 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
559 /* Find a record in the WavePoint table matching a given NWID */
560 static wavepoint_history
*wl_roam_check(unsigned short nwid
, net_local
*lp
)
562 wavepoint_history
*ptr
=lp
->wavepoint_table
.head
;
572 /* Create a new wavepoint table entry */
573 static wavepoint_history
*wl_new_wavepoint(unsigned short nwid
, unsigned char seq
, net_local
* lp
)
575 wavepoint_history
*new_wavepoint
;
577 #ifdef WAVELAN_ROAMING_DEBUG
578 printk(KERN_DEBUG
"WaveLAN: New Wavepoint, NWID:%.4X\n",nwid
);
581 if(lp
->wavepoint_table
.num_wavepoints
==MAX_WAVEPOINTS
)
584 new_wavepoint
= kmalloc(sizeof(wavepoint_history
),GFP_ATOMIC
);
585 if(new_wavepoint
==NULL
)
588 new_wavepoint
->nwid
=nwid
; /* New WavePoints NWID */
589 new_wavepoint
->average_fast
=0; /* Running Averages..*/
590 new_wavepoint
->average_slow
=0;
591 new_wavepoint
->qualptr
=0; /* Start of ringbuffer */
592 new_wavepoint
->last_seq
=seq
-1; /* Last sequence no.seen */
593 memset(new_wavepoint
->sigqual
,0,WAVEPOINT_HISTORY
);/* Empty ringbuffer */
595 new_wavepoint
->next
=lp
->wavepoint_table
.head
;/* Add to wavepoint table */
596 new_wavepoint
->prev
=NULL
;
598 if(lp
->wavepoint_table
.head
!=NULL
)
599 lp
->wavepoint_table
.head
->prev
=new_wavepoint
;
601 lp
->wavepoint_table
.head
=new_wavepoint
;
603 lp
->wavepoint_table
.num_wavepoints
++; /* no. of visible wavepoints */
605 return new_wavepoint
;
608 /* Remove a wavepoint entry from WavePoint table */
609 static void wl_del_wavepoint(wavepoint_history
*wavepoint
, struct net_local
*lp
)
614 if(lp
->curr_point
==wavepoint
)
617 if(wavepoint
->prev
!=NULL
)
618 wavepoint
->prev
->next
=wavepoint
->next
;
620 if(wavepoint
->next
!=NULL
)
621 wavepoint
->next
->prev
=wavepoint
->prev
;
623 if(lp
->wavepoint_table
.head
==wavepoint
)
624 lp
->wavepoint_table
.head
=wavepoint
->next
;
626 lp
->wavepoint_table
.num_wavepoints
--;
630 /* Timer callback function - checks WavePoint table for stale entries */
631 static void wl_cell_expiry(unsigned long data
)
633 net_local
*lp
=(net_local
*)data
;
634 wavepoint_history
*wavepoint
=lp
->wavepoint_table
.head
,*old_point
;
636 #if WAVELAN_ROAMING_DEBUG > 1
637 printk(KERN_DEBUG
"WaveLAN: Wavepoint timeout, dev %s\n",lp
->dev
->name
);
640 if(lp
->wavepoint_table
.locked
)
642 #if WAVELAN_ROAMING_DEBUG > 1
643 printk(KERN_DEBUG
"WaveLAN: Wavepoint table locked...\n");
646 lp
->cell_timer
.expires
=jiffies
+1; /* If table in use, come back later */
647 add_timer(&lp
->cell_timer
);
651 while(wavepoint
!=NULL
)
653 if(time_after(jiffies
, wavepoint
->last_seen
+ CELL_TIMEOUT
))
655 #ifdef WAVELAN_ROAMING_DEBUG
656 printk(KERN_DEBUG
"WaveLAN: Bye bye %.4X\n",wavepoint
->nwid
);
660 wavepoint
=wavepoint
->next
;
661 wl_del_wavepoint(old_point
,lp
);
664 wavepoint
=wavepoint
->next
;
666 lp
->cell_timer
.expires
=jiffies
+CELL_TIMEOUT
;
667 add_timer(&lp
->cell_timer
);
670 /* Update SNR history of a wavepoint */
671 static void wl_update_history(wavepoint_history
*wavepoint
, unsigned char sigqual
, unsigned char seq
)
673 int i
=0,num_missed
=0,ptr
=0;
674 int average_fast
=0,average_slow
=0;
676 num_missed
=(seq
-wavepoint
->last_seq
)%WAVEPOINT_HISTORY
;/* Have we missed
679 for(i
=0;i
<num_missed
;i
++)
681 wavepoint
->sigqual
[wavepoint
->qualptr
++]=0; /* If so, enter them as 0's */
682 wavepoint
->qualptr
%=WAVEPOINT_HISTORY
; /* in the ringbuffer. */
684 wavepoint
->last_seen
=jiffies
; /* Add beacon to history */
685 wavepoint
->last_seq
=seq
;
686 wavepoint
->sigqual
[wavepoint
->qualptr
++]=sigqual
;
687 wavepoint
->qualptr
%=WAVEPOINT_HISTORY
;
688 ptr
=(wavepoint
->qualptr
-WAVEPOINT_FAST_HISTORY
+WAVEPOINT_HISTORY
)%WAVEPOINT_HISTORY
;
690 for(i
=0;i
<WAVEPOINT_FAST_HISTORY
;i
++) /* Update running averages */
692 average_fast
+=wavepoint
->sigqual
[ptr
++];
693 ptr
%=WAVEPOINT_HISTORY
;
696 average_slow
=average_fast
;
697 for(i
=WAVEPOINT_FAST_HISTORY
;i
<WAVEPOINT_HISTORY
;i
++)
699 average_slow
+=wavepoint
->sigqual
[ptr
++];
700 ptr
%=WAVEPOINT_HISTORY
;
703 wavepoint
->average_fast
=average_fast
/WAVEPOINT_FAST_HISTORY
;
704 wavepoint
->average_slow
=average_slow
/WAVEPOINT_HISTORY
;
707 /* Perform a handover to a new WavePoint */
708 static void wv_roam_handover(wavepoint_history
*wavepoint
, net_local
*lp
)
710 unsigned int base
= lp
->dev
->base_addr
;
714 if(wavepoint
==lp
->curr_point
) /* Sanity check... */
716 wv_nwid_filter(!NWID_PROMISC
,lp
);
720 #ifdef WAVELAN_ROAMING_DEBUG
721 printk(KERN_DEBUG
"WaveLAN: Doing handover to %.4X, dev %s\n",wavepoint
->nwid
,lp
->dev
->name
);
724 /* Disable interrupts & save flags */
725 spin_lock_irqsave(&lp
->spinlock
, flags
);
727 m
.w
.mmw_netw_id_l
= wavepoint
->nwid
& 0xFF;
728 m
.w
.mmw_netw_id_h
= (wavepoint
->nwid
& 0xFF00) >> 8;
730 mmc_write(base
, (char *)&m
.w
.mmw_netw_id_l
- (char *)&m
, (unsigned char *)&m
.w
.mmw_netw_id_l
, 2);
732 /* ReEnable interrupts & restore flags */
733 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
735 wv_nwid_filter(!NWID_PROMISC
,lp
);
736 lp
->curr_point
=wavepoint
;
739 /* Called when a WavePoint beacon is received */
740 static void wl_roam_gather(struct net_device
* dev
,
741 u_char
* hdr
, /* Beacon header */
742 u_char
* stats
) /* SNR, Signal quality
745 wavepoint_beacon
*beacon
= (wavepoint_beacon
*)hdr
; /* Rcvd. Beacon */
746 unsigned short nwid
=ntohs(beacon
->nwid
);
747 unsigned short sigqual
=stats
[2] & MMR_SGNL_QUAL
; /* SNR of beacon */
748 wavepoint_history
*wavepoint
=NULL
; /* WavePoint table entry */
749 net_local
*lp
= netdev_priv(dev
); /* Device info */
751 #ifdef I_NEED_THIS_FEATURE
752 /* Some people don't need this, some other may need it */
753 nwid
=nwid
^ntohs(beacon
->domain_id
);
756 #if WAVELAN_ROAMING_DEBUG > 1
757 printk(KERN_DEBUG
"WaveLAN: beacon, dev %s:\n",dev
->name
);
758 printk(KERN_DEBUG
"Domain: %.4X NWID: %.4X SigQual=%d\n",ntohs(beacon
->domain_id
),nwid
,sigqual
);
761 lp
->wavepoint_table
.locked
=1; /* <Mutex> */
763 wavepoint
=wl_roam_check(nwid
,lp
); /* Find WavePoint table entry */
764 if(wavepoint
==NULL
) /* If no entry, Create a new one... */
766 wavepoint
=wl_new_wavepoint(nwid
,beacon
->seq
,lp
);
770 if(lp
->curr_point
==NULL
) /* If this is the only WavePoint, */
771 wv_roam_handover(wavepoint
, lp
); /* Jump on it! */
773 wl_update_history(wavepoint
, sigqual
, beacon
->seq
); /* Update SNR history
776 if(lp
->curr_point
->average_slow
< SEARCH_THRESH_LOW
) /* If our current */
777 if(!lp
->cell_search
) /* WavePoint is getting faint, */
778 wv_nwid_filter(NWID_PROMISC
,lp
); /* start looking for a new one */
780 if(wavepoint
->average_slow
>
781 lp
->curr_point
->average_slow
+ WAVELAN_ROAMING_DELTA
)
782 wv_roam_handover(wavepoint
, lp
); /* Handover to a better WavePoint */
784 if(lp
->curr_point
->average_slow
> SEARCH_THRESH_HIGH
) /* If our SNR is */
785 if(lp
->cell_search
) /* getting better, drop out of cell search mode */
786 wv_nwid_filter(!NWID_PROMISC
,lp
);
789 lp
->wavepoint_table
.locked
=0; /* </MUTEX> :-) */
792 /* Test this MAC frame a WavePoint beacon */
793 static inline int WAVELAN_BEACON(unsigned char *data
)
795 wavepoint_beacon
*beacon
= (wavepoint_beacon
*)data
;
796 static const wavepoint_beacon beacon_template
={0xaa,0xaa,0x03,0x08,0x00,0x0e,0x20,0x03,0x00};
798 if(memcmp(beacon
,&beacon_template
,9)==0)
803 #endif /* WAVELAN_ROAMING */
805 /************************ I82593 SUBROUTINES *************************/
807 * Useful subroutines to manage the Ethernet controller
810 /*------------------------------------------------------------------*/
812 * Routine to synchronously send a command to the i82593 chip.
813 * Should be called with interrupts disabled.
814 * (called by wv_packet_write(), wv_ru_stop(), wv_ru_start(),
815 * wv_82593_config() & wv_diag())
818 wv_82593_cmd(struct net_device
* dev
,
823 unsigned int base
= dev
->base_addr
;
828 /* Spin until the chip finishes executing its current command (if any) */
832 /* Time calibration of the loop */
835 /* Read the interrupt register */
836 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
837 status
= inb(LCSR(base
));
839 while(((status
& SR3_EXEC_STATE_MASK
) != SR3_EXEC_IDLE
) && (spin
-- > 0));
841 /* If the interrupt hasn't been posted */
843 #ifdef DEBUG_INTERRUPT_ERROR
844 printk(KERN_INFO
"wv_82593_cmd: %s timeout (previous command), status 0x%02x\n",
850 /* Issue the command to the controller */
851 outb(cmd
, LCCR(base
));
853 /* If we don't have to check the result of the command
854 * Note : this mean that the irq handler will deal with that */
855 if(result
== SR0_NO_RESULT
)
858 /* We are waiting for command completion */
859 wait_completed
= TRUE
;
861 /* Busy wait while the LAN controller executes the command. */
865 /* Time calibration of the loop */
868 /* Read the interrupt register */
869 outb(CR0_STATUS_0
| OP0_NOP
, LCCR(base
));
870 status
= inb(LCSR(base
));
872 /* Check if there was an interrupt posted */
873 if((status
& SR0_INTERRUPT
))
875 /* Acknowledge the interrupt */
876 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
));
878 /* Check if interrupt is a command completion */
879 if(((status
& SR0_BOTH_RX_TX
) != SR0_BOTH_RX_TX
) &&
880 ((status
& SR0_BOTH_RX_TX
) != 0x0) &&
881 !(status
& SR0_RECEPTION
))
883 /* Signal command completion */
884 wait_completed
= FALSE
;
888 /* Note : Rx interrupts will be handled later, because we can
889 * handle multiple Rx packets at once */
890 #ifdef DEBUG_INTERRUPT_INFO
891 printk(KERN_INFO
"wv_82593_cmd: not our interrupt\n");
896 while(wait_completed
&& (spin
-- > 0));
898 /* If the interrupt hasn't be posted */
901 #ifdef DEBUG_INTERRUPT_ERROR
902 printk(KERN_INFO
"wv_82593_cmd: %s timeout, status 0x%02x\n",
908 /* Check the return code returned by the card (see above) against
909 * the expected return code provided by the caller */
910 if((status
& SR0_EVENT_MASK
) != result
)
912 #ifdef DEBUG_INTERRUPT_ERROR
913 printk(KERN_INFO
"wv_82593_cmd: %s failed, status = 0x%x\n",
922 /*------------------------------------------------------------------*/
924 * This routine does a 593 op-code number 7, and obtains the diagnose
925 * status for the WaveLAN.
928 wv_diag(struct net_device
* dev
)
930 return(wv_82593_cmd(dev
, "wv_diag(): diagnose",
931 OP0_DIAGNOSE
, SR0_DIAGNOSE_PASSED
));
934 /*------------------------------------------------------------------*/
936 * Routine to read len bytes from the i82593's ring buffer, starting at
937 * chip address addr. The results read from the chip are stored in buf.
938 * The return value is the address to use for next the call.
941 read_ringbuf(struct net_device
* dev
,
946 unsigned int base
= dev
->base_addr
;
949 char * buf_ptr
= buf
;
951 /* Get all the buffer */
954 /* Position the Program I/O Register at the ring buffer pointer */
955 outb(ring_ptr
& 0xff, PIORL(base
));
956 outb(((ring_ptr
>> 8) & PIORH_MASK
), PIORH(base
));
958 /* First, determine how much we can read without wrapping around the
960 if((addr
+ len
) < (RX_BASE
+ RX_SIZE
))
963 chunk_len
= RX_BASE
+ RX_SIZE
- addr
;
964 insb(PIOP(base
), buf_ptr
, chunk_len
);
965 buf_ptr
+= chunk_len
;
967 ring_ptr
= (ring_ptr
- RX_BASE
+ chunk_len
) % RX_SIZE
+ RX_BASE
;
972 /*------------------------------------------------------------------*/
974 * Reconfigure the i82593, or at least ask for it...
975 * Because wv_82593_config use the transmission buffer, we must do it
976 * when we are sure that there is no transmission, so we do it now
977 * or in wavelan_packet_xmit() (I can't find any better place,
978 * wavelan_interrupt is not an option...), so you may experience
979 * some delay sometime...
982 wv_82593_reconfig(struct net_device
* dev
)
984 net_local
* lp
= netdev_priv(dev
);
985 struct pcmcia_device
* link
= lp
->link
;
988 /* Arm the flag, will be cleard in wv_82593_config() */
989 lp
->reconfig_82593
= TRUE
;
991 /* Check if we can do it now ! */
992 if((link
->open
) && (netif_running(dev
)) && !(netif_queue_stopped(dev
)))
994 spin_lock_irqsave(&lp
->spinlock
, flags
); /* Disable interrupts */
995 wv_82593_config(dev
);
996 spin_unlock_irqrestore(&lp
->spinlock
, flags
); /* Re-enable interrupts */
1000 #ifdef DEBUG_IOCTL_INFO
1002 "%s: wv_82593_reconfig(): delayed (state = %lX, link = %d)\n",
1003 dev
->name
, dev
->state
, link
->open
);
1008 /********************* DEBUG & INFO SUBROUTINES *********************/
1010 * This routines are used in the code to show debug informations.
1011 * Most of the time, it dump the content of hardware structures...
1014 #ifdef DEBUG_PSA_SHOW
1015 /*------------------------------------------------------------------*/
1017 * Print the formatted contents of the Parameter Storage Area.
1020 wv_psa_show(psa_t
* p
)
1022 printk(KERN_DEBUG
"##### wavelan psa contents: #####\n");
1023 printk(KERN_DEBUG
"psa_io_base_addr_1: 0x%02X %02X %02X %02X\n",
1024 p
->psa_io_base_addr_1
,
1025 p
->psa_io_base_addr_2
,
1026 p
->psa_io_base_addr_3
,
1027 p
->psa_io_base_addr_4
);
1028 printk(KERN_DEBUG
"psa_rem_boot_addr_1: 0x%02X %02X %02X\n",
1029 p
->psa_rem_boot_addr_1
,
1030 p
->psa_rem_boot_addr_2
,
1031 p
->psa_rem_boot_addr_3
);
1032 printk(KERN_DEBUG
"psa_holi_params: 0x%02x, ", p
->psa_holi_params
);
1033 printk("psa_int_req_no: %d\n", p
->psa_int_req_no
);
1034 #ifdef DEBUG_SHOW_UNUSED
1035 printk(KERN_DEBUG
"psa_unused0[]: %pM\n", p
->psa_unused0
);
1036 #endif /* DEBUG_SHOW_UNUSED */
1037 printk(KERN_DEBUG
"psa_univ_mac_addr[]: %pM\n", p
->psa_univ_mac_addr
);
1038 printk(KERN_DEBUG
"psa_local_mac_addr[]: %pM\n", p
->psa_local_mac_addr
);
1039 printk(KERN_DEBUG
"psa_univ_local_sel: %d, ", p
->psa_univ_local_sel
);
1040 printk("psa_comp_number: %d, ", p
->psa_comp_number
);
1041 printk("psa_thr_pre_set: 0x%02x\n", p
->psa_thr_pre_set
);
1042 printk(KERN_DEBUG
"psa_feature_select/decay_prm: 0x%02x, ",
1043 p
->psa_feature_select
);
1044 printk("psa_subband/decay_update_prm: %d\n", p
->psa_subband
);
1045 printk(KERN_DEBUG
"psa_quality_thr: 0x%02x, ", p
->psa_quality_thr
);
1046 printk("psa_mod_delay: 0x%02x\n", p
->psa_mod_delay
);
1047 printk(KERN_DEBUG
"psa_nwid: 0x%02x%02x, ", p
->psa_nwid
[0], p
->psa_nwid
[1]);
1048 printk("psa_nwid_select: %d\n", p
->psa_nwid_select
);
1049 printk(KERN_DEBUG
"psa_encryption_select: %d, ", p
->psa_encryption_select
);
1050 printk("psa_encryption_key[]: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
1051 p
->psa_encryption_key
[0],
1052 p
->psa_encryption_key
[1],
1053 p
->psa_encryption_key
[2],
1054 p
->psa_encryption_key
[3],
1055 p
->psa_encryption_key
[4],
1056 p
->psa_encryption_key
[5],
1057 p
->psa_encryption_key
[6],
1058 p
->psa_encryption_key
[7]);
1059 printk(KERN_DEBUG
"psa_databus_width: %d\n", p
->psa_databus_width
);
1060 printk(KERN_DEBUG
"psa_call_code/auto_squelch: 0x%02x, ",
1061 p
->psa_call_code
[0]);
1062 printk("psa_call_code[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
1063 p
->psa_call_code
[0],
1064 p
->psa_call_code
[1],
1065 p
->psa_call_code
[2],
1066 p
->psa_call_code
[3],
1067 p
->psa_call_code
[4],
1068 p
->psa_call_code
[5],
1069 p
->psa_call_code
[6],
1070 p
->psa_call_code
[7]);
1071 #ifdef DEBUG_SHOW_UNUSED
1072 printk(KERN_DEBUG
"psa_reserved[]: %02X:%02X\n",
1074 p
->psa_reserved
[1]);
1075 #endif /* DEBUG_SHOW_UNUSED */
1076 printk(KERN_DEBUG
"psa_conf_status: %d, ", p
->psa_conf_status
);
1077 printk("psa_crc: 0x%02x%02x, ", p
->psa_crc
[0], p
->psa_crc
[1]);
1078 printk("psa_crc_status: 0x%02x\n", p
->psa_crc_status
);
1080 #endif /* DEBUG_PSA_SHOW */
1082 #ifdef DEBUG_MMC_SHOW
1083 /*------------------------------------------------------------------*/
1085 * Print the formatted status of the Modem Management Controller.
1086 * This function need to be completed...
1089 wv_mmc_show(struct net_device
* dev
)
1091 unsigned int base
= dev
->base_addr
;
1092 net_local
* lp
= netdev_priv(dev
);
1096 if(hasr_read(base
) & HASR_NO_CLK
)
1098 printk(KERN_WARNING
"%s: wv_mmc_show: modem not connected\n",
1103 spin_lock_irqsave(&lp
->spinlock
, flags
);
1106 mmc_out(base
, mmwoff(0, mmw_freeze
), 1);
1107 mmc_read(base
, 0, (u_char
*)&m
, sizeof(m
));
1108 mmc_out(base
, mmwoff(0, mmw_freeze
), 0);
1110 /* Don't forget to update statistics */
1111 lp
->wstats
.discard
.nwid
+= (m
.mmr_wrong_nwid_h
<< 8) | m
.mmr_wrong_nwid_l
;
1113 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1115 printk(KERN_DEBUG
"##### wavelan modem status registers: #####\n");
1116 #ifdef DEBUG_SHOW_UNUSED
1117 printk(KERN_DEBUG
"mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
1126 #endif /* DEBUG_SHOW_UNUSED */
1127 printk(KERN_DEBUG
"Encryption algorithm: %02X - Status: %02X\n",
1128 m
.mmr_des_avail
, m
.mmr_des_status
);
1129 #ifdef DEBUG_SHOW_UNUSED
1130 printk(KERN_DEBUG
"mmc_unused1[]: %02X:%02X:%02X:%02X:%02X\n",
1136 #endif /* DEBUG_SHOW_UNUSED */
1137 printk(KERN_DEBUG
"dce_status: 0x%x [%s%s%s%s]\n",
1139 (m
.mmr_dce_status
& MMR_DCE_STATUS_RX_BUSY
) ? "energy detected,":"",
1140 (m
.mmr_dce_status
& MMR_DCE_STATUS_LOOPT_IND
) ?
1141 "loop test indicated," : "",
1142 (m
.mmr_dce_status
& MMR_DCE_STATUS_TX_BUSY
) ? "transmitter on," : "",
1143 (m
.mmr_dce_status
& MMR_DCE_STATUS_JBR_EXPIRED
) ?
1144 "jabber timer expired," : "");
1145 printk(KERN_DEBUG
"Dsp ID: %02X\n",
1147 #ifdef DEBUG_SHOW_UNUSED
1148 printk(KERN_DEBUG
"mmc_unused2[]: %02X:%02X\n",
1151 #endif /* DEBUG_SHOW_UNUSED */
1152 printk(KERN_DEBUG
"# correct_nwid: %d, # wrong_nwid: %d\n",
1153 (m
.mmr_correct_nwid_h
<< 8) | m
.mmr_correct_nwid_l
,
1154 (m
.mmr_wrong_nwid_h
<< 8) | m
.mmr_wrong_nwid_l
);
1155 printk(KERN_DEBUG
"thr_pre_set: 0x%x [current signal %s]\n",
1156 m
.mmr_thr_pre_set
& MMR_THR_PRE_SET
,
1157 (m
.mmr_thr_pre_set
& MMR_THR_PRE_SET_CUR
) ? "above" : "below");
1158 printk(KERN_DEBUG
"signal_lvl: %d [%s], ",
1159 m
.mmr_signal_lvl
& MMR_SIGNAL_LVL
,
1160 (m
.mmr_signal_lvl
& MMR_SIGNAL_LVL_VALID
) ? "new msg" : "no new msg");
1161 printk("silence_lvl: %d [%s], ", m
.mmr_silence_lvl
& MMR_SILENCE_LVL
,
1162 (m
.mmr_silence_lvl
& MMR_SILENCE_LVL_VALID
) ? "update done" : "no new update");
1163 printk("sgnl_qual: 0x%x [%s]\n", m
.mmr_sgnl_qual
& MMR_SGNL_QUAL
,
1164 (m
.mmr_sgnl_qual
& MMR_SGNL_QUAL_ANT
) ? "Antenna 1" : "Antenna 0");
1165 #ifdef DEBUG_SHOW_UNUSED
1166 printk(KERN_DEBUG
"netw_id_l: %x\n", m
.mmr_netw_id_l
);
1167 #endif /* DEBUG_SHOW_UNUSED */
1169 #endif /* DEBUG_MMC_SHOW */
1171 #ifdef DEBUG_I82593_SHOW
1172 /*------------------------------------------------------------------*/
1174 * Print the formatted status of the i82593's receive unit.
1177 wv_ru_show(struct net_device
* dev
)
1179 net_local
*lp
= netdev_priv(dev
);
1181 printk(KERN_DEBUG
"##### wavelan i82593 receiver status: #####\n");
1182 printk(KERN_DEBUG
"ru: rfp %d stop %d", lp
->rfp
, lp
->stop
);
1184 * Not implemented yet...
1188 #endif /* DEBUG_I82593_SHOW */
1190 #ifdef DEBUG_DEVICE_SHOW
1191 /*------------------------------------------------------------------*/
1193 * Print the formatted status of the WaveLAN PCMCIA device driver.
1196 wv_dev_show(struct net_device
* dev
)
1198 printk(KERN_DEBUG
"dev:");
1199 printk(" state=%lX,", dev
->state
);
1200 printk(" trans_start=%ld,", dev
->trans_start
);
1201 printk(" flags=0x%x,", dev
->flags
);
1205 /*------------------------------------------------------------------*/
1207 * Print the formatted status of the WaveLAN PCMCIA device driver's
1208 * private information.
1211 wv_local_show(struct net_device
* dev
)
1213 net_local
*lp
= netdev_priv(dev
);
1215 printk(KERN_DEBUG
"local:");
1217 * Not implemented yet...
1220 } /* wv_local_show */
1221 #endif /* DEBUG_DEVICE_SHOW */
1223 #if defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO)
1224 /*------------------------------------------------------------------*/
1226 * Dump packet header (and content if necessary) on the screen
1229 wv_packet_info(u_char
* p
, /* Packet to dump */
1230 int length
, /* Length of the packet */
1231 char * msg1
, /* Name of the device */
1232 char * msg2
) /* Name of the function */
1237 printk(KERN_DEBUG
"%s: %s(): dest %pM, length %d\n",
1238 msg1
, msg2
, p
, length
);
1239 printk(KERN_DEBUG
"%s: %s(): src %pM, type 0x%02X%02X\n",
1240 msg1
, msg2
, &p
[6], p
[12], p
[13]);
1242 #ifdef DEBUG_PACKET_DUMP
1244 printk(KERN_DEBUG
"data=\"");
1246 if((maxi
= length
) > DEBUG_PACKET_DUMP
)
1247 maxi
= DEBUG_PACKET_DUMP
;
1248 for(i
= 14; i
< maxi
; i
++)
1249 if(p
[i
] >= ' ' && p
[i
] <= '~')
1250 printk(" %c", p
[i
]);
1252 printk("%02X", p
[i
]);
1256 printk(KERN_DEBUG
"\n");
1257 #endif /* DEBUG_PACKET_DUMP */
1259 #endif /* defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO) */
1261 /*------------------------------------------------------------------*/
1263 * This is the information which is displayed by the driver at startup
1264 * There is a lot of flag to configure it at your will...
1267 wv_init_info(struct net_device
* dev
)
1269 unsigned int base
= dev
->base_addr
;
1272 /* Read the parameter storage area */
1273 psa_read(dev
, 0, (unsigned char *) &psa
, sizeof(psa
));
1275 #ifdef DEBUG_PSA_SHOW
1278 #ifdef DEBUG_MMC_SHOW
1281 #ifdef DEBUG_I82593_SHOW
1285 #ifdef DEBUG_BASIC_SHOW
1286 /* Now, let's go for the basic stuff */
1287 printk(KERN_NOTICE
"%s: WaveLAN: port %#x, irq %d, hw_addr %pM",
1288 dev
->name
, base
, dev
->irq
, dev
->dev_addr
);
1290 /* Print current network id */
1291 if(psa
.psa_nwid_select
)
1292 printk(", nwid 0x%02X-%02X", psa
.psa_nwid
[0], psa
.psa_nwid
[1]);
1294 printk(", nwid off");
1297 if(!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
1298 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
)))
1300 unsigned short freq
;
1302 /* Ask the EEprom to read the frequency from the first area */
1303 fee_read(base
, 0x00 /* 1st area - frequency... */,
1306 /* Print frequency */
1307 printk(", 2.00, %ld", (freq
>> 6) + 2400L);
1315 printk(", PCMCIA, ");
1316 switch (psa
.psa_subband
)
1318 case PSA_SUBBAND_915
:
1321 case PSA_SUBBAND_2425
:
1324 case PSA_SUBBAND_2460
:
1327 case PSA_SUBBAND_2484
:
1330 case PSA_SUBBAND_2430_5
:
1339 #endif /* DEBUG_BASIC_SHOW */
1341 #ifdef DEBUG_VERSION_SHOW
1342 /* Print version information */
1343 printk(KERN_NOTICE
"%s", version
);
1345 } /* wv_init_info */
1347 /********************* IOCTL, STATS & RECONFIG *********************/
1349 * We found here routines that are called by Linux on differents
1350 * occasions after the configuration and not for transmitting data
1351 * These may be called when the user use ifconfig, /proc/net/dev
1352 * or wireless extensions
1356 /*------------------------------------------------------------------*/
1358 * Set or clear the multicast filter for this adaptor.
1359 * num_addrs == -1 Promiscuous mode, receive all packets
1360 * num_addrs == 0 Normal mode, clear multicast list
1361 * num_addrs > 0 Multicast mode, receive normal and MC packets,
1362 * and do best-effort filtering.
1366 wavelan_set_multicast_list(struct net_device
* dev
)
1368 net_local
* lp
= netdev_priv(dev
);
1370 #ifdef DEBUG_IOCTL_TRACE
1371 printk(KERN_DEBUG
"%s: ->wavelan_set_multicast_list()\n", dev
->name
);
1374 #ifdef DEBUG_IOCTL_INFO
1375 printk(KERN_DEBUG
"%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n",
1376 dev
->name
, dev
->flags
, netdev_mc_count(dev
));
1379 if(dev
->flags
& IFF_PROMISC
)
1382 * Enable promiscuous mode: receive all packets.
1384 if(!lp
->promiscuous
)
1386 lp
->promiscuous
= 1;
1387 lp
->allmulticast
= 0;
1390 wv_82593_reconfig(dev
);
1394 /* If all multicast addresses
1395 * or too much multicast addresses for the hardware filter */
1396 if((dev
->flags
& IFF_ALLMULTI
) ||
1397 (netdev_mc_count(dev
) > I82593_MAX_MULTICAST_ADDRESSES
))
1400 * Disable promiscuous mode, but active the all multicast mode
1402 if(!lp
->allmulticast
)
1404 lp
->promiscuous
= 0;
1405 lp
->allmulticast
= 1;
1408 wv_82593_reconfig(dev
);
1412 /* If there is some multicast addresses to send */
1413 if (!netdev_mc_empty(dev
)) {
1415 * Disable promiscuous mode, but receive all packets
1418 #ifdef MULTICAST_AVOID
1419 if(lp
->promiscuous
|| lp
->allmulticast
||
1420 (netdev_mc_count(dev
) != lp
->mc_count
))
1423 lp
->promiscuous
= 0;
1424 lp
->allmulticast
= 0;
1425 lp
->mc_count
= netdev_mc_count(dev
);
1427 wv_82593_reconfig(dev
);
1433 * Switch to normal mode: disable promiscuous mode and
1434 * clear the multicast list.
1436 if(lp
->promiscuous
|| lp
->mc_count
== 0)
1438 lp
->promiscuous
= 0;
1439 lp
->allmulticast
= 0;
1442 wv_82593_reconfig(dev
);
1445 #ifdef DEBUG_IOCTL_TRACE
1446 printk(KERN_DEBUG
"%s: <-wavelan_set_multicast_list()\n", dev
->name
);
1450 /*------------------------------------------------------------------*/
1452 * This function doesn't exist...
1453 * (Note : it was a nice way to test the reconfigure stuff...)
1455 #ifdef SET_MAC_ADDRESS
1457 wavelan_set_mac_address(struct net_device
* dev
,
1460 struct sockaddr
* mac
= addr
;
1462 /* Copy the address */
1463 memcpy(dev
->dev_addr
, mac
->sa_data
, WAVELAN_ADDR_SIZE
);
1465 /* Reconfig the beast */
1466 wv_82593_reconfig(dev
);
1470 #endif /* SET_MAC_ADDRESS */
1473 /*------------------------------------------------------------------*/
1475 * Frequency setting (for hardware able of it)
1476 * It's a bit complicated and you don't really want to look into it...
1479 wv_set_frequency(u_long base
, /* i/o port of the card */
1480 iw_freq
* frequency
)
1482 const int BAND_NUM
= 10; /* Number of bands */
1483 long freq
= 0L; /* offset to 2.4 GHz in .5 MHz */
1484 #ifdef DEBUG_IOCTL_INFO
1488 /* Setting by frequency */
1489 /* Theoritically, you may set any frequency between
1490 * the two limits with a 0.5 MHz precision. In practice,
1491 * I don't want you to have trouble with local
1493 if((frequency
->e
== 1) &&
1494 (frequency
->m
>= (int) 2.412e8
) && (frequency
->m
<= (int) 2.487e8
))
1496 freq
= ((frequency
->m
/ 10000) - 24000L) / 5;
1499 /* Setting by channel (same as wfreqsel) */
1500 /* Warning : each channel is 22MHz wide, so some of the channels
1501 * will interfere... */
1502 if((frequency
->e
== 0) &&
1503 (frequency
->m
>= 0) && (frequency
->m
< BAND_NUM
))
1505 /* Get frequency offset. */
1506 freq
= channel_bands
[frequency
->m
] >> 1;
1509 /* Verify if the frequency is allowed */
1512 u_short table
[10]; /* Authorized frequency table */
1514 /* Read the frequency table */
1515 fee_read(base
, 0x71 /* frequency table */,
1518 #ifdef DEBUG_IOCTL_INFO
1519 printk(KERN_DEBUG
"Frequency table :");
1520 for(i
= 0; i
< 10; i
++)
1528 /* Look in the table if the frequency is allowed */
1529 if(!(table
[9 - ((freq
- 24) / 16)] &
1530 (1 << ((freq
- 24) % 16))))
1531 return -EINVAL
; /* not allowed */
1536 /* If we get a usable frequency */
1539 unsigned short area
[16];
1540 unsigned short dac
[2];
1541 unsigned short area_verify
[16];
1542 unsigned short dac_verify
[2];
1543 /* Corresponding gain (in the power adjust value table)
1544 * see AT&T Wavelan Data Manual, REF 407-024689/E, page 3-8
1545 * & WCIN062D.DOC, page 6.2.9 */
1546 unsigned short power_limit
[] = { 40, 80, 120, 160, 0 };
1547 int power_band
= 0; /* Selected band */
1548 unsigned short power_adjust
; /* Correct value */
1550 /* Search for the gain */
1552 while((freq
> power_limit
[power_band
]) &&
1553 (power_limit
[++power_band
] != 0))
1556 /* Read the first area */
1557 fee_read(base
, 0x00,
1561 fee_read(base
, 0x60,
1564 /* Read the new power adjust value */
1565 fee_read(base
, 0x6B - (power_band
>> 1),
1567 if(power_band
& 0x1)
1570 power_adjust
&= 0xFF;
1572 #ifdef DEBUG_IOCTL_INFO
1573 printk(KERN_DEBUG
"Wavelan EEprom Area 1 :");
1574 for(i
= 0; i
< 16; i
++)
1581 printk(KERN_DEBUG
"Wavelan EEprom DAC : %04X %04X\n",
1585 /* Frequency offset (for info only...) */
1586 area
[0] = ((freq
<< 5) & 0xFFE0) | (area
[0] & 0x1F);
1588 /* Receiver Principle main divider coefficient */
1589 area
[3] = (freq
>> 1) + 2400L - 352L;
1590 area
[2] = ((freq
& 0x1) << 4) | (area
[2] & 0xFFEF);
1592 /* Transmitter Main divider coefficient */
1593 area
[13] = (freq
>> 1) + 2400L;
1594 area
[12] = ((freq
& 0x1) << 4) | (area
[2] & 0xFFEF);
1596 /* Others part of the area are flags, bit streams or unused... */
1598 /* Set the value in the DAC */
1599 dac
[1] = ((power_adjust
>> 1) & 0x7F) | (dac
[1] & 0xFF80);
1600 dac
[0] = ((power_adjust
& 0x1) << 4) | (dac
[0] & 0xFFEF);
1602 /* Write the first area */
1603 fee_write(base
, 0x00,
1607 fee_write(base
, 0x60,
1610 /* We now should verify here that the EEprom writing was ok */
1612 /* ReRead the first area */
1613 fee_read(base
, 0x00,
1616 /* ReRead the DAC */
1617 fee_read(base
, 0x60,
1621 if(memcmp(area
, area_verify
, 16 * 2) ||
1622 memcmp(dac
, dac_verify
, 2 * 2))
1624 #ifdef DEBUG_IOCTL_ERROR
1625 printk(KERN_INFO
"Wavelan: wv_set_frequency : unable to write new frequency to EEprom (?)\n");
1630 /* We must download the frequency parameters to the
1631 * synthetisers (from the EEprom - area 1)
1632 * Note : as the EEprom is auto decremented, we set the end
1634 mmc_out(base
, mmwoff(0, mmw_fee_addr
), 0x0F);
1635 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
),
1636 MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
);
1638 /* Wait until the download is finished */
1639 fee_wait(base
, 100, 100);
1641 /* We must now download the power adjust value (gain) to
1642 * the synthetisers (from the EEprom - area 7 - DAC) */
1643 mmc_out(base
, mmwoff(0, mmw_fee_addr
), 0x61);
1644 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
),
1645 MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
);
1647 /* Wait until the download is finished */
1648 fee_wait(base
, 100, 100);
1650 #ifdef DEBUG_IOCTL_INFO
1651 /* Verification of what we have done... */
1653 printk(KERN_DEBUG
"Wavelan EEprom Area 1 :");
1654 for(i
= 0; i
< 16; i
++)
1661 printk(KERN_DEBUG
"Wavelan EEprom DAC : %04X %04X\n",
1662 dac_verify
[0], dac_verify
[1]);
1668 return -EINVAL
; /* Bah, never get there... */
1671 /*------------------------------------------------------------------*/
1673 * Give the list of available frequencies
1676 wv_frequency_list(u_long base
, /* i/o port of the card */
1677 iw_freq
* list
, /* List of frequency to fill */
1678 int max
) /* Maximum number of frequencies */
1680 u_short table
[10]; /* Authorized frequency table */
1681 long freq
= 0L; /* offset to 2.4 GHz in .5 MHz + 12 MHz */
1682 int i
; /* index in the table */
1683 const int BAND_NUM
= 10; /* Number of bands */
1684 int c
= 0; /* Channel number */
1686 /* Read the frequency table */
1687 fee_read(base
, 0x71 /* frequency table */,
1690 /* Look all frequencies */
1692 for(freq
= 0; freq
< 150; freq
++)
1693 /* Look in the table if the frequency is allowed */
1694 if(table
[9 - (freq
/ 16)] & (1 << (freq
% 16)))
1696 /* Compute approximate channel number */
1697 while((((channel_bands
[c
] >> 1) - 24) < freq
) &&
1700 list
[i
].i
= c
; /* Set the list index */
1702 /* put in the list */
1703 list
[i
].m
= (((freq
+ 24) * 5) + 24000L) * 10000;
1714 #ifdef IW_WIRELESS_SPY
1715 /*------------------------------------------------------------------*/
1717 * Gather wireless spy statistics : for each packet, compare the source
1718 * address with out list, and if match, get the stats...
1719 * Sorry, but this function really need wireless extensions...
1722 wl_spy_gather(struct net_device
* dev
,
1723 u_char
* mac
, /* MAC address */
1724 u_char
* stats
) /* Statistics to gather */
1726 struct iw_quality wstats
;
1728 wstats
.qual
= stats
[2] & MMR_SGNL_QUAL
;
1729 wstats
.level
= stats
[0] & MMR_SIGNAL_LVL
;
1730 wstats
.noise
= stats
[1] & MMR_SILENCE_LVL
;
1731 wstats
.updated
= 0x7;
1733 /* Update spy records */
1734 wireless_spy_update(dev
, mac
, &wstats
);
1736 #endif /* IW_WIRELESS_SPY */
1739 /*------------------------------------------------------------------*/
1741 * This function calculate an histogram on the signal level.
1742 * As the noise is quite constant, it's like doing it on the SNR.
1743 * We have defined a set of interval (lp->his_range), and each time
1744 * the level goes in that interval, we increment the count (lp->his_sum).
1745 * With this histogram you may detect if one wavelan is really weak,
1746 * or you may also calculate the mean and standard deviation of the level...
1749 wl_his_gather(struct net_device
* dev
,
1750 u_char
* stats
) /* Statistics to gather */
1752 net_local
* lp
= netdev_priv(dev
);
1753 u_char level
= stats
[0] & MMR_SIGNAL_LVL
;
1756 /* Find the correct interval */
1758 while((i
< (lp
->his_number
- 1)) && (level
>= lp
->his_range
[i
++]))
1761 /* Increment interval counter */
1764 #endif /* HISTOGRAM */
1766 static void wl_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
1768 strncpy(info
->driver
, "wavelan_cs", sizeof(info
->driver
)-1);
1771 static const struct ethtool_ops ops
= {
1772 .get_drvinfo
= wl_get_drvinfo
1775 /*------------------------------------------------------------------*/
1777 * Wireless Handler : get protocol name
1779 static int wavelan_get_name(struct net_device
*dev
,
1780 struct iw_request_info
*info
,
1781 union iwreq_data
*wrqu
,
1784 strcpy(wrqu
->name
, "WaveLAN");
1788 /*------------------------------------------------------------------*/
1790 * Wireless Handler : set NWID
1792 static int wavelan_set_nwid(struct net_device
*dev
,
1793 struct iw_request_info
*info
,
1794 union iwreq_data
*wrqu
,
1797 unsigned int base
= dev
->base_addr
;
1798 net_local
*lp
= netdev_priv(dev
);
1801 unsigned long flags
;
1804 /* Disable interrupts and save flags. */
1805 spin_lock_irqsave(&lp
->spinlock
, flags
);
1807 /* Set NWID in WaveLAN. */
1808 if (!wrqu
->nwid
.disabled
) {
1809 /* Set NWID in psa */
1810 psa
.psa_nwid
[0] = (wrqu
->nwid
.value
& 0xFF00) >> 8;
1811 psa
.psa_nwid
[1] = wrqu
->nwid
.value
& 0xFF;
1812 psa
.psa_nwid_select
= 0x01;
1814 (char *) psa
.psa_nwid
- (char *) &psa
,
1815 (unsigned char *) psa
.psa_nwid
, 3);
1817 /* Set NWID in mmc. */
1818 m
.w
.mmw_netw_id_l
= psa
.psa_nwid
[1];
1819 m
.w
.mmw_netw_id_h
= psa
.psa_nwid
[0];
1821 (char *) &m
.w
.mmw_netw_id_l
-
1823 (unsigned char *) &m
.w
.mmw_netw_id_l
, 2);
1824 mmc_out(base
, mmwoff(0, mmw_loopt_sel
), 0x00);
1826 /* Disable NWID in the psa. */
1827 psa
.psa_nwid_select
= 0x00;
1829 (char *) &psa
.psa_nwid_select
-
1831 (unsigned char *) &psa
.psa_nwid_select
,
1834 /* Disable NWID in the mmc (no filtering). */
1835 mmc_out(base
, mmwoff(0, mmw_loopt_sel
),
1836 MMW_LOOPT_SEL_DIS_NWID
);
1838 /* update the Wavelan checksum */
1839 update_psa_checksum(dev
);
1841 /* Enable interrupts and restore flags. */
1842 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1847 /*------------------------------------------------------------------*/
1849 * Wireless Handler : get NWID
1851 static int wavelan_get_nwid(struct net_device
*dev
,
1852 struct iw_request_info
*info
,
1853 union iwreq_data
*wrqu
,
1856 net_local
*lp
= netdev_priv(dev
);
1858 unsigned long flags
;
1861 /* Disable interrupts and save flags. */
1862 spin_lock_irqsave(&lp
->spinlock
, flags
);
1864 /* Read the NWID. */
1866 (char *) psa
.psa_nwid
- (char *) &psa
,
1867 (unsigned char *) psa
.psa_nwid
, 3);
1868 wrqu
->nwid
.value
= (psa
.psa_nwid
[0] << 8) + psa
.psa_nwid
[1];
1869 wrqu
->nwid
.disabled
= !(psa
.psa_nwid_select
);
1870 wrqu
->nwid
.fixed
= 1; /* Superfluous */
1872 /* Enable interrupts and restore flags. */
1873 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1878 /*------------------------------------------------------------------*/
1880 * Wireless Handler : set frequency
1882 static int wavelan_set_freq(struct net_device
*dev
,
1883 struct iw_request_info
*info
,
1884 union iwreq_data
*wrqu
,
1887 unsigned int base
= dev
->base_addr
;
1888 net_local
*lp
= netdev_priv(dev
);
1889 unsigned long flags
;
1892 /* Disable interrupts and save flags. */
1893 spin_lock_irqsave(&lp
->spinlock
, flags
);
1895 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
1896 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
1897 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
)))
1898 ret
= wv_set_frequency(base
, &(wrqu
->freq
));
1902 /* Enable interrupts and restore flags. */
1903 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1908 /*------------------------------------------------------------------*/
1910 * Wireless Handler : get frequency
1912 static int wavelan_get_freq(struct net_device
*dev
,
1913 struct iw_request_info
*info
,
1914 union iwreq_data
*wrqu
,
1917 unsigned int base
= dev
->base_addr
;
1918 net_local
*lp
= netdev_priv(dev
);
1920 unsigned long flags
;
1923 /* Disable interrupts and save flags. */
1924 spin_lock_irqsave(&lp
->spinlock
, flags
);
1926 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable).
1927 * Does it work for everybody, especially old cards? */
1928 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
1929 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
))) {
1930 unsigned short freq
;
1932 /* Ask the EEPROM to read the frequency from the first area. */
1933 fee_read(base
, 0x00, &freq
, 1);
1934 wrqu
->freq
.m
= ((freq
>> 5) * 5 + 24000L) * 10000;
1938 (char *) &psa
.psa_subband
- (char *) &psa
,
1939 (unsigned char *) &psa
.psa_subband
, 1);
1941 if (psa
.psa_subband
<= 4) {
1942 wrqu
->freq
.m
= fixed_bands
[psa
.psa_subband
];
1943 wrqu
->freq
.e
= (psa
.psa_subband
!= 0);
1948 /* Enable interrupts and restore flags. */
1949 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1954 /*------------------------------------------------------------------*/
1956 * Wireless Handler : set level threshold
1958 static int wavelan_set_sens(struct net_device
*dev
,
1959 struct iw_request_info
*info
,
1960 union iwreq_data
*wrqu
,
1963 unsigned int base
= dev
->base_addr
;
1964 net_local
*lp
= netdev_priv(dev
);
1966 unsigned long flags
;
1969 /* Disable interrupts and save flags. */
1970 spin_lock_irqsave(&lp
->spinlock
, flags
);
1972 /* Set the level threshold. */
1973 /* We should complain loudly if wrqu->sens.fixed = 0, because we
1974 * can't set auto mode... */
1975 psa
.psa_thr_pre_set
= wrqu
->sens
.value
& 0x3F;
1977 (char *) &psa
.psa_thr_pre_set
- (char *) &psa
,
1978 (unsigned char *) &psa
.psa_thr_pre_set
, 1);
1979 /* update the Wavelan checksum */
1980 update_psa_checksum(dev
);
1981 mmc_out(base
, mmwoff(0, mmw_thr_pre_set
),
1982 psa
.psa_thr_pre_set
);
1984 /* Enable interrupts and restore flags. */
1985 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1990 /*------------------------------------------------------------------*/
1992 * Wireless Handler : get level threshold
1994 static int wavelan_get_sens(struct net_device
*dev
,
1995 struct iw_request_info
*info
,
1996 union iwreq_data
*wrqu
,
1999 net_local
*lp
= netdev_priv(dev
);
2001 unsigned long flags
;
2004 /* Disable interrupts and save flags. */
2005 spin_lock_irqsave(&lp
->spinlock
, flags
);
2007 /* Read the level threshold. */
2009 (char *) &psa
.psa_thr_pre_set
- (char *) &psa
,
2010 (unsigned char *) &psa
.psa_thr_pre_set
, 1);
2011 wrqu
->sens
.value
= psa
.psa_thr_pre_set
& 0x3F;
2012 wrqu
->sens
.fixed
= 1;
2014 /* Enable interrupts and restore flags. */
2015 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2020 /*------------------------------------------------------------------*/
2022 * Wireless Handler : set encryption key
2024 static int wavelan_set_encode(struct net_device
*dev
,
2025 struct iw_request_info
*info
,
2026 union iwreq_data
*wrqu
,
2029 unsigned int base
= dev
->base_addr
;
2030 net_local
*lp
= netdev_priv(dev
);
2031 unsigned long flags
;
2035 /* Disable interrupts and save flags. */
2036 spin_lock_irqsave(&lp
->spinlock
, flags
);
2038 /* Check if capable of encryption */
2039 if (!mmc_encr(base
)) {
2043 /* Check the size of the key */
2044 if((wrqu
->encoding
.length
!= 8) && (wrqu
->encoding
.length
!= 0)) {
2049 /* Basic checking... */
2050 if (wrqu
->encoding
.length
== 8) {
2051 /* Copy the key in the driver */
2052 memcpy(psa
.psa_encryption_key
, extra
,
2053 wrqu
->encoding
.length
);
2054 psa
.psa_encryption_select
= 1;
2057 (char *) &psa
.psa_encryption_select
-
2059 (unsigned char *) &psa
.
2060 psa_encryption_select
, 8 + 1);
2062 mmc_out(base
, mmwoff(0, mmw_encr_enable
),
2063 MMW_ENCR_ENABLE_EN
| MMW_ENCR_ENABLE_MODE
);
2064 mmc_write(base
, mmwoff(0, mmw_encr_key
),
2065 (unsigned char *) &psa
.
2066 psa_encryption_key
, 8);
2069 /* disable encryption */
2070 if (wrqu
->encoding
.flags
& IW_ENCODE_DISABLED
) {
2071 psa
.psa_encryption_select
= 0;
2073 (char *) &psa
.psa_encryption_select
-
2075 (unsigned char *) &psa
.
2076 psa_encryption_select
, 1);
2078 mmc_out(base
, mmwoff(0, mmw_encr_enable
), 0);
2080 /* update the Wavelan checksum */
2081 update_psa_checksum(dev
);
2084 /* Enable interrupts and restore flags. */
2085 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2090 /*------------------------------------------------------------------*/
2092 * Wireless Handler : get encryption key
2094 static int wavelan_get_encode(struct net_device
*dev
,
2095 struct iw_request_info
*info
,
2096 union iwreq_data
*wrqu
,
2099 unsigned int base
= dev
->base_addr
;
2100 net_local
*lp
= netdev_priv(dev
);
2102 unsigned long flags
;
2105 /* Disable interrupts and save flags. */
2106 spin_lock_irqsave(&lp
->spinlock
, flags
);
2108 /* Check if encryption is available */
2109 if (!mmc_encr(base
)) {
2112 /* Read the encryption key */
2114 (char *) &psa
.psa_encryption_select
-
2116 (unsigned char *) &psa
.
2117 psa_encryption_select
, 1 + 8);
2119 /* encryption is enabled ? */
2120 if (psa
.psa_encryption_select
)
2121 wrqu
->encoding
.flags
= IW_ENCODE_ENABLED
;
2123 wrqu
->encoding
.flags
= IW_ENCODE_DISABLED
;
2124 wrqu
->encoding
.flags
|= mmc_encr(base
);
2126 /* Copy the key to the user buffer */
2127 wrqu
->encoding
.length
= 8;
2128 memcpy(extra
, psa
.psa_encryption_key
, wrqu
->encoding
.length
);
2131 /* Enable interrupts and restore flags. */
2132 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2137 #ifdef WAVELAN_ROAMING_EXT
2138 /*------------------------------------------------------------------*/
2140 * Wireless Handler : set ESSID (domain)
2142 static int wavelan_set_essid(struct net_device
*dev
,
2143 struct iw_request_info
*info
,
2144 union iwreq_data
*wrqu
,
2147 net_local
*lp
= netdev_priv(dev
);
2148 unsigned long flags
;
2151 /* Disable interrupts and save flags. */
2152 spin_lock_irqsave(&lp
->spinlock
, flags
);
2154 /* Check if disable */
2155 if(wrqu
->data
.flags
== 0)
2156 lp
->filter_domains
= 0;
2158 char essid
[IW_ESSID_MAX_SIZE
+ 1];
2161 /* Terminate the string */
2162 memcpy(essid
, extra
, wrqu
->data
.length
);
2163 essid
[IW_ESSID_MAX_SIZE
] = '\0';
2165 #ifdef DEBUG_IOCTL_INFO
2166 printk(KERN_DEBUG
"SetEssid : ``%s''\n", essid
);
2167 #endif /* DEBUG_IOCTL_INFO */
2169 /* Convert to a number (note : Wavelan specific) */
2170 lp
->domain_id
= simple_strtoul(essid
, &endp
, 16);
2171 /* Has it worked ? */
2173 lp
->filter_domains
= 1;
2175 lp
->filter_domains
= 0;
2180 /* Enable interrupts and restore flags. */
2181 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2186 /*------------------------------------------------------------------*/
2188 * Wireless Handler : get ESSID (domain)
2190 static int wavelan_get_essid(struct net_device
*dev
,
2191 struct iw_request_info
*info
,
2192 union iwreq_data
*wrqu
,
2195 net_local
*lp
= netdev_priv(dev
);
2197 /* Is the domain ID active ? */
2198 wrqu
->data
.flags
= lp
->filter_domains
;
2200 /* Copy Domain ID into a string (Wavelan specific) */
2201 /* Sound crazy, be we can't have a snprintf in the kernel !!! */
2202 sprintf(extra
, "%lX", lp
->domain_id
);
2203 extra
[IW_ESSID_MAX_SIZE
] = '\0';
2205 /* Set the length */
2206 wrqu
->data
.length
= strlen(extra
);
2211 /*------------------------------------------------------------------*/
2213 * Wireless Handler : set AP address
2215 static int wavelan_set_wap(struct net_device
*dev
,
2216 struct iw_request_info
*info
,
2217 union iwreq_data
*wrqu
,
2220 #ifdef DEBUG_IOCTL_INFO
2221 printk(KERN_DEBUG
"Set AP to : %pM\n", wrqu
->ap_addr
.sa_data
);
2222 #endif /* DEBUG_IOCTL_INFO */
2227 /*------------------------------------------------------------------*/
2229 * Wireless Handler : get AP address
2231 static int wavelan_get_wap(struct net_device
*dev
,
2232 struct iw_request_info
*info
,
2233 union iwreq_data
*wrqu
,
2236 /* Should get the real McCoy instead of own Ethernet address */
2237 memcpy(wrqu
->ap_addr
.sa_data
, dev
->dev_addr
, WAVELAN_ADDR_SIZE
);
2238 wrqu
->ap_addr
.sa_family
= ARPHRD_ETHER
;
2242 #endif /* WAVELAN_ROAMING_EXT */
2244 #ifdef WAVELAN_ROAMING
2245 /*------------------------------------------------------------------*/
2247 * Wireless Handler : set mode
2249 static int wavelan_set_mode(struct net_device
*dev
,
2250 struct iw_request_info
*info
,
2251 union iwreq_data
*wrqu
,
2254 net_local
*lp
= netdev_priv(dev
);
2255 unsigned long flags
;
2258 /* Disable interrupts and save flags. */
2259 spin_lock_irqsave(&lp
->spinlock
, flags
);
2262 switch(wrqu
->mode
) {
2265 wv_roam_cleanup(dev
);
2279 /* Enable interrupts and restore flags. */
2280 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2285 /*------------------------------------------------------------------*/
2287 * Wireless Handler : get mode
2289 static int wavelan_get_mode(struct net_device
*dev
,
2290 struct iw_request_info
*info
,
2291 union iwreq_data
*wrqu
,
2295 wrqu
->mode
= IW_MODE_INFRA
;
2297 wrqu
->mode
= IW_MODE_ADHOC
;
2301 #endif /* WAVELAN_ROAMING */
2303 /*------------------------------------------------------------------*/
2305 * Wireless Handler : get range info
2307 static int wavelan_get_range(struct net_device
*dev
,
2308 struct iw_request_info
*info
,
2309 union iwreq_data
*wrqu
,
2312 unsigned int base
= dev
->base_addr
;
2313 net_local
*lp
= netdev_priv(dev
);
2314 struct iw_range
*range
= (struct iw_range
*) extra
;
2315 unsigned long flags
;
2318 /* Set the length (very important for backward compatibility) */
2319 wrqu
->data
.length
= sizeof(struct iw_range
);
2321 /* Set all the info we don't care or don't know about to zero */
2322 memset(range
, 0, sizeof(struct iw_range
));
2324 /* Set the Wireless Extension versions */
2325 range
->we_version_compiled
= WIRELESS_EXT
;
2326 range
->we_version_source
= 9;
2328 /* Set information in the range struct. */
2329 range
->throughput
= 1.4 * 1000 * 1000; /* don't argue on this ! */
2330 range
->min_nwid
= 0x0000;
2331 range
->max_nwid
= 0xFFFF;
2333 range
->sensitivity
= 0x3F;
2334 range
->max_qual
.qual
= MMR_SGNL_QUAL
;
2335 range
->max_qual
.level
= MMR_SIGNAL_LVL
;
2336 range
->max_qual
.noise
= MMR_SILENCE_LVL
;
2337 range
->avg_qual
.qual
= MMR_SGNL_QUAL
; /* Always max */
2338 /* Need to get better values for those two */
2339 range
->avg_qual
.level
= 30;
2340 range
->avg_qual
.noise
= 8;
2342 range
->num_bitrates
= 1;
2343 range
->bitrate
[0] = 2000000; /* 2 Mb/s */
2345 /* Event capability (kernel + driver) */
2346 range
->event_capa
[0] = (IW_EVENT_CAPA_MASK(0x8B02) |
2347 IW_EVENT_CAPA_MASK(0x8B04) |
2348 IW_EVENT_CAPA_MASK(0x8B06));
2349 range
->event_capa
[1] = IW_EVENT_CAPA_K_1
;
2351 /* Disable interrupts and save flags. */
2352 spin_lock_irqsave(&lp
->spinlock
, flags
);
2354 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
2355 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
2356 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
))) {
2357 range
->num_channels
= 10;
2358 range
->num_frequency
= wv_frequency_list(base
, range
->freq
,
2359 IW_MAX_FREQUENCIES
);
2361 range
->num_channels
= range
->num_frequency
= 0;
2363 /* Encryption supported ? */
2364 if (mmc_encr(base
)) {
2365 range
->encoding_size
[0] = 8; /* DES = 64 bits key */
2366 range
->num_encoding_sizes
= 1;
2367 range
->max_encoding_tokens
= 1; /* Only one key possible */
2369 range
->num_encoding_sizes
= 0;
2370 range
->max_encoding_tokens
= 0;
2373 /* Enable interrupts and restore flags. */
2374 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2379 /*------------------------------------------------------------------*/
2381 * Wireless Private Handler : set quality threshold
2383 static int wavelan_set_qthr(struct net_device
*dev
,
2384 struct iw_request_info
*info
,
2385 union iwreq_data
*wrqu
,
2388 unsigned int base
= dev
->base_addr
;
2389 net_local
*lp
= netdev_priv(dev
);
2391 unsigned long flags
;
2393 /* Disable interrupts and save flags. */
2394 spin_lock_irqsave(&lp
->spinlock
, flags
);
2396 psa
.psa_quality_thr
= *(extra
) & 0x0F;
2398 (char *) &psa
.psa_quality_thr
- (char *) &psa
,
2399 (unsigned char *) &psa
.psa_quality_thr
, 1);
2400 /* update the Wavelan checksum */
2401 update_psa_checksum(dev
);
2402 mmc_out(base
, mmwoff(0, mmw_quality_thr
),
2403 psa
.psa_quality_thr
);
2405 /* Enable interrupts and restore flags. */
2406 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2411 /*------------------------------------------------------------------*/
2413 * Wireless Private Handler : get quality threshold
2415 static int wavelan_get_qthr(struct net_device
*dev
,
2416 struct iw_request_info
*info
,
2417 union iwreq_data
*wrqu
,
2420 net_local
*lp
= netdev_priv(dev
);
2422 unsigned long flags
;
2424 /* Disable interrupts and save flags. */
2425 spin_lock_irqsave(&lp
->spinlock
, flags
);
2428 (char *) &psa
.psa_quality_thr
- (char *) &psa
,
2429 (unsigned char *) &psa
.psa_quality_thr
, 1);
2430 *(extra
) = psa
.psa_quality_thr
& 0x0F;
2432 /* Enable interrupts and restore flags. */
2433 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2438 #ifdef WAVELAN_ROAMING
2439 /*------------------------------------------------------------------*/
2441 * Wireless Private Handler : set roaming
2443 static int wavelan_set_roam(struct net_device
*dev
,
2444 struct iw_request_info
*info
,
2445 union iwreq_data
*wrqu
,
2448 net_local
*lp
= netdev_priv(dev
);
2449 unsigned long flags
;
2451 /* Disable interrupts and save flags. */
2452 spin_lock_irqsave(&lp
->spinlock
, flags
);
2454 /* Note : should check if user == root */
2455 if(do_roaming
&& (*extra
)==0)
2456 wv_roam_cleanup(dev
);
2457 else if(do_roaming
==0 && (*extra
)!=0)
2460 do_roaming
= (*extra
);
2462 /* Enable interrupts and restore flags. */
2463 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2468 /*------------------------------------------------------------------*/
2470 * Wireless Private Handler : get quality threshold
2472 static int wavelan_get_roam(struct net_device
*dev
,
2473 struct iw_request_info
*info
,
2474 union iwreq_data
*wrqu
,
2477 *(extra
) = do_roaming
;
2481 #endif /* WAVELAN_ROAMING */
2484 /*------------------------------------------------------------------*/
2486 * Wireless Private Handler : set histogram
2488 static int wavelan_set_histo(struct net_device
*dev
,
2489 struct iw_request_info
*info
,
2490 union iwreq_data
*wrqu
,
2493 net_local
*lp
= netdev_priv(dev
);
2495 /* Check the number of intervals. */
2496 if (wrqu
->data
.length
> 16) {
2500 /* Disable histo while we copy the addresses.
2501 * As we don't disable interrupts, we need to do this */
2504 /* Are there ranges to copy? */
2505 if (wrqu
->data
.length
> 0) {
2506 /* Copy interval ranges to the driver */
2507 memcpy(lp
->his_range
, extra
, wrqu
->data
.length
);
2511 printk(KERN_DEBUG
"Histo :");
2512 for(i
= 0; i
< wrqu
->data
.length
; i
++)
2513 printk(" %d", lp
->his_range
[i
]);
2517 /* Reset result structure. */
2518 memset(lp
->his_sum
, 0x00, sizeof(long) * 16);
2521 /* Now we can set the number of ranges */
2522 lp
->his_number
= wrqu
->data
.length
;
2527 /*------------------------------------------------------------------*/
2529 * Wireless Private Handler : get histogram
2531 static int wavelan_get_histo(struct net_device
*dev
,
2532 struct iw_request_info
*info
,
2533 union iwreq_data
*wrqu
,
2536 net_local
*lp
= netdev_priv(dev
);
2538 /* Set the number of intervals. */
2539 wrqu
->data
.length
= lp
->his_number
;
2541 /* Give back the distribution statistics */
2542 if(lp
->his_number
> 0)
2543 memcpy(extra
, lp
->his_sum
, sizeof(long) * lp
->his_number
);
2547 #endif /* HISTOGRAM */
2549 /*------------------------------------------------------------------*/
2551 * Structures to export the Wireless Handlers
2554 static const struct iw_priv_args wavelan_private_args
[] = {
2555 /*{ cmd, set_args, get_args, name } */
2556 { SIOCSIPQTHR
, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, 0, "setqualthr" },
2557 { SIOCGIPQTHR
, 0, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, "getqualthr" },
2558 { SIOCSIPROAM
, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, 0, "setroam" },
2559 { SIOCGIPROAM
, 0, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, "getroam" },
2560 { SIOCSIPHISTO
, IW_PRIV_TYPE_BYTE
| 16, 0, "sethisto" },
2561 { SIOCGIPHISTO
, 0, IW_PRIV_TYPE_INT
| 16, "gethisto" },
2564 static const iw_handler wavelan_handler
[] =
2566 NULL
, /* SIOCSIWNAME */
2567 wavelan_get_name
, /* SIOCGIWNAME */
2568 wavelan_set_nwid
, /* SIOCSIWNWID */
2569 wavelan_get_nwid
, /* SIOCGIWNWID */
2570 wavelan_set_freq
, /* SIOCSIWFREQ */
2571 wavelan_get_freq
, /* SIOCGIWFREQ */
2572 #ifdef WAVELAN_ROAMING
2573 wavelan_set_mode
, /* SIOCSIWMODE */
2574 wavelan_get_mode
, /* SIOCGIWMODE */
2575 #else /* WAVELAN_ROAMING */
2576 NULL
, /* SIOCSIWMODE */
2577 NULL
, /* SIOCGIWMODE */
2578 #endif /* WAVELAN_ROAMING */
2579 wavelan_set_sens
, /* SIOCSIWSENS */
2580 wavelan_get_sens
, /* SIOCGIWSENS */
2581 NULL
, /* SIOCSIWRANGE */
2582 wavelan_get_range
, /* SIOCGIWRANGE */
2583 NULL
, /* SIOCSIWPRIV */
2584 NULL
, /* SIOCGIWPRIV */
2585 NULL
, /* SIOCSIWSTATS */
2586 NULL
, /* SIOCGIWSTATS */
2587 iw_handler_set_spy
, /* SIOCSIWSPY */
2588 iw_handler_get_spy
, /* SIOCGIWSPY */
2589 iw_handler_set_thrspy
, /* SIOCSIWTHRSPY */
2590 iw_handler_get_thrspy
, /* SIOCGIWTHRSPY */
2591 #ifdef WAVELAN_ROAMING_EXT
2592 wavelan_set_wap
, /* SIOCSIWAP */
2593 wavelan_get_wap
, /* SIOCGIWAP */
2594 NULL
, /* -- hole -- */
2595 NULL
, /* SIOCGIWAPLIST */
2596 NULL
, /* -- hole -- */
2597 NULL
, /* -- hole -- */
2598 wavelan_set_essid
, /* SIOCSIWESSID */
2599 wavelan_get_essid
, /* SIOCGIWESSID */
2600 #else /* WAVELAN_ROAMING_EXT */
2601 NULL
, /* SIOCSIWAP */
2602 NULL
, /* SIOCGIWAP */
2603 NULL
, /* -- hole -- */
2604 NULL
, /* SIOCGIWAPLIST */
2605 NULL
, /* -- hole -- */
2606 NULL
, /* -- hole -- */
2607 NULL
, /* SIOCSIWESSID */
2608 NULL
, /* SIOCGIWESSID */
2609 #endif /* WAVELAN_ROAMING_EXT */
2610 NULL
, /* SIOCSIWNICKN */
2611 NULL
, /* SIOCGIWNICKN */
2612 NULL
, /* -- hole -- */
2613 NULL
, /* -- hole -- */
2614 NULL
, /* SIOCSIWRATE */
2615 NULL
, /* SIOCGIWRATE */
2616 NULL
, /* SIOCSIWRTS */
2617 NULL
, /* SIOCGIWRTS */
2618 NULL
, /* SIOCSIWFRAG */
2619 NULL
, /* SIOCGIWFRAG */
2620 NULL
, /* SIOCSIWTXPOW */
2621 NULL
, /* SIOCGIWTXPOW */
2622 NULL
, /* SIOCSIWRETRY */
2623 NULL
, /* SIOCGIWRETRY */
2624 wavelan_set_encode
, /* SIOCSIWENCODE */
2625 wavelan_get_encode
, /* SIOCGIWENCODE */
2628 static const iw_handler wavelan_private_handler
[] =
2630 wavelan_set_qthr
, /* SIOCIWFIRSTPRIV */
2631 wavelan_get_qthr
, /* SIOCIWFIRSTPRIV + 1 */
2632 #ifdef WAVELAN_ROAMING
2633 wavelan_set_roam
, /* SIOCIWFIRSTPRIV + 2 */
2634 wavelan_get_roam
, /* SIOCIWFIRSTPRIV + 3 */
2635 #else /* WAVELAN_ROAMING */
2636 NULL
, /* SIOCIWFIRSTPRIV + 2 */
2637 NULL
, /* SIOCIWFIRSTPRIV + 3 */
2638 #endif /* WAVELAN_ROAMING */
2640 wavelan_set_histo
, /* SIOCIWFIRSTPRIV + 4 */
2641 wavelan_get_histo
, /* SIOCIWFIRSTPRIV + 5 */
2642 #endif /* HISTOGRAM */
2645 static const struct iw_handler_def wavelan_handler_def
=
2647 .num_standard
= ARRAY_SIZE(wavelan_handler
),
2648 .num_private
= ARRAY_SIZE(wavelan_private_handler
),
2649 .num_private_args
= ARRAY_SIZE(wavelan_private_args
),
2650 .standard
= wavelan_handler
,
2651 .private = wavelan_private_handler
,
2652 .private_args
= wavelan_private_args
,
2653 .get_wireless_stats
= wavelan_get_wireless_stats
,
2656 /*------------------------------------------------------------------*/
2658 * Get wireless statistics
2659 * Called by /proc/net/wireless...
2662 wavelan_get_wireless_stats(struct net_device
* dev
)
2664 unsigned int base
= dev
->base_addr
;
2665 net_local
* lp
= netdev_priv(dev
);
2668 unsigned long flags
;
2670 #ifdef DEBUG_IOCTL_TRACE
2671 printk(KERN_DEBUG
"%s: ->wavelan_get_wireless_stats()\n", dev
->name
);
2674 /* Disable interrupts & save flags */
2675 spin_lock_irqsave(&lp
->spinlock
, flags
);
2677 wstats
= &lp
->wstats
;
2679 /* Get data from the mmc */
2680 mmc_out(base
, mmwoff(0, mmw_freeze
), 1);
2682 mmc_read(base
, mmroff(0, mmr_dce_status
), &m
.mmr_dce_status
, 1);
2683 mmc_read(base
, mmroff(0, mmr_wrong_nwid_l
), &m
.mmr_wrong_nwid_l
, 2);
2684 mmc_read(base
, mmroff(0, mmr_thr_pre_set
), &m
.mmr_thr_pre_set
, 4);
2686 mmc_out(base
, mmwoff(0, mmw_freeze
), 0);
2688 /* Copy data to wireless stuff */
2689 wstats
->status
= m
.mmr_dce_status
& MMR_DCE_STATUS
;
2690 wstats
->qual
.qual
= m
.mmr_sgnl_qual
& MMR_SGNL_QUAL
;
2691 wstats
->qual
.level
= m
.mmr_signal_lvl
& MMR_SIGNAL_LVL
;
2692 wstats
->qual
.noise
= m
.mmr_silence_lvl
& MMR_SILENCE_LVL
;
2693 wstats
->qual
.updated
= (((m
.mmr_signal_lvl
& MMR_SIGNAL_LVL_VALID
) >> 7) |
2694 ((m
.mmr_signal_lvl
& MMR_SIGNAL_LVL_VALID
) >> 6) |
2695 ((m
.mmr_silence_lvl
& MMR_SILENCE_LVL_VALID
) >> 5));
2696 wstats
->discard
.nwid
+= (m
.mmr_wrong_nwid_h
<< 8) | m
.mmr_wrong_nwid_l
;
2697 wstats
->discard
.code
= 0L;
2698 wstats
->discard
.misc
= 0L;
2700 /* ReEnable interrupts & restore flags */
2701 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2703 #ifdef DEBUG_IOCTL_TRACE
2704 printk(KERN_DEBUG
"%s: <-wavelan_get_wireless_stats()\n", dev
->name
);
2709 /************************* PACKET RECEPTION *************************/
2711 * This part deal with receiving the packets.
2712 * The interrupt handler get an interrupt when a packet has been
2713 * successfully received and called this part...
2716 /*------------------------------------------------------------------*/
2718 * Calculate the starting address of the frame pointed to by the receive
2719 * frame pointer and verify that the frame seem correct
2720 * (called by wv_packet_rcv())
2723 wv_start_of_frame(struct net_device
* dev
,
2724 int rfp
, /* end of frame */
2725 int wrap
) /* start of buffer */
2727 unsigned int base
= dev
->base_addr
;
2731 rp
= (rfp
- 5 + RX_SIZE
) % RX_SIZE
;
2732 outb(rp
& 0xff, PIORL(base
));
2733 outb(((rp
>> 8) & PIORH_MASK
), PIORH(base
));
2734 len
= inb(PIOP(base
));
2735 len
|= inb(PIOP(base
)) << 8;
2737 /* Sanity checks on size */
2739 if(len
> MAXDATAZ
+ 100)
2741 #ifdef DEBUG_RX_ERROR
2742 printk(KERN_INFO
"%s: wv_start_of_frame: Received frame too large, rfp %d len 0x%x\n",
2743 dev
->name
, rfp
, len
);
2748 /* Frame too short */
2751 #ifdef DEBUG_RX_ERROR
2752 printk(KERN_INFO
"%s: wv_start_of_frame: Received null frame, rfp %d len 0x%x\n",
2753 dev
->name
, rfp
, len
);
2758 /* Wrap around buffer */
2759 if(len
> ((wrap
- (rfp
- len
) + RX_SIZE
) % RX_SIZE
)) /* magic formula ! */
2761 #ifdef DEBUG_RX_ERROR
2762 printk(KERN_INFO
"%s: wv_start_of_frame: wrap around buffer, wrap %d rfp %d len 0x%x\n",
2763 dev
->name
, wrap
, rfp
, len
);
2768 return((rp
- len
+ RX_SIZE
) % RX_SIZE
);
2769 } /* wv_start_of_frame */
2771 /*------------------------------------------------------------------*/
2773 * This routine does the actual copy of data (including the ethernet
2774 * header structure) from the WaveLAN card to an sk_buff chain that
2775 * will be passed up to the network interface layer. NOTE: We
2776 * currently don't handle trailer protocols (neither does the rest of
2777 * the network interface), so if that is needed, it will (at least in
2778 * part) be added here. The contents of the receive ring buffer are
2779 * copied to a message chain that is then passed to the kernel.
2781 * Note: if any errors occur, the packet is "dropped on the floor"
2782 * (called by wv_packet_rcv())
2785 wv_packet_read(struct net_device
* dev
,
2789 net_local
* lp
= netdev_priv(dev
);
2790 struct sk_buff
* skb
;
2792 #ifdef DEBUG_RX_TRACE
2793 printk(KERN_DEBUG
"%s: ->wv_packet_read(0x%X, %d)\n",
2794 dev
->name
, fd_p
, sksize
);
2797 /* Allocate some buffer for the new packet */
2798 if((skb
= dev_alloc_skb(sksize
+2)) == (struct sk_buff
*) NULL
)
2800 #ifdef DEBUG_RX_ERROR
2801 printk(KERN_INFO
"%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC)\n",
2804 dev
->stats
.rx_dropped
++;
2806 * Not only do we want to return here, but we also need to drop the
2807 * packet on the floor to clear the interrupt.
2812 skb_reserve(skb
, 2);
2813 fd_p
= read_ringbuf(dev
, fd_p
, (char *) skb_put(skb
, sksize
), sksize
);
2814 skb
->protocol
= eth_type_trans(skb
, dev
);
2816 #ifdef DEBUG_RX_INFO
2817 wv_packet_info(skb_mac_header(skb
), sksize
, dev
->name
, "wv_packet_read");
2818 #endif /* DEBUG_RX_INFO */
2820 /* Statistics gathering & stuff associated.
2821 * It seem a bit messy with all the define, but it's really simple... */
2823 #ifdef IW_WIRELESS_SPY
2824 (lp
->spy_data
.spy_number
> 0) ||
2825 #endif /* IW_WIRELESS_SPY */
2827 (lp
->his_number
> 0) ||
2828 #endif /* HISTOGRAM */
2829 #ifdef WAVELAN_ROAMING
2831 #endif /* WAVELAN_ROAMING */
2834 u_char stats
[3]; /* Signal level, Noise level, Signal quality */
2836 /* read signal level, silence level and signal quality bytes */
2837 fd_p
= read_ringbuf(dev
, (fd_p
+ 4) % RX_SIZE
+ RX_BASE
,
2839 #ifdef DEBUG_RX_INFO
2840 printk(KERN_DEBUG
"%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
2841 dev
->name
, stats
[0] & 0x3F, stats
[1] & 0x3F, stats
[2] & 0x0F);
2844 #ifdef WAVELAN_ROAMING
2846 if(WAVELAN_BEACON(skb
->data
))
2847 wl_roam_gather(dev
, skb
->data
, stats
);
2848 #endif /* WAVELAN_ROAMING */
2851 wl_spy_gather(dev
, skb_mac_header(skb
) + WAVELAN_ADDR_SIZE
, stats
);
2852 #endif /* WIRELESS_SPY */
2854 wl_his_gather(dev
, stats
);
2855 #endif /* HISTOGRAM */
2859 * Hand the packet to the Network Module
2863 /* Keep stats up to date */
2864 dev
->stats
.rx_packets
++;
2865 dev
->stats
.rx_bytes
+= sksize
;
2867 #ifdef DEBUG_RX_TRACE
2868 printk(KERN_DEBUG
"%s: <-wv_packet_read()\n", dev
->name
);
2873 /*------------------------------------------------------------------*/
2875 * This routine is called by the interrupt handler to initiate a
2876 * packet transfer from the card to the network interface layer above
2877 * this driver. This routine checks if a buffer has been successfully
2878 * received by the WaveLAN card. If so, the routine wv_packet_read is
2879 * called to do the actual transfer of the card's data including the
2880 * ethernet header into a packet consisting of an sk_buff chain.
2881 * (called by wavelan_interrupt())
2882 * Note : the spinlock is already grabbed for us and irq are disabled.
2885 wv_packet_rcv(struct net_device
* dev
)
2887 unsigned int base
= dev
->base_addr
;
2888 net_local
* lp
= netdev_priv(dev
);
2898 #ifdef DEBUG_RX_TRACE
2899 printk(KERN_DEBUG
"%s: ->wv_packet_rcv()\n", dev
->name
);
2902 /* Get the new receive frame pointer from the i82593 chip */
2903 outb(CR0_STATUS_2
| OP0_NOP
, LCCR(base
));
2904 i593_rfp
= inb(LCSR(base
));
2905 i593_rfp
|= inb(LCSR(base
)) << 8;
2906 i593_rfp
%= RX_SIZE
;
2908 /* Get the new receive frame pointer from the WaveLAN card.
2909 * It is 3 bytes more than the increment of the i82593 receive
2910 * frame pointer, for each packet. This is because it includes the
2911 * 3 roaming bytes added by the mmc.
2913 newrfp
= inb(RPLL(base
));
2914 newrfp
|= inb(RPLH(base
)) << 8;
2917 #ifdef DEBUG_RX_INFO
2918 printk(KERN_DEBUG
"%s: wv_packet_rcv(): i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2919 dev
->name
, i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2922 #ifdef DEBUG_RX_ERROR
2923 /* If no new frame pointer... */
2924 if(lp
->overrunning
|| newrfp
== lp
->rfp
)
2925 printk(KERN_INFO
"%s: wv_packet_rcv(): no new frame: i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2926 dev
->name
, i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2929 /* Read all frames (packets) received */
2930 while(newrfp
!= lp
->rfp
)
2932 /* A frame is composed of the packet, followed by a status word,
2933 * the length of the frame (word) and the mmc info (SNR & qual).
2934 * It's because the length is at the end that we can only scan
2935 * frames backward. */
2937 /* Find the first frame by skipping backwards over the frames */
2938 rp
= newrfp
; /* End of last frame */
2939 while(((f_start
= wv_start_of_frame(dev
, rp
, newrfp
)) != lp
->rfp
) &&
2943 /* If we had a problem */
2946 #ifdef DEBUG_RX_ERROR
2947 printk(KERN_INFO
"wavelan_cs: cannot find start of frame ");
2948 printk(" i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2949 i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2951 lp
->rfp
= rp
; /* Get to the last usable frame */
2955 /* f_start point to the beggining of the first frame received
2956 * and rp to the beggining of the next one */
2958 /* Read status & length of the frame */
2959 stat_ptr
= (rp
- 7 + RX_SIZE
) % RX_SIZE
;
2960 stat_ptr
= read_ringbuf(dev
, stat_ptr
, c
, 4);
2961 status
= c
[0] | (c
[1] << 8);
2962 len
= c
[2] | (c
[3] << 8);
2965 if((status
& RX_RCV_OK
) != RX_RCV_OK
)
2967 dev
->stats
.rx_errors
++;
2968 if(status
& RX_NO_SFD
)
2969 dev
->stats
.rx_frame_errors
++;
2970 if(status
& RX_CRC_ERR
)
2971 dev
->stats
.rx_crc_errors
++;
2972 if(status
& RX_OVRRUN
)
2973 dev
->stats
.rx_over_errors
++;
2975 #ifdef DEBUG_RX_FAIL
2976 printk(KERN_DEBUG
"%s: wv_packet_rcv(): packet not received ok, status = 0x%x\n",
2981 /* Read the packet and transmit to Linux */
2982 wv_packet_read(dev
, f_start
, len
- 2);
2984 /* One frame has been processed, skip it */
2989 * Update the frame stop register, but set it to less than
2990 * the full 8K to allow space for 3 bytes of signal strength
2993 lp
->stop
= (i593_rfp
+ RX_SIZE
- ((RX_SIZE
/ 64) * 3)) % RX_SIZE
;
2994 outb(OP0_SWIT_TO_PORT_1
| CR0_CHNL
, LCCR(base
));
2995 outb(CR1_STOP_REG_UPDATE
| (lp
->stop
>> RX_SIZE_SHIFT
), LCCR(base
));
2996 outb(OP1_SWIT_TO_PORT_0
, LCCR(base
));
2998 #ifdef DEBUG_RX_TRACE
2999 printk(KERN_DEBUG
"%s: <-wv_packet_rcv()\n", dev
->name
);
3003 /*********************** PACKET TRANSMISSION ***********************/
3005 * This part deal with sending packet through the wavelan
3006 * We copy the packet to the send buffer and then issue the send
3007 * command to the i82593. The result of this operation will be
3008 * checked in wavelan_interrupt()
3011 /*------------------------------------------------------------------*/
3013 * This routine fills in the appropriate registers and memory
3014 * locations on the WaveLAN card and starts the card off on
3016 * (called in wavelan_packet_xmit())
3019 wv_packet_write(struct net_device
* dev
,
3023 net_local
* lp
= netdev_priv(dev
);
3024 unsigned int base
= dev
->base_addr
;
3025 unsigned long flags
;
3027 register u_short xmtdata_base
= TX_BASE
;
3029 #ifdef DEBUG_TX_TRACE
3030 printk(KERN_DEBUG
"%s: ->wv_packet_write(%d)\n", dev
->name
, length
);
3033 spin_lock_irqsave(&lp
->spinlock
, flags
);
3035 /* Write the length of data buffer followed by the buffer */
3036 outb(xmtdata_base
& 0xff, PIORL(base
));
3037 outb(((xmtdata_base
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3038 outb(clen
& 0xff, PIOP(base
)); /* lsb */
3039 outb(clen
>> 8, PIOP(base
)); /* msb */
3042 outsb(PIOP(base
), buf
, clen
);
3044 /* Indicate end of transmit chain */
3045 outb(OP0_NOP
, PIOP(base
));
3046 /* josullvn@cs.cmu.edu: need to send a second NOP for alignment... */
3047 outb(OP0_NOP
, PIOP(base
));
3049 /* Reset the transmit DMA pointer */
3050 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3051 hacr_write(base
, HACR_DEFAULT
);
3052 /* Send the transmit command */
3053 wv_82593_cmd(dev
, "wv_packet_write(): transmit",
3054 OP0_TRANSMIT
, SR0_NO_RESULT
);
3056 /* Make sure the watchdog will keep quiet for a while */
3057 dev
->trans_start
= jiffies
;
3059 /* Keep stats up to date */
3060 dev
->stats
.tx_bytes
+= length
;
3062 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3064 #ifdef DEBUG_TX_INFO
3065 wv_packet_info((u_char
*) buf
, length
, dev
->name
, "wv_packet_write");
3066 #endif /* DEBUG_TX_INFO */
3068 #ifdef DEBUG_TX_TRACE
3069 printk(KERN_DEBUG
"%s: <-wv_packet_write()\n", dev
->name
);
3073 /*------------------------------------------------------------------*/
3075 * This routine is called when we want to send a packet (NET3 callback)
3076 * In this routine, we check if the harware is ready to accept
3077 * the packet. We also prevent reentrance. Then, we call the function
3078 * to send the packet...
3081 wavelan_packet_xmit(struct sk_buff
* skb
,
3082 struct net_device
* dev
)
3084 net_local
* lp
= netdev_priv(dev
);
3085 unsigned long flags
;
3087 #ifdef DEBUG_TX_TRACE
3088 printk(KERN_DEBUG
"%s: ->wavelan_packet_xmit(0x%X)\n", dev
->name
,
3093 * Block a timer-based transmit from overlapping a previous transmit.
3094 * In other words, prevent reentering this routine.
3096 netif_stop_queue(dev
);
3098 /* If somebody has asked to reconfigure the controller,
3099 * we can do it now */
3100 if(lp
->reconfig_82593
)
3102 spin_lock_irqsave(&lp
->spinlock
, flags
); /* Disable interrupts */
3103 wv_82593_config(dev
);
3104 spin_unlock_irqrestore(&lp
->spinlock
, flags
); /* Re-enable interrupts */
3105 /* Note : the configure procedure was totally synchronous,
3106 * so the Tx buffer is now free */
3109 /* Check if we need some padding */
3110 /* Note : on wireless the propagation time is in the order of 1us,
3111 * and we don't have the Ethernet specific requirement of beeing
3112 * able to detect collisions, therefore in theory we don't really
3113 * need to pad. Jean II */
3114 if (skb_padto(skb
, ETH_ZLEN
))
3115 return NETDEV_TX_OK
;
3117 wv_packet_write(dev
, skb
->data
, skb
->len
);
3121 #ifdef DEBUG_TX_TRACE
3122 printk(KERN_DEBUG
"%s: <-wavelan_packet_xmit()\n", dev
->name
);
3124 return NETDEV_TX_OK
;
3127 /********************** HARDWARE CONFIGURATION **********************/
3129 * This part do the real job of starting and configuring the hardware.
3132 /*------------------------------------------------------------------*/
3134 * Routine to initialize the Modem Management Controller.
3135 * (called by wv_hw_config())
3138 wv_mmc_init(struct net_device
* dev
)
3140 unsigned int base
= dev
->base_addr
;
3144 int i
; /* Loop counter */
3146 #ifdef DEBUG_CONFIG_TRACE
3147 printk(KERN_DEBUG
"%s: ->wv_mmc_init()\n", dev
->name
);
3150 /* Read the parameter storage area */
3151 psa_read(dev
, 0, (unsigned char *) &psa
, sizeof(psa
));
3154 * Check the first three octets of the MAC addr for the manufacturer's code.
3155 * Note: If you get the error message below, you've got a
3156 * non-NCR/AT&T/Lucent PCMCIA cards, see wavelan_cs.h for detail on
3157 * how to configure your card...
3159 for (i
= 0; i
< ARRAY_SIZE(MAC_ADDRESSES
); i
++)
3160 if ((psa
.psa_univ_mac_addr
[0] == MAC_ADDRESSES
[i
][0]) &&
3161 (psa
.psa_univ_mac_addr
[1] == MAC_ADDRESSES
[i
][1]) &&
3162 (psa
.psa_univ_mac_addr
[2] == MAC_ADDRESSES
[i
][2]))
3165 /* If we have not found it... */
3166 if (i
== ARRAY_SIZE(MAC_ADDRESSES
))
3168 #ifdef DEBUG_CONFIG_ERRORS
3169 printk(KERN_WARNING
"%s: wv_mmc_init(): Invalid MAC address: %02X:%02X:%02X:...\n",
3170 dev
->name
, psa
.psa_univ_mac_addr
[0],
3171 psa
.psa_univ_mac_addr
[1], psa
.psa_univ_mac_addr
[2]);
3176 /* Get the MAC address */
3177 memcpy(&dev
->dev_addr
[0], &psa
.psa_univ_mac_addr
[0], WAVELAN_ADDR_SIZE
);
3179 #ifdef USE_PSA_CONFIG
3180 configured
= psa
.psa_conf_status
& 1;
3185 /* Is the PSA is not configured */
3188 /* User will be able to configure NWID after (with iwconfig) */
3189 psa
.psa_nwid
[0] = 0;
3190 psa
.psa_nwid
[1] = 0;
3192 /* As NWID is not set : no NWID checking */
3193 psa
.psa_nwid_select
= 0;
3195 /* Disable encryption */
3196 psa
.psa_encryption_select
= 0;
3198 /* Set to standard values
3201 * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document)
3203 if (psa
.psa_comp_number
& 1)
3204 psa
.psa_thr_pre_set
= 0x01;
3206 psa
.psa_thr_pre_set
= 0x04;
3207 psa
.psa_quality_thr
= 0x03;
3209 /* It is configured */
3210 psa
.psa_conf_status
|= 1;
3212 #ifdef USE_PSA_CONFIG
3214 psa_write(dev
, (char *)psa
.psa_nwid
- (char *)&psa
,
3215 (unsigned char *)psa
.psa_nwid
, 4);
3216 psa_write(dev
, (char *)&psa
.psa_thr_pre_set
- (char *)&psa
,
3217 (unsigned char *)&psa
.psa_thr_pre_set
, 1);
3218 psa_write(dev
, (char *)&psa
.psa_quality_thr
- (char *)&psa
,
3219 (unsigned char *)&psa
.psa_quality_thr
, 1);
3220 psa_write(dev
, (char *)&psa
.psa_conf_status
- (char *)&psa
,
3221 (unsigned char *)&psa
.psa_conf_status
, 1);
3222 /* update the Wavelan checksum */
3223 update_psa_checksum(dev
);
3224 #endif /* USE_PSA_CONFIG */
3227 /* Zero the mmc structure */
3228 memset(&m
, 0x00, sizeof(m
));
3230 /* Copy PSA info to the mmc */
3231 m
.mmw_netw_id_l
= psa
.psa_nwid
[1];
3232 m
.mmw_netw_id_h
= psa
.psa_nwid
[0];
3234 if(psa
.psa_nwid_select
& 1)
3235 m
.mmw_loopt_sel
= 0x00;
3237 m
.mmw_loopt_sel
= MMW_LOOPT_SEL_DIS_NWID
;
3239 memcpy(&m
.mmw_encr_key
, &psa
.psa_encryption_key
,
3240 sizeof(m
.mmw_encr_key
));
3242 if(psa
.psa_encryption_select
)
3243 m
.mmw_encr_enable
= MMW_ENCR_ENABLE_EN
| MMW_ENCR_ENABLE_MODE
;
3245 m
.mmw_encr_enable
= 0;
3247 m
.mmw_thr_pre_set
= psa
.psa_thr_pre_set
& 0x3F;
3248 m
.mmw_quality_thr
= psa
.psa_quality_thr
& 0x0F;
3251 * Set default modem control parameters.
3252 * See NCR document 407-0024326 Rev. A.
3254 m
.mmw_jabber_enable
= 0x01;
3255 m
.mmw_anten_sel
= MMW_ANTEN_SEL_ALG_EN
;
3257 m
.mmw_mod_delay
= 0x04;
3258 m
.mmw_jam_time
= 0x38;
3260 m
.mmw_des_io_invert
= 0;
3262 m
.mmw_decay_prm
= 0;
3263 m
.mmw_decay_updat_prm
= 0;
3265 /* Write all info to mmc */
3266 mmc_write(base
, 0, (u_char
*)&m
, sizeof(m
));
3268 /* The following code start the modem of the 2.00 frequency
3269 * selectable cards at power on. It's not strictly needed for the
3270 * following boots...
3271 * The original patch was by Joe Finney for the PCMCIA driver, but
3272 * I've cleaned it a bit and add documentation.
3273 * Thanks to Loeke Brederveld from Lucent for the info.
3276 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
3277 * (does it work for everybody ? - especially old cards...) */
3278 /* Note : WFREQSEL verify that it is able to read from EEprom
3279 * a sensible frequency (address 0x00) + that MMR_FEE_STATUS_ID
3280 * is 0xA (Xilinx version) or 0xB (Ariadne version).
3281 * My test is more crude but do work... */
3282 if(!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
3283 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
)))
3285 /* We must download the frequency parameters to the
3286 * synthetisers (from the EEprom - area 1)
3287 * Note : as the EEprom is auto decremented, we set the end
3289 m
.mmw_fee_addr
= 0x0F;
3290 m
.mmw_fee_ctrl
= MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
;
3291 mmc_write(base
, (char *)&m
.mmw_fee_ctrl
- (char *)&m
,
3292 (unsigned char *)&m
.mmw_fee_ctrl
, 2);
3294 /* Wait until the download is finished */
3295 fee_wait(base
, 100, 100);
3297 #ifdef DEBUG_CONFIG_INFO
3298 /* The frequency was in the last word downloaded... */
3299 mmc_read(base
, (char *)&m
.mmw_fee_data_l
- (char *)&m
,
3300 (unsigned char *)&m
.mmw_fee_data_l
, 2);
3302 /* Print some info for the user */
3303 printk(KERN_DEBUG
"%s: Wavelan 2.00 recognised (frequency select) : Current frequency = %ld\n",
3305 ((m
.mmw_fee_data_h
<< 4) |
3306 (m
.mmw_fee_data_l
>> 4)) * 5 / 2 + 24000L);
3309 /* We must now download the power adjust value (gain) to
3310 * the synthetisers (from the EEprom - area 7 - DAC) */
3311 m
.mmw_fee_addr
= 0x61;
3312 m
.mmw_fee_ctrl
= MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
;
3313 mmc_write(base
, (char *)&m
.mmw_fee_ctrl
- (char *)&m
,
3314 (unsigned char *)&m
.mmw_fee_ctrl
, 2);
3316 /* Wait until the download is finished */
3317 } /* if 2.00 card */
3319 #ifdef DEBUG_CONFIG_TRACE
3320 printk(KERN_DEBUG
"%s: <-wv_mmc_init()\n", dev
->name
);
3325 /*------------------------------------------------------------------*/
3327 * Routine to gracefully turn off reception, and wait for any commands
3329 * (called in wv_ru_start() and wavelan_close() and wavelan_event())
3332 wv_ru_stop(struct net_device
* dev
)
3334 unsigned int base
= dev
->base_addr
;
3335 net_local
* lp
= netdev_priv(dev
);
3336 unsigned long flags
;
3340 #ifdef DEBUG_CONFIG_TRACE
3341 printk(KERN_DEBUG
"%s: ->wv_ru_stop()\n", dev
->name
);
3344 spin_lock_irqsave(&lp
->spinlock
, flags
);
3346 /* First, send the LAN controller a stop receive command */
3347 wv_82593_cmd(dev
, "wv_graceful_shutdown(): stop-rcv",
3348 OP0_STOP_RCV
, SR0_NO_RESULT
);
3350 /* Then, spin until the receive unit goes idle */
3355 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3356 status
= inb(LCSR(base
));
3358 while(((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_IDLE
) && (spin
-- > 0));
3360 /* Now, spin until the chip finishes executing its current command */
3364 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3365 status
= inb(LCSR(base
));
3367 while(((status
& SR3_EXEC_STATE_MASK
) != SR3_EXEC_IDLE
) && (spin
-- > 0));
3369 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3371 /* If there was a problem */
3374 #ifdef DEBUG_CONFIG_ERRORS
3375 printk(KERN_INFO
"%s: wv_ru_stop(): The chip doesn't want to stop...\n",
3381 #ifdef DEBUG_CONFIG_TRACE
3382 printk(KERN_DEBUG
"%s: <-wv_ru_stop()\n", dev
->name
);
3387 /*------------------------------------------------------------------*/
3389 * This routine starts the receive unit running. First, it checks if
3390 * the card is actually ready. Then the card is instructed to receive
3392 * (called in wv_hw_reset() & wavelan_open())
3395 wv_ru_start(struct net_device
* dev
)
3397 unsigned int base
= dev
->base_addr
;
3398 net_local
* lp
= netdev_priv(dev
);
3399 unsigned long flags
;
3401 #ifdef DEBUG_CONFIG_TRACE
3402 printk(KERN_DEBUG
"%s: ->wv_ru_start()\n", dev
->name
);
3406 * We need to start from a quiescent state. To do so, we could check
3407 * if the card is already running, but instead we just try to shut
3408 * it down. First, we disable reception (in case it was already enabled).
3410 if(!wv_ru_stop(dev
))
3413 spin_lock_irqsave(&lp
->spinlock
, flags
);
3415 /* Now we know that no command is being executed. */
3417 /* Set the receive frame pointer and stop pointer */
3419 outb(OP0_SWIT_TO_PORT_1
| CR0_CHNL
, LCCR(base
));
3421 /* Reset ring management. This sets the receive frame pointer to 1 */
3422 outb(OP1_RESET_RING_MNGMT
, LCCR(base
));
3425 /* XXX the i82593 manual page 6-4 seems to indicate that the stop register
3426 should be set as below */
3427 /* outb(CR1_STOP_REG_UPDATE|((RX_SIZE - 0x40)>> RX_SIZE_SHIFT),LCCR(base));*/
3429 /* but I set it 0 instead */
3432 /* but I set it to 3 bytes per packet less than 8K */
3433 lp
->stop
= (0 + RX_SIZE
- ((RX_SIZE
/ 64) * 3)) % RX_SIZE
;
3435 outb(CR1_STOP_REG_UPDATE
| (lp
->stop
>> RX_SIZE_SHIFT
), LCCR(base
));
3436 outb(OP1_INT_ENABLE
, LCCR(base
));
3437 outb(OP1_SWIT_TO_PORT_0
, LCCR(base
));
3439 /* Reset receive DMA pointer */
3440 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3441 hacr_write_slow(base
, HACR_DEFAULT
);
3443 /* Receive DMA on channel 1 */
3444 wv_82593_cmd(dev
, "wv_ru_start(): rcv-enable",
3445 CR0_CHNL
| OP0_RCV_ENABLE
, SR0_NO_RESULT
);
3447 #ifdef DEBUG_I82593_SHOW
3453 /* spin until the chip starts receiving */
3456 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3457 status
= inb(LCSR(base
));
3461 while(((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_ACTIVE
) &&
3462 ((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_READY
));
3463 printk(KERN_DEBUG
"rcv status is 0x%x [i:%d]\n",
3464 (status
& SR3_RCV_STATE_MASK
), i
);
3468 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3470 #ifdef DEBUG_CONFIG_TRACE
3471 printk(KERN_DEBUG
"%s: <-wv_ru_start()\n", dev
->name
);
3476 /*------------------------------------------------------------------*/
3478 * This routine does a standard config of the WaveLAN controller (i82593).
3479 * In the ISA driver, this is integrated in wavelan_hardware_reset()
3480 * (called by wv_hw_config(), wv_82593_reconfig() & wavelan_packet_xmit())
3483 wv_82593_config(struct net_device
* dev
)
3485 unsigned int base
= dev
->base_addr
;
3486 net_local
* lp
= netdev_priv(dev
);
3487 struct i82593_conf_block cfblk
;
3490 #ifdef DEBUG_CONFIG_TRACE
3491 printk(KERN_DEBUG
"%s: ->wv_82593_config()\n", dev
->name
);
3494 /* Create & fill i82593 config block
3496 * Now conform to Wavelan document WCIN085B
3498 memset(&cfblk
, 0x00, sizeof(struct i82593_conf_block
));
3499 cfblk
.d6mod
= FALSE
; /* Run in i82593 advanced mode */
3500 cfblk
.fifo_limit
= 5; /* = 56 B rx and 40 B tx fifo thresholds */
3501 cfblk
.forgnesi
= FALSE
; /* 0=82C501, 1=AMD7992B compatibility */
3503 cfblk
.throttle_enb
= FALSE
;
3504 cfblk
.contin
= TRUE
; /* enable continuous mode */
3505 cfblk
.cntrxint
= FALSE
; /* enable continuous mode receive interrupts */
3506 cfblk
.addr_len
= WAVELAN_ADDR_SIZE
;
3507 cfblk
.acloc
= TRUE
; /* Disable source addr insertion by i82593 */
3508 cfblk
.preamb_len
= 0; /* 2 bytes preamble (SFD) */
3509 cfblk
.loopback
= FALSE
;
3510 cfblk
.lin_prio
= 0; /* conform to 802.3 backoff algorithm */
3511 cfblk
.exp_prio
= 5; /* conform to 802.3 backoff algorithm */
3512 cfblk
.bof_met
= 1; /* conform to 802.3 backoff algorithm */
3513 cfblk
.ifrm_spc
= 0x20 >> 4; /* 32 bit times interframe spacing */
3514 cfblk
.slottim_low
= 0x20 >> 5; /* 32 bit times slot time */
3515 cfblk
.slottim_hi
= 0x0;
3516 cfblk
.max_retr
= 15;
3517 cfblk
.prmisc
= ((lp
->promiscuous
) ? TRUE
: FALSE
); /* Promiscuous mode */
3518 cfblk
.bc_dis
= FALSE
; /* Enable broadcast reception */
3519 cfblk
.crs_1
= TRUE
; /* Transmit without carrier sense */
3520 cfblk
.nocrc_ins
= FALSE
; /* i82593 generates CRC */
3521 cfblk
.crc_1632
= FALSE
; /* 32-bit Autodin-II CRC */
3522 cfblk
.crs_cdt
= FALSE
; /* CD not to be interpreted as CS */
3523 cfblk
.cs_filter
= 0; /* CS is recognized immediately */
3524 cfblk
.crs_src
= FALSE
; /* External carrier sense */
3525 cfblk
.cd_filter
= 0; /* CD is recognized immediately */
3526 cfblk
.min_fr_len
= ETH_ZLEN
>> 2; /* Minimum frame length 64 bytes */
3527 cfblk
.lng_typ
= FALSE
; /* Length field > 1500 = type field */
3528 cfblk
.lng_fld
= TRUE
; /* Disable 802.3 length field check */
3529 cfblk
.rxcrc_xf
= TRUE
; /* Don't transfer CRC to memory */
3530 cfblk
.artx
= TRUE
; /* Disable automatic retransmission */
3531 cfblk
.sarec
= TRUE
; /* Disable source addr trig of CD */
3532 cfblk
.tx_jabber
= TRUE
; /* Disable jabber jam sequence */
3533 cfblk
.hash_1
= FALSE
; /* Use bits 0-5 in mc address hash */
3534 cfblk
.lbpkpol
= TRUE
; /* Loopback pin active high */
3535 cfblk
.fdx
= FALSE
; /* Disable full duplex operation */
3536 cfblk
.dummy_6
= 0x3f; /* all ones */
3537 cfblk
.mult_ia
= FALSE
; /* No multiple individual addresses */
3538 cfblk
.dis_bof
= FALSE
; /* Disable the backoff algorithm ?! */
3539 cfblk
.dummy_1
= TRUE
; /* set to 1 */
3540 cfblk
.tx_ifs_retrig
= 3; /* Hmm... Disabled */
3541 #ifdef MULTICAST_ALL
3542 cfblk
.mc_all
= (lp
->allmulticast
? TRUE
: FALSE
); /* Allow all multicasts */
3544 cfblk
.mc_all
= FALSE
; /* No multicast all mode */
3546 cfblk
.rcv_mon
= 0; /* Monitor mode disabled */
3547 cfblk
.frag_acpt
= TRUE
; /* Do not accept fragments */
3548 cfblk
.tstrttrs
= FALSE
; /* No start transmission threshold */
3549 cfblk
.fretx
= TRUE
; /* FIFO automatic retransmission */
3550 cfblk
.syncrqs
= FALSE
; /* Synchronous DRQ deassertion... */
3551 cfblk
.sttlen
= TRUE
; /* 6 byte status registers */
3552 cfblk
.rx_eop
= TRUE
; /* Signal EOP on packet reception */
3553 cfblk
.tx_eop
= TRUE
; /* Signal EOP on packet transmission */
3554 cfblk
.rbuf_size
= RX_SIZE
>>11; /* Set receive buffer size */
3555 cfblk
.rcvstop
= TRUE
; /* Enable Receive Stop Register */
3557 #ifdef DEBUG_I82593_SHOW
3558 print_hex_dump(KERN_DEBUG
, "wavelan_cs: config block: ", DUMP_PREFIX_NONE
,
3559 16, 1, &cfblk
, sizeof(struct i82593_conf_block
), false);
3562 /* Copy the config block to the i82593 */
3563 outb(TX_BASE
& 0xff, PIORL(base
));
3564 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3565 outb(sizeof(struct i82593_conf_block
) & 0xff, PIOP(base
)); /* lsb */
3566 outb(sizeof(struct i82593_conf_block
) >> 8, PIOP(base
)); /* msb */
3567 outsb(PIOP(base
), (char *) &cfblk
, sizeof(struct i82593_conf_block
));
3569 /* reset transmit DMA pointer */
3570 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3571 hacr_write(base
, HACR_DEFAULT
);
3572 if(!wv_82593_cmd(dev
, "wv_82593_config(): configure",
3573 OP0_CONFIGURE
, SR0_CONFIGURE_DONE
))
3576 /* Initialize adapter's ethernet MAC address */
3577 outb(TX_BASE
& 0xff, PIORL(base
));
3578 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3579 outb(WAVELAN_ADDR_SIZE
, PIOP(base
)); /* byte count lsb */
3580 outb(0, PIOP(base
)); /* byte count msb */
3581 outsb(PIOP(base
), &dev
->dev_addr
[0], WAVELAN_ADDR_SIZE
);
3583 /* reset transmit DMA pointer */
3584 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3585 hacr_write(base
, HACR_DEFAULT
);
3586 if(!wv_82593_cmd(dev
, "wv_82593_config(): ia-setup",
3587 OP0_IA_SETUP
, SR0_IA_SETUP_DONE
))
3590 #ifdef WAVELAN_ROAMING
3591 /* If roaming is enabled, join the "Beacon Request" multicast group... */
3592 /* But only if it's not in there already! */
3594 dev_mc_add(dev
, WAVELAN_BEACON_ADDRESS
);
3595 #endif /* WAVELAN_ROAMING */
3597 /* If any multicast address to set */
3600 struct netdev_hw_addr
*ha
;
3601 int addrs_len
= WAVELAN_ADDR_SIZE
* lp
->mc_count
;
3603 #ifdef DEBUG_CONFIG_INFO
3604 printk(KERN_DEBUG
"%s: wv_hw_config(): set %d multicast addresses:\n",
3605 dev
->name
, lp
->mc_count
);
3606 netdev_for_each_mc_addr(ha
, dev
)
3607 printk(KERN_DEBUG
" %pM\n", ha
->addr
);
3610 /* Initialize adapter's ethernet multicast addresses */
3611 outb(TX_BASE
& 0xff, PIORL(base
));
3612 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3613 outb(addrs_len
& 0xff, PIOP(base
)); /* byte count lsb */
3614 outb((addrs_len
>> 8), PIOP(base
)); /* byte count msb */
3615 netdev_for_each_mc_addr(ha
, dev
)
3616 outsb(PIOP(base
), ha
->addr
, dev
->addr_len
);
3618 /* reset transmit DMA pointer */
3619 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3620 hacr_write(base
, HACR_DEFAULT
);
3621 if(!wv_82593_cmd(dev
, "wv_82593_config(): mc-setup",
3622 OP0_MC_SETUP
, SR0_MC_SETUP_DONE
))
3624 /* remember to avoid repeated reset */
3625 lp
->mc_count
= netdev_mc_count(dev
);
3628 /* Job done, clear the flag */
3629 lp
->reconfig_82593
= FALSE
;
3631 #ifdef DEBUG_CONFIG_TRACE
3632 printk(KERN_DEBUG
"%s: <-wv_82593_config()\n", dev
->name
);
3637 /*------------------------------------------------------------------*/
3639 * Read the Access Configuration Register, perform a software reset,
3640 * and then re-enable the card's software.
3642 * If I understand correctly : reset the pcmcia interface of the
3644 * (called by wv_config())
3647 wv_pcmcia_reset(struct net_device
* dev
)
3650 conf_reg_t reg
= { 0, CS_READ
, CISREG_COR
, 0 };
3651 struct pcmcia_device
* link
= ((net_local
*)netdev_priv(dev
))->link
;
3653 #ifdef DEBUG_CONFIG_TRACE
3654 printk(KERN_DEBUG
"%s: ->wv_pcmcia_reset()\n", dev
->name
);
3657 i
= pcmcia_access_configuration_register(link
, ®
);
3661 #ifdef DEBUG_CONFIG_INFO
3662 printk(KERN_DEBUG
"%s: wavelan_pcmcia_reset(): Config reg is 0x%x\n",
3663 dev
->name
, (u_int
) reg
.Value
);
3666 reg
.Action
= CS_WRITE
;
3667 reg
.Value
= reg
.Value
| COR_SW_RESET
;
3668 i
= pcmcia_access_configuration_register(link
, ®
);
3672 reg
.Action
= CS_WRITE
;
3673 reg
.Value
= COR_LEVEL_IRQ
| COR_CONFIG
;
3674 i
= pcmcia_access_configuration_register(link
, ®
);
3678 #ifdef DEBUG_CONFIG_TRACE
3679 printk(KERN_DEBUG
"%s: <-wv_pcmcia_reset()\n", dev
->name
);
3684 /*------------------------------------------------------------------*/
3686 * wavelan_hw_config() is called after a CARD_INSERTION event is
3687 * received, to configure the wavelan hardware.
3688 * Note that the reception will be enabled in wavelan->open(), so the
3689 * device is configured but idle...
3690 * Performs the following actions:
3691 * 1. A pcmcia software reset (using wv_pcmcia_reset())
3692 * 2. A power reset (reset DMA)
3693 * 3. Reset the LAN controller
3694 * 4. Initialize the radio modem (using wv_mmc_init)
3695 * 5. Configure LAN controller (using wv_82593_config)
3696 * 6. Perform a diagnostic on the LAN controller
3697 * (called by wavelan_event() & wv_hw_reset())
3700 wv_hw_config(struct net_device
* dev
)
3702 net_local
* lp
= netdev_priv(dev
);
3703 unsigned int base
= dev
->base_addr
;
3704 unsigned long flags
;
3707 #ifdef DEBUG_CONFIG_TRACE
3708 printk(KERN_DEBUG
"%s: ->wv_hw_config()\n", dev
->name
);
3711 /* compile-time check the sizes of structures */
3712 BUILD_BUG_ON(sizeof(psa_t
) != PSA_SIZE
);
3713 BUILD_BUG_ON(sizeof(mmw_t
) != MMW_SIZE
);
3714 BUILD_BUG_ON(sizeof(mmr_t
) != MMR_SIZE
);
3716 /* Reset the pcmcia interface */
3717 if(wv_pcmcia_reset(dev
) == FALSE
)
3720 /* Disable interrupts */
3721 spin_lock_irqsave(&lp
->spinlock
, flags
);
3723 /* Disguised goto ;-) */
3726 /* Power UP the module + reset the modem + reset host adapter
3727 * (in fact, reset DMA channels) */
3728 hacr_write_slow(base
, HACR_RESET
);
3729 hacr_write(base
, HACR_DEFAULT
);
3731 /* Check if the module has been powered up... */
3732 if(hasr_read(base
) & HASR_NO_CLK
)
3734 #ifdef DEBUG_CONFIG_ERRORS
3735 printk(KERN_WARNING
"%s: wv_hw_config(): modem not connected or not a wavelan card\n",
3741 /* initialize the modem */
3742 if(wv_mmc_init(dev
) == FALSE
)
3744 #ifdef DEBUG_CONFIG_ERRORS
3745 printk(KERN_WARNING
"%s: wv_hw_config(): Can't configure the modem\n",
3751 /* reset the LAN controller (i82593) */
3752 outb(OP0_RESET
, LCCR(base
));
3753 mdelay(1); /* A bit crude ! */
3755 /* Initialize the LAN controller */
3756 if(wv_82593_config(dev
) == FALSE
)
3758 #ifdef DEBUG_CONFIG_ERRORS
3759 printk(KERN_INFO
"%s: wv_hw_config(): i82593 init failed\n",
3766 if(wv_diag(dev
) == FALSE
)
3768 #ifdef DEBUG_CONFIG_ERRORS
3769 printk(KERN_INFO
"%s: wv_hw_config(): i82593 diagnostic failed\n",
3776 * insert code for loopback test here
3779 /* The device is now configured */
3785 /* Re-enable interrupts */
3786 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3788 #ifdef DEBUG_CONFIG_TRACE
3789 printk(KERN_DEBUG
"%s: <-wv_hw_config()\n", dev
->name
);
3794 /*------------------------------------------------------------------*/
3796 * Totally reset the wavelan and restart it.
3797 * Performs the following actions:
3798 * 1. Call wv_hw_config()
3799 * 2. Start the LAN controller's receive unit
3800 * (called by wavelan_event(), wavelan_watchdog() and wavelan_open())
3803 wv_hw_reset(struct net_device
* dev
)
3805 net_local
* lp
= netdev_priv(dev
);
3807 #ifdef DEBUG_CONFIG_TRACE
3808 printk(KERN_DEBUG
"%s: ->wv_hw_reset()\n", dev
->name
);
3814 /* Call wv_hw_config() for most of the reset & init stuff */
3815 if(wv_hw_config(dev
) == FALSE
)
3818 /* start receive unit */
3821 #ifdef DEBUG_CONFIG_TRACE
3822 printk(KERN_DEBUG
"%s: <-wv_hw_reset()\n", dev
->name
);
3826 /*------------------------------------------------------------------*/
3828 * wv_pcmcia_config() is called after a CARD_INSERTION event is
3829 * received, to configure the PCMCIA socket, and to make the ethernet
3830 * device available to the system.
3831 * (called by wavelan_event())
3834 wv_pcmcia_config(struct pcmcia_device
* link
)
3836 struct net_device
* dev
= (struct net_device
*) link
->priv
;
3840 net_local
* lp
= netdev_priv(dev
);
3843 #ifdef DEBUG_CONFIG_TRACE
3844 printk(KERN_DEBUG
"->wv_pcmcia_config(0x%p)\n", link
);
3849 i
= pcmcia_request_io(link
, &link
->io
);
3854 * Now allocate an interrupt line. Note that this does not
3855 * actually assign a handler to the interrupt.
3857 i
= pcmcia_request_irq(link
, &link
->irq
);
3862 * This actually configures the PCMCIA socket -- setting up
3863 * the I/O windows and the interrupt mapping.
3865 link
->conf
.ConfigIndex
= 1;
3866 i
= pcmcia_request_configuration(link
, &link
->conf
);
3871 * Allocate a small memory window. Note that the struct pcmcia_device
3872 * structure provides space for one window handle -- if your
3873 * device needs several windows, you'll need to keep track of
3874 * the handles in your private data structure, link->priv.
3876 req
.Attributes
= WIN_DATA_WIDTH_8
|WIN_MEMORY_TYPE_AM
|WIN_ENABLE
;
3877 req
.Base
= req
.Size
= 0;
3878 req
.AccessSpeed
= mem_speed
;
3879 i
= pcmcia_request_window(link
, &req
, &link
->win
);
3883 lp
->mem
= ioremap(req
.Base
, req
.Size
);
3884 dev
->mem_start
= (u_long
)lp
->mem
;
3885 dev
->mem_end
= dev
->mem_start
+ req
.Size
;
3887 mem
.CardOffset
= 0; mem
.Page
= 0;
3888 i
= pcmcia_map_mem_page(link
, link
->win
, &mem
);
3892 /* Feed device with this info... */
3893 dev
->irq
= link
->irq
.AssignedIRQ
;
3894 dev
->base_addr
= link
->io
.BasePort1
;
3895 netif_start_queue(dev
);
3897 #ifdef DEBUG_CONFIG_INFO
3898 printk(KERN_DEBUG
"wv_pcmcia_config: MEMSTART %p IRQ %d IOPORT 0x%x\n",
3899 lp
->mem
, dev
->irq
, (u_int
) dev
->base_addr
);
3902 SET_NETDEV_DEV(dev
, &link
->dev
);
3903 i
= register_netdev(dev
);
3906 #ifdef DEBUG_CONFIG_ERRORS
3907 printk(KERN_INFO
"wv_pcmcia_config(): register_netdev() failed\n");
3912 while(0); /* Humm... Disguised goto !!! */
3914 /* If any step failed, release any partially configured state */
3917 wv_pcmcia_release(link
);
3921 strcpy(((net_local
*) netdev_priv(dev
))->node
.dev_name
, dev
->name
);
3922 link
->dev_node
= &((net_local
*) netdev_priv(dev
))->node
;
3924 #ifdef DEBUG_CONFIG_TRACE
3925 printk(KERN_DEBUG
"<-wv_pcmcia_config()\n");
3930 /*------------------------------------------------------------------*/
3932 * After a card is removed, wv_pcmcia_release() will unregister the net
3933 * device, and release the PCMCIA configuration. If the device is
3934 * still open, this will be postponed until it is closed.
3937 wv_pcmcia_release(struct pcmcia_device
*link
)
3939 struct net_device
* dev
= (struct net_device
*) link
->priv
;
3940 net_local
* lp
= netdev_priv(dev
);
3942 #ifdef DEBUG_CONFIG_TRACE
3943 printk(KERN_DEBUG
"%s: -> wv_pcmcia_release(0x%p)\n", dev
->name
, link
);
3947 pcmcia_disable_device(link
);
3949 #ifdef DEBUG_CONFIG_TRACE
3950 printk(KERN_DEBUG
"%s: <- wv_pcmcia_release()\n", dev
->name
);
3954 /************************ INTERRUPT HANDLING ************************/
3957 * This function is the interrupt handler for the WaveLAN card. This
3958 * routine will be called whenever:
3959 * 1. A packet is received.
3960 * 2. A packet has successfully been transferred and the unit is
3961 * ready to transmit another packet.
3962 * 3. A command has completed execution.
3965 wavelan_interrupt(int irq
,
3968 struct net_device
* dev
= dev_id
;
3974 #ifdef DEBUG_INTERRUPT_TRACE
3975 printk(KERN_DEBUG
"%s: ->wavelan_interrupt()\n", dev
->name
);
3978 lp
= netdev_priv(dev
);
3979 base
= dev
->base_addr
;
3981 #ifdef DEBUG_INTERRUPT_INFO
3982 /* Check state of our spinlock (it should be cleared) */
3983 if(spin_is_locked(&lp
->spinlock
))
3985 "%s: wavelan_interrupt(): spinlock is already locked !!!\n",
3989 /* Prevent reentrancy. We need to do that because we may have
3990 * multiple interrupt handler running concurrently.
3991 * It is safe because interrupts are disabled before aquiring
3993 spin_lock(&lp
->spinlock
);
3995 /* Treat all pending interrupts */
3998 /* ---------------- INTERRUPT CHECKING ---------------- */
4000 * Look for the interrupt and verify the validity
4002 outb(CR0_STATUS_0
| OP0_NOP
, LCCR(base
));
4003 status0
= inb(LCSR(base
));
4005 #ifdef DEBUG_INTERRUPT_INFO
4006 printk(KERN_DEBUG
"status0 0x%x [%s => 0x%x]", status0
,
4007 (status0
&SR0_INTERRUPT
)?"int":"no int",status0
&~SR0_INTERRUPT
);
4008 if(status0
&SR0_INTERRUPT
)
4010 printk(" [%s => %d]\n", (status0
& SR0_CHNL
) ? "chnl" :
4011 ((status0
& SR0_EXECUTION
) ? "cmd" :
4012 ((status0
& SR0_RECEPTION
) ? "recv" : "unknown")),
4013 (status0
& SR0_EVENT_MASK
));
4019 /* Return if no actual interrupt from i82593 (normal exit) */
4020 if(!(status0
& SR0_INTERRUPT
))
4023 /* If interrupt is both Rx and Tx or none...
4024 * This code in fact is there to catch the spurious interrupt
4025 * when you remove the wavelan pcmcia card from the socket */
4026 if(((status0
& SR0_BOTH_RX_TX
) == SR0_BOTH_RX_TX
) ||
4027 ((status0
& SR0_BOTH_RX_TX
) == 0x0))
4029 #ifdef DEBUG_INTERRUPT_INFO
4030 printk(KERN_INFO
"%s: wv_interrupt(): bogus interrupt (or from dead card) : %X\n",
4031 dev
->name
, status0
);
4033 /* Acknowledge the interrupt */
4034 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
));
4038 /* ----------------- RECEIVING PACKET ----------------- */
4040 * When the wavelan signal the reception of a new packet,
4041 * we call wv_packet_rcv() to copy if from the buffer and
4044 if(status0
& SR0_RECEPTION
)
4046 #ifdef DEBUG_INTERRUPT_INFO
4047 printk(KERN_DEBUG
"%s: wv_interrupt(): receive\n", dev
->name
);
4050 if((status0
& SR0_EVENT_MASK
) == SR0_STOP_REG_HIT
)
4052 #ifdef DEBUG_INTERRUPT_ERROR
4053 printk(KERN_INFO
"%s: wv_interrupt(): receive buffer overflow\n",
4056 dev
->stats
.rx_over_errors
++;
4057 lp
->overrunning
= 1;
4060 /* Get the packet */
4062 lp
->overrunning
= 0;
4064 /* Acknowledge the interrupt */
4065 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
));
4069 /* ---------------- COMMAND COMPLETION ---------------- */
4071 * Interrupts issued when the i82593 has completed a command.
4072 * Most likely : transmission done
4075 /* If a transmission has been done */
4076 if((status0
& SR0_EVENT_MASK
) == SR0_TRANSMIT_DONE
||
4077 (status0
& SR0_EVENT_MASK
) == SR0_RETRANSMIT_DONE
||
4078 (status0
& SR0_EVENT_MASK
) == SR0_TRANSMIT_NO_CRC_DONE
)
4080 #ifdef DEBUG_TX_ERROR
4081 if((status0
& SR0_EVENT_MASK
) == SR0_TRANSMIT_NO_CRC_DONE
)
4082 printk(KERN_INFO
"%s: wv_interrupt(): packet transmitted without CRC.\n",
4086 /* Get transmission status */
4087 tx_status
= inb(LCSR(base
));
4088 tx_status
|= (inb(LCSR(base
)) << 8);
4089 #ifdef DEBUG_INTERRUPT_INFO
4090 printk(KERN_DEBUG
"%s: wv_interrupt(): transmission done\n",
4095 rcv_bytes
= inb(LCSR(base
));
4096 rcv_bytes
|= (inb(LCSR(base
)) << 8);
4097 status3
= inb(LCSR(base
));
4098 printk(KERN_DEBUG
"tx_status 0x%02x rcv_bytes 0x%02x status3 0x%x\n",
4099 tx_status
, rcv_bytes
, (u_int
) status3
);
4102 /* Check for possible errors */
4103 if((tx_status
& TX_OK
) != TX_OK
)
4105 dev
->stats
.tx_errors
++;
4107 if(tx_status
& TX_FRTL
)
4109 #ifdef DEBUG_TX_ERROR
4110 printk(KERN_INFO
"%s: wv_interrupt(): frame too long\n",
4114 if(tx_status
& TX_UND_RUN
)
4116 #ifdef DEBUG_TX_FAIL
4117 printk(KERN_DEBUG
"%s: wv_interrupt(): DMA underrun\n",
4120 dev
->stats
.tx_aborted_errors
++;
4122 if(tx_status
& TX_LOST_CTS
)
4124 #ifdef DEBUG_TX_FAIL
4125 printk(KERN_DEBUG
"%s: wv_interrupt(): no CTS\n", dev
->name
);
4127 dev
->stats
.tx_carrier_errors
++;
4129 if(tx_status
& TX_LOST_CRS
)
4131 #ifdef DEBUG_TX_FAIL
4132 printk(KERN_DEBUG
"%s: wv_interrupt(): no carrier\n",
4135 dev
->stats
.tx_carrier_errors
++;
4137 if(tx_status
& TX_HRT_BEAT
)
4139 #ifdef DEBUG_TX_FAIL
4140 printk(KERN_DEBUG
"%s: wv_interrupt(): heart beat\n", dev
->name
);
4142 dev
->stats
.tx_heartbeat_errors
++;
4144 if(tx_status
& TX_DEFER
)
4146 #ifdef DEBUG_TX_FAIL
4147 printk(KERN_DEBUG
"%s: wv_interrupt(): channel jammed\n",
4151 /* Ignore late collisions since they're more likely to happen
4152 * here (the WaveLAN design prevents the LAN controller from
4153 * receiving while it is transmitting). We take action only when
4154 * the maximum retransmit attempts is exceeded.
4156 if(tx_status
& TX_COLL
)
4158 if(tx_status
& TX_MAX_COL
)
4160 #ifdef DEBUG_TX_FAIL
4161 printk(KERN_DEBUG
"%s: wv_interrupt(): channel congestion\n",
4164 if(!(tx_status
& TX_NCOL_MASK
))
4166 dev
->stats
.collisions
+= 0x10;
4170 } /* if(!(tx_status & TX_OK)) */
4172 dev
->stats
.collisions
+= (tx_status
& TX_NCOL_MASK
);
4173 dev
->stats
.tx_packets
++;
4175 netif_wake_queue(dev
);
4176 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
)); /* Acknowledge the interrupt */
4178 else /* if interrupt = transmit done or retransmit done */
4180 #ifdef DEBUG_INTERRUPT_ERROR
4181 printk(KERN_INFO
"wavelan_cs: unknown interrupt, status0 = %02x\n",
4184 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
)); /* Acknowledge the interrupt */
4188 spin_unlock(&lp
->spinlock
);
4190 #ifdef DEBUG_INTERRUPT_TRACE
4191 printk(KERN_DEBUG
"%s: <-wavelan_interrupt()\n", dev
->name
);
4194 /* We always return IRQ_HANDLED, because we will receive empty
4195 * interrupts under normal operations. Anyway, it doesn't matter
4196 * as we are dealing with an ISA interrupt that can't be shared.
4198 * Explanation : under heavy receive, the following happens :
4199 * ->wavelan_interrupt()
4200 * (status0 & SR0_INTERRUPT) != 0
4202 * (status0 & SR0_INTERRUPT) != 0
4204 * (status0 & SR0_INTERRUPT) == 0 // i.e. no more event
4205 * <-wavelan_interrupt()
4206 * ->wavelan_interrupt()
4207 * (status0 & SR0_INTERRUPT) == 0 // i.e. empty interrupt
4208 * <-wavelan_interrupt()
4211 } /* wv_interrupt */
4213 /*------------------------------------------------------------------*/
4215 * Watchdog: when we start a transmission, a timer is set for us in the
4216 * kernel. If the transmission completes, this timer is disabled. If
4217 * the timer expires, we are called and we try to unlock the hardware.
4219 * Note : This watchdog is move clever than the one in the ISA driver,
4220 * because it try to abort the current command before reseting
4222 * On the other hand, it's a bit simpler, because we don't have to
4223 * deal with the multiple Tx buffers...
4226 wavelan_watchdog(struct net_device
* dev
)
4228 net_local
* lp
= netdev_priv(dev
);
4229 unsigned int base
= dev
->base_addr
;
4230 unsigned long flags
;
4231 int aborted
= FALSE
;
4233 #ifdef DEBUG_INTERRUPT_TRACE
4234 printk(KERN_DEBUG
"%s: ->wavelan_watchdog()\n", dev
->name
);
4237 #ifdef DEBUG_INTERRUPT_ERROR
4238 printk(KERN_INFO
"%s: wavelan_watchdog: watchdog timer expired\n",
4242 spin_lock_irqsave(&lp
->spinlock
, flags
);
4244 /* Ask to abort the current command */
4245 outb(OP0_ABORT
, LCCR(base
));
4247 /* Wait for the end of the command (a bit hackish) */
4248 if(wv_82593_cmd(dev
, "wavelan_watchdog(): abort",
4249 OP0_NOP
| CR0_STATUS_3
, SR0_EXECUTION_ABORTED
))
4252 /* Release spinlock here so that wv_hw_reset() can grab it */
4253 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
4255 /* Check if we were successful in aborting it */
4258 /* It seem that it wasn't enough */
4259 #ifdef DEBUG_INTERRUPT_ERROR
4260 printk(KERN_INFO
"%s: wavelan_watchdog: abort failed, trying reset\n",
4266 #ifdef DEBUG_PSA_SHOW
4269 psa_read(dev
, 0, (unsigned char *) &psa
, sizeof(psa
));
4273 #ifdef DEBUG_MMC_SHOW
4276 #ifdef DEBUG_I82593_SHOW
4280 /* We are no more waiting for something... */
4281 netif_wake_queue(dev
);
4283 #ifdef DEBUG_INTERRUPT_TRACE
4284 printk(KERN_DEBUG
"%s: <-wavelan_watchdog()\n", dev
->name
);
4288 /********************* CONFIGURATION CALLBACKS *********************/
4290 * Here are the functions called by the pcmcia package (cardmgr) and
4291 * linux networking (NET3) for initialization, configuration and
4292 * deinstallations of the Wavelan Pcmcia Hardware.
4295 /*------------------------------------------------------------------*/
4297 * Configure and start up the WaveLAN PCMCIA adaptor.
4298 * Called by NET3 when it "open" the device.
4301 wavelan_open(struct net_device
* dev
)
4303 net_local
* lp
= netdev_priv(dev
);
4304 struct pcmcia_device
* link
= lp
->link
;
4305 unsigned int base
= dev
->base_addr
;
4307 #ifdef DEBUG_CALLBACK_TRACE
4308 printk(KERN_DEBUG
"%s: ->wavelan_open(dev=0x%x)\n", dev
->name
,
4309 (unsigned int) dev
);
4312 /* Check if the modem is powered up (wavelan_close() power it down */
4313 if(hasr_read(base
) & HASR_NO_CLK
)
4315 /* Power up (power up time is 250us) */
4316 hacr_write(base
, HACR_DEFAULT
);
4318 /* Check if the module has been powered up... */
4319 if(hasr_read(base
) & HASR_NO_CLK
)
4321 #ifdef DEBUG_CONFIG_ERRORS
4322 printk(KERN_WARNING
"%s: wavelan_open(): modem not connected\n",
4329 /* Start reception and declare the driver ready */
4332 if(!wv_ru_start(dev
))
4333 wv_hw_reset(dev
); /* If problem : reset */
4334 netif_start_queue(dev
);
4336 /* Mark the device as used */
4339 #ifdef WAVELAN_ROAMING
4342 #endif /* WAVELAN_ROAMING */
4344 #ifdef DEBUG_CALLBACK_TRACE
4345 printk(KERN_DEBUG
"%s: <-wavelan_open()\n", dev
->name
);
4350 /*------------------------------------------------------------------*/
4352 * Shutdown the WaveLAN PCMCIA adaptor.
4353 * Called by NET3 when it "close" the device.
4356 wavelan_close(struct net_device
* dev
)
4358 struct pcmcia_device
* link
= ((net_local
*)netdev_priv(dev
))->link
;
4359 unsigned int base
= dev
->base_addr
;
4361 #ifdef DEBUG_CALLBACK_TRACE
4362 printk(KERN_DEBUG
"%s: ->wavelan_close(dev=0x%x)\n", dev
->name
,
4363 (unsigned int) dev
);
4366 /* If the device isn't open, then nothing to do */
4369 #ifdef DEBUG_CONFIG_INFO
4370 printk(KERN_DEBUG
"%s: wavelan_close(): device not open\n", dev
->name
);
4375 #ifdef WAVELAN_ROAMING
4376 /* Cleanup of roaming stuff... */
4378 wv_roam_cleanup(dev
);
4379 #endif /* WAVELAN_ROAMING */
4383 /* If the card is still present */
4384 if(netif_running(dev
))
4386 netif_stop_queue(dev
);
4388 /* Stop receiving new messages and wait end of transmission */
4391 /* Power down the module */
4392 hacr_write(base
, HACR_DEFAULT
& (~HACR_PWR_STAT
));
4395 #ifdef DEBUG_CALLBACK_TRACE
4396 printk(KERN_DEBUG
"%s: <-wavelan_close()\n", dev
->name
);
4401 static const struct net_device_ops wavelan_netdev_ops
= {
4402 .ndo_open
= wavelan_open
,
4403 .ndo_stop
= wavelan_close
,
4404 .ndo_start_xmit
= wavelan_packet_xmit
,
4405 .ndo_set_multicast_list
= wavelan_set_multicast_list
,
4406 #ifdef SET_MAC_ADDRESS
4407 .ndo_set_mac_address
= wavelan_set_mac_address
,
4409 .ndo_tx_timeout
= wavelan_watchdog
,
4410 .ndo_change_mtu
= eth_change_mtu
,
4411 .ndo_validate_addr
= eth_validate_addr
,
4414 /*------------------------------------------------------------------*/
4416 * wavelan_attach() creates an "instance" of the driver, allocating
4417 * local data structures for one device (one interface). The device
4418 * is registered with Card Services.
4420 * The dev_link structure is initialized, but we don't actually
4421 * configure the card at this point -- we wait until we receive a
4422 * card insertion event.
4425 wavelan_probe(struct pcmcia_device
*p_dev
)
4427 struct net_device
* dev
; /* Interface generic data */
4428 net_local
* lp
; /* Interface specific data */
4431 #ifdef DEBUG_CALLBACK_TRACE
4432 printk(KERN_DEBUG
"-> wavelan_attach()\n");
4435 /* The io structure describes IO port mapping */
4436 p_dev
->io
.NumPorts1
= 8;
4437 p_dev
->io
.Attributes1
= IO_DATA_PATH_WIDTH_8
;
4438 p_dev
->io
.IOAddrLines
= 3;
4440 /* Interrupt setup */
4441 p_dev
->irq
.Attributes
= IRQ_TYPE_DYNAMIC_SHARING
;
4442 p_dev
->irq
.Handler
= wavelan_interrupt
;
4444 /* General socket configuration */
4445 p_dev
->conf
.Attributes
= CONF_ENABLE_IRQ
;
4446 p_dev
->conf
.IntType
= INT_MEMORY_AND_IO
;
4448 /* Allocate the generic data structure */
4449 dev
= alloc_etherdev(sizeof(net_local
));
4455 lp
= netdev_priv(dev
);
4457 /* Init specific data */
4459 lp
->reconfig_82593
= FALSE
;
4461 /* Multicast stuff */
4462 lp
->promiscuous
= 0;
4463 lp
->allmulticast
= 0;
4467 spin_lock_init(&lp
->spinlock
);
4472 /* wavelan NET3 callbacks */
4473 dev
->netdev_ops
= &wavelan_netdev_ops
;
4474 dev
->watchdog_timeo
= WATCHDOG_JIFFIES
;
4475 SET_ETHTOOL_OPS(dev
, &ops
);
4477 dev
->wireless_handlers
= &wavelan_handler_def
;
4478 lp
->wireless_data
.spy_data
= &lp
->spy_data
;
4479 dev
->wireless_data
= &lp
->wireless_data
;
4481 /* Other specific data */
4482 dev
->mtu
= WAVELAN_MTU
;
4484 ret
= wv_pcmcia_config(p_dev
);
4488 ret
= wv_hw_config(dev
);
4491 pcmcia_disable_device(p_dev
);
4497 #ifdef DEBUG_CALLBACK_TRACE
4498 printk(KERN_DEBUG
"<- wavelan_attach()\n");
4504 /*------------------------------------------------------------------*/
4506 * This deletes a driver "instance". The device is de-registered with
4507 * Card Services. If it has been released, all local data structures
4508 * are freed. Otherwise, the structures will be freed when the device
4512 wavelan_detach(struct pcmcia_device
*link
)
4514 #ifdef DEBUG_CALLBACK_TRACE
4515 printk(KERN_DEBUG
"-> wavelan_detach(0x%p)\n", link
);
4518 /* Some others haven't done their job : give them another chance */
4519 wv_pcmcia_release(link
);
4524 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4526 /* Remove ourselves from the kernel list of ethernet devices */
4527 /* Warning : can't be called from interrupt, timer or wavelan_close() */
4529 unregister_netdev(dev
);
4530 link
->dev_node
= NULL
;
4531 ((net_local
*)netdev_priv(dev
))->link
= NULL
;
4532 ((net_local
*)netdev_priv(dev
))->dev
= NULL
;
4536 #ifdef DEBUG_CALLBACK_TRACE
4537 printk(KERN_DEBUG
"<- wavelan_detach()\n");
4541 static int wavelan_suspend(struct pcmcia_device
*link
)
4543 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4545 /* NB: wavelan_close will be called, but too late, so we are
4546 * obliged to close nicely the wavelan here. David, could you
4547 * close the device before suspending them ? And, by the way,
4548 * could you, on resume, add a "route add -net ..." after the
4549 * ifconfig up ? Thanks... */
4551 /* Stop receiving new messages and wait end of transmission */
4555 netif_device_detach(dev
);
4557 /* Power down the module */
4558 hacr_write(dev
->base_addr
, HACR_DEFAULT
& (~HACR_PWR_STAT
));
4563 static int wavelan_resume(struct pcmcia_device
*link
)
4565 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4569 netif_device_attach(dev
);
4576 static struct pcmcia_device_id wavelan_ids
[] = {
4577 PCMCIA_DEVICE_PROD_ID12("AT&T","WaveLAN/PCMCIA", 0xe7c5affd, 0x1bc50975),
4578 PCMCIA_DEVICE_PROD_ID12("Digital", "RoamAbout/DS", 0x9999ab35, 0x00d05e06),
4579 PCMCIA_DEVICE_PROD_ID12("Lucent Technologies", "WaveLAN/PCMCIA", 0x23eb9949, 0x1bc50975),
4580 PCMCIA_DEVICE_PROD_ID12("NCR", "WaveLAN/PCMCIA", 0x24358cd4, 0x1bc50975),
4583 MODULE_DEVICE_TABLE(pcmcia
, wavelan_ids
);
4585 static struct pcmcia_driver wavelan_driver
= {
4586 .owner
= THIS_MODULE
,
4588 .name
= "wavelan_cs",
4590 .probe
= wavelan_probe
,
4591 .remove
= wavelan_detach
,
4592 .id_table
= wavelan_ids
,
4593 .suspend
= wavelan_suspend
,
4594 .resume
= wavelan_resume
,
4598 init_wavelan_cs(void)
4600 return pcmcia_register_driver(&wavelan_driver
);
4604 exit_wavelan_cs(void)
4606 pcmcia_unregister_driver(&wavelan_driver
);
4609 module_init(init_wavelan_cs
);
4610 module_exit(exit_wavelan_cs
);