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
, dev
->mc_count
);
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 (dev
->mc_count
> 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(dev
->mc_list
!= (struct dev_mc_list
*) NULL
)
1416 * Disable promiscuous mode, but receive all packets
1419 #ifdef MULTICAST_AVOID
1420 if(lp
->promiscuous
|| lp
->allmulticast
||
1421 (dev
->mc_count
!= lp
->mc_count
))
1424 lp
->promiscuous
= 0;
1425 lp
->allmulticast
= 0;
1426 lp
->mc_count
= dev
->mc_count
;
1428 wv_82593_reconfig(dev
);
1434 * Switch to normal mode: disable promiscuous mode and
1435 * clear the multicast list.
1437 if(lp
->promiscuous
|| lp
->mc_count
== 0)
1439 lp
->promiscuous
= 0;
1440 lp
->allmulticast
= 0;
1443 wv_82593_reconfig(dev
);
1446 #ifdef DEBUG_IOCTL_TRACE
1447 printk(KERN_DEBUG
"%s: <-wavelan_set_multicast_list()\n", dev
->name
);
1451 /*------------------------------------------------------------------*/
1453 * This function doesn't exist...
1454 * (Note : it was a nice way to test the reconfigure stuff...)
1456 #ifdef SET_MAC_ADDRESS
1458 wavelan_set_mac_address(struct net_device
* dev
,
1461 struct sockaddr
* mac
= addr
;
1463 /* Copy the address */
1464 memcpy(dev
->dev_addr
, mac
->sa_data
, WAVELAN_ADDR_SIZE
);
1466 /* Reconfig the beast */
1467 wv_82593_reconfig(dev
);
1471 #endif /* SET_MAC_ADDRESS */
1474 /*------------------------------------------------------------------*/
1476 * Frequency setting (for hardware able of it)
1477 * It's a bit complicated and you don't really want to look into it...
1480 wv_set_frequency(u_long base
, /* i/o port of the card */
1481 iw_freq
* frequency
)
1483 const int BAND_NUM
= 10; /* Number of bands */
1484 long freq
= 0L; /* offset to 2.4 GHz in .5 MHz */
1485 #ifdef DEBUG_IOCTL_INFO
1489 /* Setting by frequency */
1490 /* Theoritically, you may set any frequency between
1491 * the two limits with a 0.5 MHz precision. In practice,
1492 * I don't want you to have trouble with local
1494 if((frequency
->e
== 1) &&
1495 (frequency
->m
>= (int) 2.412e8
) && (frequency
->m
<= (int) 2.487e8
))
1497 freq
= ((frequency
->m
/ 10000) - 24000L) / 5;
1500 /* Setting by channel (same as wfreqsel) */
1501 /* Warning : each channel is 22MHz wide, so some of the channels
1502 * will interfere... */
1503 if((frequency
->e
== 0) &&
1504 (frequency
->m
>= 0) && (frequency
->m
< BAND_NUM
))
1506 /* Get frequency offset. */
1507 freq
= channel_bands
[frequency
->m
] >> 1;
1510 /* Verify if the frequency is allowed */
1513 u_short table
[10]; /* Authorized frequency table */
1515 /* Read the frequency table */
1516 fee_read(base
, 0x71 /* frequency table */,
1519 #ifdef DEBUG_IOCTL_INFO
1520 printk(KERN_DEBUG
"Frequency table :");
1521 for(i
= 0; i
< 10; i
++)
1529 /* Look in the table if the frequency is allowed */
1530 if(!(table
[9 - ((freq
- 24) / 16)] &
1531 (1 << ((freq
- 24) % 16))))
1532 return -EINVAL
; /* not allowed */
1537 /* If we get a usable frequency */
1540 unsigned short area
[16];
1541 unsigned short dac
[2];
1542 unsigned short area_verify
[16];
1543 unsigned short dac_verify
[2];
1544 /* Corresponding gain (in the power adjust value table)
1545 * see AT&T Wavelan Data Manual, REF 407-024689/E, page 3-8
1546 * & WCIN062D.DOC, page 6.2.9 */
1547 unsigned short power_limit
[] = { 40, 80, 120, 160, 0 };
1548 int power_band
= 0; /* Selected band */
1549 unsigned short power_adjust
; /* Correct value */
1551 /* Search for the gain */
1553 while((freq
> power_limit
[power_band
]) &&
1554 (power_limit
[++power_band
] != 0))
1557 /* Read the first area */
1558 fee_read(base
, 0x00,
1562 fee_read(base
, 0x60,
1565 /* Read the new power adjust value */
1566 fee_read(base
, 0x6B - (power_band
>> 1),
1568 if(power_band
& 0x1)
1571 power_adjust
&= 0xFF;
1573 #ifdef DEBUG_IOCTL_INFO
1574 printk(KERN_DEBUG
"Wavelan EEprom Area 1 :");
1575 for(i
= 0; i
< 16; i
++)
1582 printk(KERN_DEBUG
"Wavelan EEprom DAC : %04X %04X\n",
1586 /* Frequency offset (for info only...) */
1587 area
[0] = ((freq
<< 5) & 0xFFE0) | (area
[0] & 0x1F);
1589 /* Receiver Principle main divider coefficient */
1590 area
[3] = (freq
>> 1) + 2400L - 352L;
1591 area
[2] = ((freq
& 0x1) << 4) | (area
[2] & 0xFFEF);
1593 /* Transmitter Main divider coefficient */
1594 area
[13] = (freq
>> 1) + 2400L;
1595 area
[12] = ((freq
& 0x1) << 4) | (area
[2] & 0xFFEF);
1597 /* Others part of the area are flags, bit streams or unused... */
1599 /* Set the value in the DAC */
1600 dac
[1] = ((power_adjust
>> 1) & 0x7F) | (dac
[1] & 0xFF80);
1601 dac
[0] = ((power_adjust
& 0x1) << 4) | (dac
[0] & 0xFFEF);
1603 /* Write the first area */
1604 fee_write(base
, 0x00,
1608 fee_write(base
, 0x60,
1611 /* We now should verify here that the EEprom writing was ok */
1613 /* ReRead the first area */
1614 fee_read(base
, 0x00,
1617 /* ReRead the DAC */
1618 fee_read(base
, 0x60,
1622 if(memcmp(area
, area_verify
, 16 * 2) ||
1623 memcmp(dac
, dac_verify
, 2 * 2))
1625 #ifdef DEBUG_IOCTL_ERROR
1626 printk(KERN_INFO
"Wavelan: wv_set_frequency : unable to write new frequency to EEprom (?)\n");
1631 /* We must download the frequency parameters to the
1632 * synthetisers (from the EEprom - area 1)
1633 * Note : as the EEprom is auto decremented, we set the end
1635 mmc_out(base
, mmwoff(0, mmw_fee_addr
), 0x0F);
1636 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
),
1637 MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
);
1639 /* Wait until the download is finished */
1640 fee_wait(base
, 100, 100);
1642 /* We must now download the power adjust value (gain) to
1643 * the synthetisers (from the EEprom - area 7 - DAC) */
1644 mmc_out(base
, mmwoff(0, mmw_fee_addr
), 0x61);
1645 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
),
1646 MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
);
1648 /* Wait until the download is finished */
1649 fee_wait(base
, 100, 100);
1651 #ifdef DEBUG_IOCTL_INFO
1652 /* Verification of what we have done... */
1654 printk(KERN_DEBUG
"Wavelan EEprom Area 1 :");
1655 for(i
= 0; i
< 16; i
++)
1662 printk(KERN_DEBUG
"Wavelan EEprom DAC : %04X %04X\n",
1663 dac_verify
[0], dac_verify
[1]);
1669 return -EINVAL
; /* Bah, never get there... */
1672 /*------------------------------------------------------------------*/
1674 * Give the list of available frequencies
1677 wv_frequency_list(u_long base
, /* i/o port of the card */
1678 iw_freq
* list
, /* List of frequency to fill */
1679 int max
) /* Maximum number of frequencies */
1681 u_short table
[10]; /* Authorized frequency table */
1682 long freq
= 0L; /* offset to 2.4 GHz in .5 MHz + 12 MHz */
1683 int i
; /* index in the table */
1684 const int BAND_NUM
= 10; /* Number of bands */
1685 int c
= 0; /* Channel number */
1687 /* Read the frequency table */
1688 fee_read(base
, 0x71 /* frequency table */,
1691 /* Look all frequencies */
1693 for(freq
= 0; freq
< 150; freq
++)
1694 /* Look in the table if the frequency is allowed */
1695 if(table
[9 - (freq
/ 16)] & (1 << (freq
% 16)))
1697 /* Compute approximate channel number */
1698 while((((channel_bands
[c
] >> 1) - 24) < freq
) &&
1701 list
[i
].i
= c
; /* Set the list index */
1703 /* put in the list */
1704 list
[i
].m
= (((freq
+ 24) * 5) + 24000L) * 10000;
1715 #ifdef IW_WIRELESS_SPY
1716 /*------------------------------------------------------------------*/
1718 * Gather wireless spy statistics : for each packet, compare the source
1719 * address with out list, and if match, get the stats...
1720 * Sorry, but this function really need wireless extensions...
1723 wl_spy_gather(struct net_device
* dev
,
1724 u_char
* mac
, /* MAC address */
1725 u_char
* stats
) /* Statistics to gather */
1727 struct iw_quality wstats
;
1729 wstats
.qual
= stats
[2] & MMR_SGNL_QUAL
;
1730 wstats
.level
= stats
[0] & MMR_SIGNAL_LVL
;
1731 wstats
.noise
= stats
[1] & MMR_SILENCE_LVL
;
1732 wstats
.updated
= 0x7;
1734 /* Update spy records */
1735 wireless_spy_update(dev
, mac
, &wstats
);
1737 #endif /* IW_WIRELESS_SPY */
1740 /*------------------------------------------------------------------*/
1742 * This function calculate an histogram on the signal level.
1743 * As the noise is quite constant, it's like doing it on the SNR.
1744 * We have defined a set of interval (lp->his_range), and each time
1745 * the level goes in that interval, we increment the count (lp->his_sum).
1746 * With this histogram you may detect if one wavelan is really weak,
1747 * or you may also calculate the mean and standard deviation of the level...
1750 wl_his_gather(struct net_device
* dev
,
1751 u_char
* stats
) /* Statistics to gather */
1753 net_local
* lp
= netdev_priv(dev
);
1754 u_char level
= stats
[0] & MMR_SIGNAL_LVL
;
1757 /* Find the correct interval */
1759 while((i
< (lp
->his_number
- 1)) && (level
>= lp
->his_range
[i
++]))
1762 /* Increment interval counter */
1765 #endif /* HISTOGRAM */
1767 static void wl_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
1769 strncpy(info
->driver
, "wavelan_cs", sizeof(info
->driver
)-1);
1772 static const struct ethtool_ops ops
= {
1773 .get_drvinfo
= wl_get_drvinfo
1776 /*------------------------------------------------------------------*/
1778 * Wireless Handler : get protocol name
1780 static int wavelan_get_name(struct net_device
*dev
,
1781 struct iw_request_info
*info
,
1782 union iwreq_data
*wrqu
,
1785 strcpy(wrqu
->name
, "WaveLAN");
1789 /*------------------------------------------------------------------*/
1791 * Wireless Handler : set NWID
1793 static int wavelan_set_nwid(struct net_device
*dev
,
1794 struct iw_request_info
*info
,
1795 union iwreq_data
*wrqu
,
1798 unsigned int base
= dev
->base_addr
;
1799 net_local
*lp
= netdev_priv(dev
);
1802 unsigned long flags
;
1805 /* Disable interrupts and save flags. */
1806 spin_lock_irqsave(&lp
->spinlock
, flags
);
1808 /* Set NWID in WaveLAN. */
1809 if (!wrqu
->nwid
.disabled
) {
1810 /* Set NWID in psa */
1811 psa
.psa_nwid
[0] = (wrqu
->nwid
.value
& 0xFF00) >> 8;
1812 psa
.psa_nwid
[1] = wrqu
->nwid
.value
& 0xFF;
1813 psa
.psa_nwid_select
= 0x01;
1815 (char *) psa
.psa_nwid
- (char *) &psa
,
1816 (unsigned char *) psa
.psa_nwid
, 3);
1818 /* Set NWID in mmc. */
1819 m
.w
.mmw_netw_id_l
= psa
.psa_nwid
[1];
1820 m
.w
.mmw_netw_id_h
= psa
.psa_nwid
[0];
1822 (char *) &m
.w
.mmw_netw_id_l
-
1824 (unsigned char *) &m
.w
.mmw_netw_id_l
, 2);
1825 mmc_out(base
, mmwoff(0, mmw_loopt_sel
), 0x00);
1827 /* Disable NWID in the psa. */
1828 psa
.psa_nwid_select
= 0x00;
1830 (char *) &psa
.psa_nwid_select
-
1832 (unsigned char *) &psa
.psa_nwid_select
,
1835 /* Disable NWID in the mmc (no filtering). */
1836 mmc_out(base
, mmwoff(0, mmw_loopt_sel
),
1837 MMW_LOOPT_SEL_DIS_NWID
);
1839 /* update the Wavelan checksum */
1840 update_psa_checksum(dev
);
1842 /* Enable interrupts and restore flags. */
1843 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1848 /*------------------------------------------------------------------*/
1850 * Wireless Handler : get NWID
1852 static int wavelan_get_nwid(struct net_device
*dev
,
1853 struct iw_request_info
*info
,
1854 union iwreq_data
*wrqu
,
1857 net_local
*lp
= netdev_priv(dev
);
1859 unsigned long flags
;
1862 /* Disable interrupts and save flags. */
1863 spin_lock_irqsave(&lp
->spinlock
, flags
);
1865 /* Read the NWID. */
1867 (char *) psa
.psa_nwid
- (char *) &psa
,
1868 (unsigned char *) psa
.psa_nwid
, 3);
1869 wrqu
->nwid
.value
= (psa
.psa_nwid
[0] << 8) + psa
.psa_nwid
[1];
1870 wrqu
->nwid
.disabled
= !(psa
.psa_nwid_select
);
1871 wrqu
->nwid
.fixed
= 1; /* Superfluous */
1873 /* Enable interrupts and restore flags. */
1874 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1879 /*------------------------------------------------------------------*/
1881 * Wireless Handler : set frequency
1883 static int wavelan_set_freq(struct net_device
*dev
,
1884 struct iw_request_info
*info
,
1885 union iwreq_data
*wrqu
,
1888 unsigned int base
= dev
->base_addr
;
1889 net_local
*lp
= netdev_priv(dev
);
1890 unsigned long flags
;
1893 /* Disable interrupts and save flags. */
1894 spin_lock_irqsave(&lp
->spinlock
, flags
);
1896 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
1897 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
1898 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
)))
1899 ret
= wv_set_frequency(base
, &(wrqu
->freq
));
1903 /* Enable interrupts and restore flags. */
1904 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1909 /*------------------------------------------------------------------*/
1911 * Wireless Handler : get frequency
1913 static int wavelan_get_freq(struct net_device
*dev
,
1914 struct iw_request_info
*info
,
1915 union iwreq_data
*wrqu
,
1918 unsigned int base
= dev
->base_addr
;
1919 net_local
*lp
= netdev_priv(dev
);
1921 unsigned long flags
;
1924 /* Disable interrupts and save flags. */
1925 spin_lock_irqsave(&lp
->spinlock
, flags
);
1927 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable).
1928 * Does it work for everybody, especially old cards? */
1929 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
1930 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
))) {
1931 unsigned short freq
;
1933 /* Ask the EEPROM to read the frequency from the first area. */
1934 fee_read(base
, 0x00, &freq
, 1);
1935 wrqu
->freq
.m
= ((freq
>> 5) * 5 + 24000L) * 10000;
1939 (char *) &psa
.psa_subband
- (char *) &psa
,
1940 (unsigned char *) &psa
.psa_subband
, 1);
1942 if (psa
.psa_subband
<= 4) {
1943 wrqu
->freq
.m
= fixed_bands
[psa
.psa_subband
];
1944 wrqu
->freq
.e
= (psa
.psa_subband
!= 0);
1949 /* Enable interrupts and restore flags. */
1950 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1955 /*------------------------------------------------------------------*/
1957 * Wireless Handler : set level threshold
1959 static int wavelan_set_sens(struct net_device
*dev
,
1960 struct iw_request_info
*info
,
1961 union iwreq_data
*wrqu
,
1964 unsigned int base
= dev
->base_addr
;
1965 net_local
*lp
= netdev_priv(dev
);
1967 unsigned long flags
;
1970 /* Disable interrupts and save flags. */
1971 spin_lock_irqsave(&lp
->spinlock
, flags
);
1973 /* Set the level threshold. */
1974 /* We should complain loudly if wrqu->sens.fixed = 0, because we
1975 * can't set auto mode... */
1976 psa
.psa_thr_pre_set
= wrqu
->sens
.value
& 0x3F;
1978 (char *) &psa
.psa_thr_pre_set
- (char *) &psa
,
1979 (unsigned char *) &psa
.psa_thr_pre_set
, 1);
1980 /* update the Wavelan checksum */
1981 update_psa_checksum(dev
);
1982 mmc_out(base
, mmwoff(0, mmw_thr_pre_set
),
1983 psa
.psa_thr_pre_set
);
1985 /* Enable interrupts and restore flags. */
1986 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1991 /*------------------------------------------------------------------*/
1993 * Wireless Handler : get level threshold
1995 static int wavelan_get_sens(struct net_device
*dev
,
1996 struct iw_request_info
*info
,
1997 union iwreq_data
*wrqu
,
2000 net_local
*lp
= netdev_priv(dev
);
2002 unsigned long flags
;
2005 /* Disable interrupts and save flags. */
2006 spin_lock_irqsave(&lp
->spinlock
, flags
);
2008 /* Read the level threshold. */
2010 (char *) &psa
.psa_thr_pre_set
- (char *) &psa
,
2011 (unsigned char *) &psa
.psa_thr_pre_set
, 1);
2012 wrqu
->sens
.value
= psa
.psa_thr_pre_set
& 0x3F;
2013 wrqu
->sens
.fixed
= 1;
2015 /* Enable interrupts and restore flags. */
2016 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2021 /*------------------------------------------------------------------*/
2023 * Wireless Handler : set encryption key
2025 static int wavelan_set_encode(struct net_device
*dev
,
2026 struct iw_request_info
*info
,
2027 union iwreq_data
*wrqu
,
2030 unsigned int base
= dev
->base_addr
;
2031 net_local
*lp
= netdev_priv(dev
);
2032 unsigned long flags
;
2036 /* Disable interrupts and save flags. */
2037 spin_lock_irqsave(&lp
->spinlock
, flags
);
2039 /* Check if capable of encryption */
2040 if (!mmc_encr(base
)) {
2044 /* Check the size of the key */
2045 if((wrqu
->encoding
.length
!= 8) && (wrqu
->encoding
.length
!= 0)) {
2050 /* Basic checking... */
2051 if (wrqu
->encoding
.length
== 8) {
2052 /* Copy the key in the driver */
2053 memcpy(psa
.psa_encryption_key
, extra
,
2054 wrqu
->encoding
.length
);
2055 psa
.psa_encryption_select
= 1;
2058 (char *) &psa
.psa_encryption_select
-
2060 (unsigned char *) &psa
.
2061 psa_encryption_select
, 8 + 1);
2063 mmc_out(base
, mmwoff(0, mmw_encr_enable
),
2064 MMW_ENCR_ENABLE_EN
| MMW_ENCR_ENABLE_MODE
);
2065 mmc_write(base
, mmwoff(0, mmw_encr_key
),
2066 (unsigned char *) &psa
.
2067 psa_encryption_key
, 8);
2070 /* disable encryption */
2071 if (wrqu
->encoding
.flags
& IW_ENCODE_DISABLED
) {
2072 psa
.psa_encryption_select
= 0;
2074 (char *) &psa
.psa_encryption_select
-
2076 (unsigned char *) &psa
.
2077 psa_encryption_select
, 1);
2079 mmc_out(base
, mmwoff(0, mmw_encr_enable
), 0);
2081 /* update the Wavelan checksum */
2082 update_psa_checksum(dev
);
2085 /* Enable interrupts and restore flags. */
2086 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2091 /*------------------------------------------------------------------*/
2093 * Wireless Handler : get encryption key
2095 static int wavelan_get_encode(struct net_device
*dev
,
2096 struct iw_request_info
*info
,
2097 union iwreq_data
*wrqu
,
2100 unsigned int base
= dev
->base_addr
;
2101 net_local
*lp
= netdev_priv(dev
);
2103 unsigned long flags
;
2106 /* Disable interrupts and save flags. */
2107 spin_lock_irqsave(&lp
->spinlock
, flags
);
2109 /* Check if encryption is available */
2110 if (!mmc_encr(base
)) {
2113 /* Read the encryption key */
2115 (char *) &psa
.psa_encryption_select
-
2117 (unsigned char *) &psa
.
2118 psa_encryption_select
, 1 + 8);
2120 /* encryption is enabled ? */
2121 if (psa
.psa_encryption_select
)
2122 wrqu
->encoding
.flags
= IW_ENCODE_ENABLED
;
2124 wrqu
->encoding
.flags
= IW_ENCODE_DISABLED
;
2125 wrqu
->encoding
.flags
|= mmc_encr(base
);
2127 /* Copy the key to the user buffer */
2128 wrqu
->encoding
.length
= 8;
2129 memcpy(extra
, psa
.psa_encryption_key
, wrqu
->encoding
.length
);
2132 /* Enable interrupts and restore flags. */
2133 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2138 #ifdef WAVELAN_ROAMING_EXT
2139 /*------------------------------------------------------------------*/
2141 * Wireless Handler : set ESSID (domain)
2143 static int wavelan_set_essid(struct net_device
*dev
,
2144 struct iw_request_info
*info
,
2145 union iwreq_data
*wrqu
,
2148 net_local
*lp
= netdev_priv(dev
);
2149 unsigned long flags
;
2152 /* Disable interrupts and save flags. */
2153 spin_lock_irqsave(&lp
->spinlock
, flags
);
2155 /* Check if disable */
2156 if(wrqu
->data
.flags
== 0)
2157 lp
->filter_domains
= 0;
2159 char essid
[IW_ESSID_MAX_SIZE
+ 1];
2162 /* Terminate the string */
2163 memcpy(essid
, extra
, wrqu
->data
.length
);
2164 essid
[IW_ESSID_MAX_SIZE
] = '\0';
2166 #ifdef DEBUG_IOCTL_INFO
2167 printk(KERN_DEBUG
"SetEssid : ``%s''\n", essid
);
2168 #endif /* DEBUG_IOCTL_INFO */
2170 /* Convert to a number (note : Wavelan specific) */
2171 lp
->domain_id
= simple_strtoul(essid
, &endp
, 16);
2172 /* Has it worked ? */
2174 lp
->filter_domains
= 1;
2176 lp
->filter_domains
= 0;
2181 /* Enable interrupts and restore flags. */
2182 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2187 /*------------------------------------------------------------------*/
2189 * Wireless Handler : get ESSID (domain)
2191 static int wavelan_get_essid(struct net_device
*dev
,
2192 struct iw_request_info
*info
,
2193 union iwreq_data
*wrqu
,
2196 net_local
*lp
= netdev_priv(dev
);
2198 /* Is the domain ID active ? */
2199 wrqu
->data
.flags
= lp
->filter_domains
;
2201 /* Copy Domain ID into a string (Wavelan specific) */
2202 /* Sound crazy, be we can't have a snprintf in the kernel !!! */
2203 sprintf(extra
, "%lX", lp
->domain_id
);
2204 extra
[IW_ESSID_MAX_SIZE
] = '\0';
2206 /* Set the length */
2207 wrqu
->data
.length
= strlen(extra
);
2212 /*------------------------------------------------------------------*/
2214 * Wireless Handler : set AP address
2216 static int wavelan_set_wap(struct net_device
*dev
,
2217 struct iw_request_info
*info
,
2218 union iwreq_data
*wrqu
,
2221 #ifdef DEBUG_IOCTL_INFO
2222 printk(KERN_DEBUG
"Set AP to : %pM\n", wrqu
->ap_addr
.sa_data
);
2223 #endif /* DEBUG_IOCTL_INFO */
2228 /*------------------------------------------------------------------*/
2230 * Wireless Handler : get AP address
2232 static int wavelan_get_wap(struct net_device
*dev
,
2233 struct iw_request_info
*info
,
2234 union iwreq_data
*wrqu
,
2237 /* Should get the real McCoy instead of own Ethernet address */
2238 memcpy(wrqu
->ap_addr
.sa_data
, dev
->dev_addr
, WAVELAN_ADDR_SIZE
);
2239 wrqu
->ap_addr
.sa_family
= ARPHRD_ETHER
;
2243 #endif /* WAVELAN_ROAMING_EXT */
2245 #ifdef WAVELAN_ROAMING
2246 /*------------------------------------------------------------------*/
2248 * Wireless Handler : set mode
2250 static int wavelan_set_mode(struct net_device
*dev
,
2251 struct iw_request_info
*info
,
2252 union iwreq_data
*wrqu
,
2255 net_local
*lp
= netdev_priv(dev
);
2256 unsigned long flags
;
2259 /* Disable interrupts and save flags. */
2260 spin_lock_irqsave(&lp
->spinlock
, flags
);
2263 switch(wrqu
->mode
) {
2266 wv_roam_cleanup(dev
);
2280 /* Enable interrupts and restore flags. */
2281 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2286 /*------------------------------------------------------------------*/
2288 * Wireless Handler : get mode
2290 static int wavelan_get_mode(struct net_device
*dev
,
2291 struct iw_request_info
*info
,
2292 union iwreq_data
*wrqu
,
2296 wrqu
->mode
= IW_MODE_INFRA
;
2298 wrqu
->mode
= IW_MODE_ADHOC
;
2302 #endif /* WAVELAN_ROAMING */
2304 /*------------------------------------------------------------------*/
2306 * Wireless Handler : get range info
2308 static int wavelan_get_range(struct net_device
*dev
,
2309 struct iw_request_info
*info
,
2310 union iwreq_data
*wrqu
,
2313 unsigned int base
= dev
->base_addr
;
2314 net_local
*lp
= netdev_priv(dev
);
2315 struct iw_range
*range
= (struct iw_range
*) extra
;
2316 unsigned long flags
;
2319 /* Set the length (very important for backward compatibility) */
2320 wrqu
->data
.length
= sizeof(struct iw_range
);
2322 /* Set all the info we don't care or don't know about to zero */
2323 memset(range
, 0, sizeof(struct iw_range
));
2325 /* Set the Wireless Extension versions */
2326 range
->we_version_compiled
= WIRELESS_EXT
;
2327 range
->we_version_source
= 9;
2329 /* Set information in the range struct. */
2330 range
->throughput
= 1.4 * 1000 * 1000; /* don't argue on this ! */
2331 range
->min_nwid
= 0x0000;
2332 range
->max_nwid
= 0xFFFF;
2334 range
->sensitivity
= 0x3F;
2335 range
->max_qual
.qual
= MMR_SGNL_QUAL
;
2336 range
->max_qual
.level
= MMR_SIGNAL_LVL
;
2337 range
->max_qual
.noise
= MMR_SILENCE_LVL
;
2338 range
->avg_qual
.qual
= MMR_SGNL_QUAL
; /* Always max */
2339 /* Need to get better values for those two */
2340 range
->avg_qual
.level
= 30;
2341 range
->avg_qual
.noise
= 8;
2343 range
->num_bitrates
= 1;
2344 range
->bitrate
[0] = 2000000; /* 2 Mb/s */
2346 /* Event capability (kernel + driver) */
2347 range
->event_capa
[0] = (IW_EVENT_CAPA_MASK(0x8B02) |
2348 IW_EVENT_CAPA_MASK(0x8B04) |
2349 IW_EVENT_CAPA_MASK(0x8B06));
2350 range
->event_capa
[1] = IW_EVENT_CAPA_K_1
;
2352 /* Disable interrupts and save flags. */
2353 spin_lock_irqsave(&lp
->spinlock
, flags
);
2355 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
2356 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
2357 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
))) {
2358 range
->num_channels
= 10;
2359 range
->num_frequency
= wv_frequency_list(base
, range
->freq
,
2360 IW_MAX_FREQUENCIES
);
2362 range
->num_channels
= range
->num_frequency
= 0;
2364 /* Encryption supported ? */
2365 if (mmc_encr(base
)) {
2366 range
->encoding_size
[0] = 8; /* DES = 64 bits key */
2367 range
->num_encoding_sizes
= 1;
2368 range
->max_encoding_tokens
= 1; /* Only one key possible */
2370 range
->num_encoding_sizes
= 0;
2371 range
->max_encoding_tokens
= 0;
2374 /* Enable interrupts and restore flags. */
2375 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2380 /*------------------------------------------------------------------*/
2382 * Wireless Private Handler : set quality threshold
2384 static int wavelan_set_qthr(struct net_device
*dev
,
2385 struct iw_request_info
*info
,
2386 union iwreq_data
*wrqu
,
2389 unsigned int base
= dev
->base_addr
;
2390 net_local
*lp
= netdev_priv(dev
);
2392 unsigned long flags
;
2394 /* Disable interrupts and save flags. */
2395 spin_lock_irqsave(&lp
->spinlock
, flags
);
2397 psa
.psa_quality_thr
= *(extra
) & 0x0F;
2399 (char *) &psa
.psa_quality_thr
- (char *) &psa
,
2400 (unsigned char *) &psa
.psa_quality_thr
, 1);
2401 /* update the Wavelan checksum */
2402 update_psa_checksum(dev
);
2403 mmc_out(base
, mmwoff(0, mmw_quality_thr
),
2404 psa
.psa_quality_thr
);
2406 /* Enable interrupts and restore flags. */
2407 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2412 /*------------------------------------------------------------------*/
2414 * Wireless Private Handler : get quality threshold
2416 static int wavelan_get_qthr(struct net_device
*dev
,
2417 struct iw_request_info
*info
,
2418 union iwreq_data
*wrqu
,
2421 net_local
*lp
= netdev_priv(dev
);
2423 unsigned long flags
;
2425 /* Disable interrupts and save flags. */
2426 spin_lock_irqsave(&lp
->spinlock
, flags
);
2429 (char *) &psa
.psa_quality_thr
- (char *) &psa
,
2430 (unsigned char *) &psa
.psa_quality_thr
, 1);
2431 *(extra
) = psa
.psa_quality_thr
& 0x0F;
2433 /* Enable interrupts and restore flags. */
2434 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2439 #ifdef WAVELAN_ROAMING
2440 /*------------------------------------------------------------------*/
2442 * Wireless Private Handler : set roaming
2444 static int wavelan_set_roam(struct net_device
*dev
,
2445 struct iw_request_info
*info
,
2446 union iwreq_data
*wrqu
,
2449 net_local
*lp
= netdev_priv(dev
);
2450 unsigned long flags
;
2452 /* Disable interrupts and save flags. */
2453 spin_lock_irqsave(&lp
->spinlock
, flags
);
2455 /* Note : should check if user == root */
2456 if(do_roaming
&& (*extra
)==0)
2457 wv_roam_cleanup(dev
);
2458 else if(do_roaming
==0 && (*extra
)!=0)
2461 do_roaming
= (*extra
);
2463 /* Enable interrupts and restore flags. */
2464 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2469 /*------------------------------------------------------------------*/
2471 * Wireless Private Handler : get quality threshold
2473 static int wavelan_get_roam(struct net_device
*dev
,
2474 struct iw_request_info
*info
,
2475 union iwreq_data
*wrqu
,
2478 *(extra
) = do_roaming
;
2482 #endif /* WAVELAN_ROAMING */
2485 /*------------------------------------------------------------------*/
2487 * Wireless Private Handler : set histogram
2489 static int wavelan_set_histo(struct net_device
*dev
,
2490 struct iw_request_info
*info
,
2491 union iwreq_data
*wrqu
,
2494 net_local
*lp
= netdev_priv(dev
);
2496 /* Check the number of intervals. */
2497 if (wrqu
->data
.length
> 16) {
2501 /* Disable histo while we copy the addresses.
2502 * As we don't disable interrupts, we need to do this */
2505 /* Are there ranges to copy? */
2506 if (wrqu
->data
.length
> 0) {
2507 /* Copy interval ranges to the driver */
2508 memcpy(lp
->his_range
, extra
, wrqu
->data
.length
);
2512 printk(KERN_DEBUG
"Histo :");
2513 for(i
= 0; i
< wrqu
->data
.length
; i
++)
2514 printk(" %d", lp
->his_range
[i
]);
2518 /* Reset result structure. */
2519 memset(lp
->his_sum
, 0x00, sizeof(long) * 16);
2522 /* Now we can set the number of ranges */
2523 lp
->his_number
= wrqu
->data
.length
;
2528 /*------------------------------------------------------------------*/
2530 * Wireless Private Handler : get histogram
2532 static int wavelan_get_histo(struct net_device
*dev
,
2533 struct iw_request_info
*info
,
2534 union iwreq_data
*wrqu
,
2537 net_local
*lp
= netdev_priv(dev
);
2539 /* Set the number of intervals. */
2540 wrqu
->data
.length
= lp
->his_number
;
2542 /* Give back the distribution statistics */
2543 if(lp
->his_number
> 0)
2544 memcpy(extra
, lp
->his_sum
, sizeof(long) * lp
->his_number
);
2548 #endif /* HISTOGRAM */
2550 /*------------------------------------------------------------------*/
2552 * Structures to export the Wireless Handlers
2555 static const struct iw_priv_args wavelan_private_args
[] = {
2556 /*{ cmd, set_args, get_args, name } */
2557 { SIOCSIPQTHR
, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, 0, "setqualthr" },
2558 { SIOCGIPQTHR
, 0, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, "getqualthr" },
2559 { SIOCSIPROAM
, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, 0, "setroam" },
2560 { SIOCGIPROAM
, 0, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, "getroam" },
2561 { SIOCSIPHISTO
, IW_PRIV_TYPE_BYTE
| 16, 0, "sethisto" },
2562 { SIOCGIPHISTO
, 0, IW_PRIV_TYPE_INT
| 16, "gethisto" },
2565 static const iw_handler wavelan_handler
[] =
2567 NULL
, /* SIOCSIWNAME */
2568 wavelan_get_name
, /* SIOCGIWNAME */
2569 wavelan_set_nwid
, /* SIOCSIWNWID */
2570 wavelan_get_nwid
, /* SIOCGIWNWID */
2571 wavelan_set_freq
, /* SIOCSIWFREQ */
2572 wavelan_get_freq
, /* SIOCGIWFREQ */
2573 #ifdef WAVELAN_ROAMING
2574 wavelan_set_mode
, /* SIOCSIWMODE */
2575 wavelan_get_mode
, /* SIOCGIWMODE */
2576 #else /* WAVELAN_ROAMING */
2577 NULL
, /* SIOCSIWMODE */
2578 NULL
, /* SIOCGIWMODE */
2579 #endif /* WAVELAN_ROAMING */
2580 wavelan_set_sens
, /* SIOCSIWSENS */
2581 wavelan_get_sens
, /* SIOCGIWSENS */
2582 NULL
, /* SIOCSIWRANGE */
2583 wavelan_get_range
, /* SIOCGIWRANGE */
2584 NULL
, /* SIOCSIWPRIV */
2585 NULL
, /* SIOCGIWPRIV */
2586 NULL
, /* SIOCSIWSTATS */
2587 NULL
, /* SIOCGIWSTATS */
2588 iw_handler_set_spy
, /* SIOCSIWSPY */
2589 iw_handler_get_spy
, /* SIOCGIWSPY */
2590 iw_handler_set_thrspy
, /* SIOCSIWTHRSPY */
2591 iw_handler_get_thrspy
, /* SIOCGIWTHRSPY */
2592 #ifdef WAVELAN_ROAMING_EXT
2593 wavelan_set_wap
, /* SIOCSIWAP */
2594 wavelan_get_wap
, /* SIOCGIWAP */
2595 NULL
, /* -- hole -- */
2596 NULL
, /* SIOCGIWAPLIST */
2597 NULL
, /* -- hole -- */
2598 NULL
, /* -- hole -- */
2599 wavelan_set_essid
, /* SIOCSIWESSID */
2600 wavelan_get_essid
, /* SIOCGIWESSID */
2601 #else /* WAVELAN_ROAMING_EXT */
2602 NULL
, /* SIOCSIWAP */
2603 NULL
, /* SIOCGIWAP */
2604 NULL
, /* -- hole -- */
2605 NULL
, /* SIOCGIWAPLIST */
2606 NULL
, /* -- hole -- */
2607 NULL
, /* -- hole -- */
2608 NULL
, /* SIOCSIWESSID */
2609 NULL
, /* SIOCGIWESSID */
2610 #endif /* WAVELAN_ROAMING_EXT */
2611 NULL
, /* SIOCSIWNICKN */
2612 NULL
, /* SIOCGIWNICKN */
2613 NULL
, /* -- hole -- */
2614 NULL
, /* -- hole -- */
2615 NULL
, /* SIOCSIWRATE */
2616 NULL
, /* SIOCGIWRATE */
2617 NULL
, /* SIOCSIWRTS */
2618 NULL
, /* SIOCGIWRTS */
2619 NULL
, /* SIOCSIWFRAG */
2620 NULL
, /* SIOCGIWFRAG */
2621 NULL
, /* SIOCSIWTXPOW */
2622 NULL
, /* SIOCGIWTXPOW */
2623 NULL
, /* SIOCSIWRETRY */
2624 NULL
, /* SIOCGIWRETRY */
2625 wavelan_set_encode
, /* SIOCSIWENCODE */
2626 wavelan_get_encode
, /* SIOCGIWENCODE */
2629 static const iw_handler wavelan_private_handler
[] =
2631 wavelan_set_qthr
, /* SIOCIWFIRSTPRIV */
2632 wavelan_get_qthr
, /* SIOCIWFIRSTPRIV + 1 */
2633 #ifdef WAVELAN_ROAMING
2634 wavelan_set_roam
, /* SIOCIWFIRSTPRIV + 2 */
2635 wavelan_get_roam
, /* SIOCIWFIRSTPRIV + 3 */
2636 #else /* WAVELAN_ROAMING */
2637 NULL
, /* SIOCIWFIRSTPRIV + 2 */
2638 NULL
, /* SIOCIWFIRSTPRIV + 3 */
2639 #endif /* WAVELAN_ROAMING */
2641 wavelan_set_histo
, /* SIOCIWFIRSTPRIV + 4 */
2642 wavelan_get_histo
, /* SIOCIWFIRSTPRIV + 5 */
2643 #endif /* HISTOGRAM */
2646 static const struct iw_handler_def wavelan_handler_def
=
2648 .num_standard
= ARRAY_SIZE(wavelan_handler
),
2649 .num_private
= ARRAY_SIZE(wavelan_private_handler
),
2650 .num_private_args
= ARRAY_SIZE(wavelan_private_args
),
2651 .standard
= wavelan_handler
,
2652 .private = wavelan_private_handler
,
2653 .private_args
= wavelan_private_args
,
2654 .get_wireless_stats
= wavelan_get_wireless_stats
,
2657 /*------------------------------------------------------------------*/
2659 * Get wireless statistics
2660 * Called by /proc/net/wireless...
2663 wavelan_get_wireless_stats(struct net_device
* dev
)
2665 unsigned int base
= dev
->base_addr
;
2666 net_local
* lp
= netdev_priv(dev
);
2669 unsigned long flags
;
2671 #ifdef DEBUG_IOCTL_TRACE
2672 printk(KERN_DEBUG
"%s: ->wavelan_get_wireless_stats()\n", dev
->name
);
2675 /* Disable interrupts & save flags */
2676 spin_lock_irqsave(&lp
->spinlock
, flags
);
2678 wstats
= &lp
->wstats
;
2680 /* Get data from the mmc */
2681 mmc_out(base
, mmwoff(0, mmw_freeze
), 1);
2683 mmc_read(base
, mmroff(0, mmr_dce_status
), &m
.mmr_dce_status
, 1);
2684 mmc_read(base
, mmroff(0, mmr_wrong_nwid_l
), &m
.mmr_wrong_nwid_l
, 2);
2685 mmc_read(base
, mmroff(0, mmr_thr_pre_set
), &m
.mmr_thr_pre_set
, 4);
2687 mmc_out(base
, mmwoff(0, mmw_freeze
), 0);
2689 /* Copy data to wireless stuff */
2690 wstats
->status
= m
.mmr_dce_status
& MMR_DCE_STATUS
;
2691 wstats
->qual
.qual
= m
.mmr_sgnl_qual
& MMR_SGNL_QUAL
;
2692 wstats
->qual
.level
= m
.mmr_signal_lvl
& MMR_SIGNAL_LVL
;
2693 wstats
->qual
.noise
= m
.mmr_silence_lvl
& MMR_SILENCE_LVL
;
2694 wstats
->qual
.updated
= (((m
.mmr_signal_lvl
& MMR_SIGNAL_LVL_VALID
) >> 7) |
2695 ((m
.mmr_signal_lvl
& MMR_SIGNAL_LVL_VALID
) >> 6) |
2696 ((m
.mmr_silence_lvl
& MMR_SILENCE_LVL_VALID
) >> 5));
2697 wstats
->discard
.nwid
+= (m
.mmr_wrong_nwid_h
<< 8) | m
.mmr_wrong_nwid_l
;
2698 wstats
->discard
.code
= 0L;
2699 wstats
->discard
.misc
= 0L;
2701 /* ReEnable interrupts & restore flags */
2702 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2704 #ifdef DEBUG_IOCTL_TRACE
2705 printk(KERN_DEBUG
"%s: <-wavelan_get_wireless_stats()\n", dev
->name
);
2710 /************************* PACKET RECEPTION *************************/
2712 * This part deal with receiving the packets.
2713 * The interrupt handler get an interrupt when a packet has been
2714 * successfully received and called this part...
2717 /*------------------------------------------------------------------*/
2719 * Calculate the starting address of the frame pointed to by the receive
2720 * frame pointer and verify that the frame seem correct
2721 * (called by wv_packet_rcv())
2724 wv_start_of_frame(struct net_device
* dev
,
2725 int rfp
, /* end of frame */
2726 int wrap
) /* start of buffer */
2728 unsigned int base
= dev
->base_addr
;
2732 rp
= (rfp
- 5 + RX_SIZE
) % RX_SIZE
;
2733 outb(rp
& 0xff, PIORL(base
));
2734 outb(((rp
>> 8) & PIORH_MASK
), PIORH(base
));
2735 len
= inb(PIOP(base
));
2736 len
|= inb(PIOP(base
)) << 8;
2738 /* Sanity checks on size */
2740 if(len
> MAXDATAZ
+ 100)
2742 #ifdef DEBUG_RX_ERROR
2743 printk(KERN_INFO
"%s: wv_start_of_frame: Received frame too large, rfp %d len 0x%x\n",
2744 dev
->name
, rfp
, len
);
2749 /* Frame too short */
2752 #ifdef DEBUG_RX_ERROR
2753 printk(KERN_INFO
"%s: wv_start_of_frame: Received null frame, rfp %d len 0x%x\n",
2754 dev
->name
, rfp
, len
);
2759 /* Wrap around buffer */
2760 if(len
> ((wrap
- (rfp
- len
) + RX_SIZE
) % RX_SIZE
)) /* magic formula ! */
2762 #ifdef DEBUG_RX_ERROR
2763 printk(KERN_INFO
"%s: wv_start_of_frame: wrap around buffer, wrap %d rfp %d len 0x%x\n",
2764 dev
->name
, wrap
, rfp
, len
);
2769 return((rp
- len
+ RX_SIZE
) % RX_SIZE
);
2770 } /* wv_start_of_frame */
2772 /*------------------------------------------------------------------*/
2774 * This routine does the actual copy of data (including the ethernet
2775 * header structure) from the WaveLAN card to an sk_buff chain that
2776 * will be passed up to the network interface layer. NOTE: We
2777 * currently don't handle trailer protocols (neither does the rest of
2778 * the network interface), so if that is needed, it will (at least in
2779 * part) be added here. The contents of the receive ring buffer are
2780 * copied to a message chain that is then passed to the kernel.
2782 * Note: if any errors occur, the packet is "dropped on the floor"
2783 * (called by wv_packet_rcv())
2786 wv_packet_read(struct net_device
* dev
,
2790 net_local
* lp
= netdev_priv(dev
);
2791 struct sk_buff
* skb
;
2793 #ifdef DEBUG_RX_TRACE
2794 printk(KERN_DEBUG
"%s: ->wv_packet_read(0x%X, %d)\n",
2795 dev
->name
, fd_p
, sksize
);
2798 /* Allocate some buffer for the new packet */
2799 if((skb
= dev_alloc_skb(sksize
+2)) == (struct sk_buff
*) NULL
)
2801 #ifdef DEBUG_RX_ERROR
2802 printk(KERN_INFO
"%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC)\n",
2805 dev
->stats
.rx_dropped
++;
2807 * Not only do we want to return here, but we also need to drop the
2808 * packet on the floor to clear the interrupt.
2813 skb_reserve(skb
, 2);
2814 fd_p
= read_ringbuf(dev
, fd_p
, (char *) skb_put(skb
, sksize
), sksize
);
2815 skb
->protocol
= eth_type_trans(skb
, dev
);
2817 #ifdef DEBUG_RX_INFO
2818 wv_packet_info(skb_mac_header(skb
), sksize
, dev
->name
, "wv_packet_read");
2819 #endif /* DEBUG_RX_INFO */
2821 /* Statistics gathering & stuff associated.
2822 * It seem a bit messy with all the define, but it's really simple... */
2824 #ifdef IW_WIRELESS_SPY
2825 (lp
->spy_data
.spy_number
> 0) ||
2826 #endif /* IW_WIRELESS_SPY */
2828 (lp
->his_number
> 0) ||
2829 #endif /* HISTOGRAM */
2830 #ifdef WAVELAN_ROAMING
2832 #endif /* WAVELAN_ROAMING */
2835 u_char stats
[3]; /* Signal level, Noise level, Signal quality */
2837 /* read signal level, silence level and signal quality bytes */
2838 fd_p
= read_ringbuf(dev
, (fd_p
+ 4) % RX_SIZE
+ RX_BASE
,
2840 #ifdef DEBUG_RX_INFO
2841 printk(KERN_DEBUG
"%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
2842 dev
->name
, stats
[0] & 0x3F, stats
[1] & 0x3F, stats
[2] & 0x0F);
2845 #ifdef WAVELAN_ROAMING
2847 if(WAVELAN_BEACON(skb
->data
))
2848 wl_roam_gather(dev
, skb
->data
, stats
);
2849 #endif /* WAVELAN_ROAMING */
2852 wl_spy_gather(dev
, skb_mac_header(skb
) + WAVELAN_ADDR_SIZE
, stats
);
2853 #endif /* WIRELESS_SPY */
2855 wl_his_gather(dev
, stats
);
2856 #endif /* HISTOGRAM */
2860 * Hand the packet to the Network Module
2864 /* Keep stats up to date */
2865 dev
->stats
.rx_packets
++;
2866 dev
->stats
.rx_bytes
+= sksize
;
2868 #ifdef DEBUG_RX_TRACE
2869 printk(KERN_DEBUG
"%s: <-wv_packet_read()\n", dev
->name
);
2874 /*------------------------------------------------------------------*/
2876 * This routine is called by the interrupt handler to initiate a
2877 * packet transfer from the card to the network interface layer above
2878 * this driver. This routine checks if a buffer has been successfully
2879 * received by the WaveLAN card. If so, the routine wv_packet_read is
2880 * called to do the actual transfer of the card's data including the
2881 * ethernet header into a packet consisting of an sk_buff chain.
2882 * (called by wavelan_interrupt())
2883 * Note : the spinlock is already grabbed for us and irq are disabled.
2886 wv_packet_rcv(struct net_device
* dev
)
2888 unsigned int base
= dev
->base_addr
;
2889 net_local
* lp
= netdev_priv(dev
);
2899 #ifdef DEBUG_RX_TRACE
2900 printk(KERN_DEBUG
"%s: ->wv_packet_rcv()\n", dev
->name
);
2903 /* Get the new receive frame pointer from the i82593 chip */
2904 outb(CR0_STATUS_2
| OP0_NOP
, LCCR(base
));
2905 i593_rfp
= inb(LCSR(base
));
2906 i593_rfp
|= inb(LCSR(base
)) << 8;
2907 i593_rfp
%= RX_SIZE
;
2909 /* Get the new receive frame pointer from the WaveLAN card.
2910 * It is 3 bytes more than the increment of the i82593 receive
2911 * frame pointer, for each packet. This is because it includes the
2912 * 3 roaming bytes added by the mmc.
2914 newrfp
= inb(RPLL(base
));
2915 newrfp
|= inb(RPLH(base
)) << 8;
2918 #ifdef DEBUG_RX_INFO
2919 printk(KERN_DEBUG
"%s: wv_packet_rcv(): i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2920 dev
->name
, i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2923 #ifdef DEBUG_RX_ERROR
2924 /* If no new frame pointer... */
2925 if(lp
->overrunning
|| newrfp
== lp
->rfp
)
2926 printk(KERN_INFO
"%s: wv_packet_rcv(): no new frame: i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2927 dev
->name
, i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2930 /* Read all frames (packets) received */
2931 while(newrfp
!= lp
->rfp
)
2933 /* A frame is composed of the packet, followed by a status word,
2934 * the length of the frame (word) and the mmc info (SNR & qual).
2935 * It's because the length is at the end that we can only scan
2936 * frames backward. */
2938 /* Find the first frame by skipping backwards over the frames */
2939 rp
= newrfp
; /* End of last frame */
2940 while(((f_start
= wv_start_of_frame(dev
, rp
, newrfp
)) != lp
->rfp
) &&
2944 /* If we had a problem */
2947 #ifdef DEBUG_RX_ERROR
2948 printk(KERN_INFO
"wavelan_cs: cannot find start of frame ");
2949 printk(" i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2950 i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2952 lp
->rfp
= rp
; /* Get to the last usable frame */
2956 /* f_start point to the beggining of the first frame received
2957 * and rp to the beggining of the next one */
2959 /* Read status & length of the frame */
2960 stat_ptr
= (rp
- 7 + RX_SIZE
) % RX_SIZE
;
2961 stat_ptr
= read_ringbuf(dev
, stat_ptr
, c
, 4);
2962 status
= c
[0] | (c
[1] << 8);
2963 len
= c
[2] | (c
[3] << 8);
2966 if((status
& RX_RCV_OK
) != RX_RCV_OK
)
2968 dev
->stats
.rx_errors
++;
2969 if(status
& RX_NO_SFD
)
2970 dev
->stats
.rx_frame_errors
++;
2971 if(status
& RX_CRC_ERR
)
2972 dev
->stats
.rx_crc_errors
++;
2973 if(status
& RX_OVRRUN
)
2974 dev
->stats
.rx_over_errors
++;
2976 #ifdef DEBUG_RX_FAIL
2977 printk(KERN_DEBUG
"%s: wv_packet_rcv(): packet not received ok, status = 0x%x\n",
2982 /* Read the packet and transmit to Linux */
2983 wv_packet_read(dev
, f_start
, len
- 2);
2985 /* One frame has been processed, skip it */
2990 * Update the frame stop register, but set it to less than
2991 * the full 8K to allow space for 3 bytes of signal strength
2994 lp
->stop
= (i593_rfp
+ RX_SIZE
- ((RX_SIZE
/ 64) * 3)) % RX_SIZE
;
2995 outb(OP0_SWIT_TO_PORT_1
| CR0_CHNL
, LCCR(base
));
2996 outb(CR1_STOP_REG_UPDATE
| (lp
->stop
>> RX_SIZE_SHIFT
), LCCR(base
));
2997 outb(OP1_SWIT_TO_PORT_0
, LCCR(base
));
2999 #ifdef DEBUG_RX_TRACE
3000 printk(KERN_DEBUG
"%s: <-wv_packet_rcv()\n", dev
->name
);
3004 /*********************** PACKET TRANSMISSION ***********************/
3006 * This part deal with sending packet through the wavelan
3007 * We copy the packet to the send buffer and then issue the send
3008 * command to the i82593. The result of this operation will be
3009 * checked in wavelan_interrupt()
3012 /*------------------------------------------------------------------*/
3014 * This routine fills in the appropriate registers and memory
3015 * locations on the WaveLAN card and starts the card off on
3017 * (called in wavelan_packet_xmit())
3020 wv_packet_write(struct net_device
* dev
,
3024 net_local
* lp
= netdev_priv(dev
);
3025 unsigned int base
= dev
->base_addr
;
3026 unsigned long flags
;
3028 register u_short xmtdata_base
= TX_BASE
;
3030 #ifdef DEBUG_TX_TRACE
3031 printk(KERN_DEBUG
"%s: ->wv_packet_write(%d)\n", dev
->name
, length
);
3034 spin_lock_irqsave(&lp
->spinlock
, flags
);
3036 /* Write the length of data buffer followed by the buffer */
3037 outb(xmtdata_base
& 0xff, PIORL(base
));
3038 outb(((xmtdata_base
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3039 outb(clen
& 0xff, PIOP(base
)); /* lsb */
3040 outb(clen
>> 8, PIOP(base
)); /* msb */
3043 outsb(PIOP(base
), buf
, clen
);
3045 /* Indicate end of transmit chain */
3046 outb(OP0_NOP
, PIOP(base
));
3047 /* josullvn@cs.cmu.edu: need to send a second NOP for alignment... */
3048 outb(OP0_NOP
, PIOP(base
));
3050 /* Reset the transmit DMA pointer */
3051 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3052 hacr_write(base
, HACR_DEFAULT
);
3053 /* Send the transmit command */
3054 wv_82593_cmd(dev
, "wv_packet_write(): transmit",
3055 OP0_TRANSMIT
, SR0_NO_RESULT
);
3057 /* Make sure the watchdog will keep quiet for a while */
3058 dev
->trans_start
= jiffies
;
3060 /* Keep stats up to date */
3061 dev
->stats
.tx_bytes
+= length
;
3063 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3065 #ifdef DEBUG_TX_INFO
3066 wv_packet_info((u_char
*) buf
, length
, dev
->name
, "wv_packet_write");
3067 #endif /* DEBUG_TX_INFO */
3069 #ifdef DEBUG_TX_TRACE
3070 printk(KERN_DEBUG
"%s: <-wv_packet_write()\n", dev
->name
);
3074 /*------------------------------------------------------------------*/
3076 * This routine is called when we want to send a packet (NET3 callback)
3077 * In this routine, we check if the harware is ready to accept
3078 * the packet. We also prevent reentrance. Then, we call the function
3079 * to send the packet...
3082 wavelan_packet_xmit(struct sk_buff
* skb
,
3083 struct net_device
* dev
)
3085 net_local
* lp
= netdev_priv(dev
);
3086 unsigned long flags
;
3088 #ifdef DEBUG_TX_TRACE
3089 printk(KERN_DEBUG
"%s: ->wavelan_packet_xmit(0x%X)\n", dev
->name
,
3094 * Block a timer-based transmit from overlapping a previous transmit.
3095 * In other words, prevent reentering this routine.
3097 netif_stop_queue(dev
);
3099 /* If somebody has asked to reconfigure the controller,
3100 * we can do it now */
3101 if(lp
->reconfig_82593
)
3103 spin_lock_irqsave(&lp
->spinlock
, flags
); /* Disable interrupts */
3104 wv_82593_config(dev
);
3105 spin_unlock_irqrestore(&lp
->spinlock
, flags
); /* Re-enable interrupts */
3106 /* Note : the configure procedure was totally synchronous,
3107 * so the Tx buffer is now free */
3110 /* Check if we need some padding */
3111 /* Note : on wireless the propagation time is in the order of 1us,
3112 * and we don't have the Ethernet specific requirement of beeing
3113 * able to detect collisions, therefore in theory we don't really
3114 * need to pad. Jean II */
3115 if (skb_padto(skb
, ETH_ZLEN
))
3116 return NETDEV_TX_OK
;
3118 wv_packet_write(dev
, skb
->data
, skb
->len
);
3122 #ifdef DEBUG_TX_TRACE
3123 printk(KERN_DEBUG
"%s: <-wavelan_packet_xmit()\n", dev
->name
);
3125 return NETDEV_TX_OK
;
3128 /********************** HARDWARE CONFIGURATION **********************/
3130 * This part do the real job of starting and configuring the hardware.
3133 /*------------------------------------------------------------------*/
3135 * Routine to initialize the Modem Management Controller.
3136 * (called by wv_hw_config())
3139 wv_mmc_init(struct net_device
* dev
)
3141 unsigned int base
= dev
->base_addr
;
3145 int i
; /* Loop counter */
3147 #ifdef DEBUG_CONFIG_TRACE
3148 printk(KERN_DEBUG
"%s: ->wv_mmc_init()\n", dev
->name
);
3151 /* Read the parameter storage area */
3152 psa_read(dev
, 0, (unsigned char *) &psa
, sizeof(psa
));
3155 * Check the first three octets of the MAC addr for the manufacturer's code.
3156 * Note: If you get the error message below, you've got a
3157 * non-NCR/AT&T/Lucent PCMCIA cards, see wavelan_cs.h for detail on
3158 * how to configure your card...
3160 for (i
= 0; i
< ARRAY_SIZE(MAC_ADDRESSES
); i
++)
3161 if ((psa
.psa_univ_mac_addr
[0] == MAC_ADDRESSES
[i
][0]) &&
3162 (psa
.psa_univ_mac_addr
[1] == MAC_ADDRESSES
[i
][1]) &&
3163 (psa
.psa_univ_mac_addr
[2] == MAC_ADDRESSES
[i
][2]))
3166 /* If we have not found it... */
3167 if (i
== ARRAY_SIZE(MAC_ADDRESSES
))
3169 #ifdef DEBUG_CONFIG_ERRORS
3170 printk(KERN_WARNING
"%s: wv_mmc_init(): Invalid MAC address: %02X:%02X:%02X:...\n",
3171 dev
->name
, psa
.psa_univ_mac_addr
[0],
3172 psa
.psa_univ_mac_addr
[1], psa
.psa_univ_mac_addr
[2]);
3177 /* Get the MAC address */
3178 memcpy(&dev
->dev_addr
[0], &psa
.psa_univ_mac_addr
[0], WAVELAN_ADDR_SIZE
);
3180 #ifdef USE_PSA_CONFIG
3181 configured
= psa
.psa_conf_status
& 1;
3186 /* Is the PSA is not configured */
3189 /* User will be able to configure NWID after (with iwconfig) */
3190 psa
.psa_nwid
[0] = 0;
3191 psa
.psa_nwid
[1] = 0;
3193 /* As NWID is not set : no NWID checking */
3194 psa
.psa_nwid_select
= 0;
3196 /* Disable encryption */
3197 psa
.psa_encryption_select
= 0;
3199 /* Set to standard values
3202 * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document)
3204 if (psa
.psa_comp_number
& 1)
3205 psa
.psa_thr_pre_set
= 0x01;
3207 psa
.psa_thr_pre_set
= 0x04;
3208 psa
.psa_quality_thr
= 0x03;
3210 /* It is configured */
3211 psa
.psa_conf_status
|= 1;
3213 #ifdef USE_PSA_CONFIG
3215 psa_write(dev
, (char *)psa
.psa_nwid
- (char *)&psa
,
3216 (unsigned char *)psa
.psa_nwid
, 4);
3217 psa_write(dev
, (char *)&psa
.psa_thr_pre_set
- (char *)&psa
,
3218 (unsigned char *)&psa
.psa_thr_pre_set
, 1);
3219 psa_write(dev
, (char *)&psa
.psa_quality_thr
- (char *)&psa
,
3220 (unsigned char *)&psa
.psa_quality_thr
, 1);
3221 psa_write(dev
, (char *)&psa
.psa_conf_status
- (char *)&psa
,
3222 (unsigned char *)&psa
.psa_conf_status
, 1);
3223 /* update the Wavelan checksum */
3224 update_psa_checksum(dev
);
3225 #endif /* USE_PSA_CONFIG */
3228 /* Zero the mmc structure */
3229 memset(&m
, 0x00, sizeof(m
));
3231 /* Copy PSA info to the mmc */
3232 m
.mmw_netw_id_l
= psa
.psa_nwid
[1];
3233 m
.mmw_netw_id_h
= psa
.psa_nwid
[0];
3235 if(psa
.psa_nwid_select
& 1)
3236 m
.mmw_loopt_sel
= 0x00;
3238 m
.mmw_loopt_sel
= MMW_LOOPT_SEL_DIS_NWID
;
3240 memcpy(&m
.mmw_encr_key
, &psa
.psa_encryption_key
,
3241 sizeof(m
.mmw_encr_key
));
3243 if(psa
.psa_encryption_select
)
3244 m
.mmw_encr_enable
= MMW_ENCR_ENABLE_EN
| MMW_ENCR_ENABLE_MODE
;
3246 m
.mmw_encr_enable
= 0;
3248 m
.mmw_thr_pre_set
= psa
.psa_thr_pre_set
& 0x3F;
3249 m
.mmw_quality_thr
= psa
.psa_quality_thr
& 0x0F;
3252 * Set default modem control parameters.
3253 * See NCR document 407-0024326 Rev. A.
3255 m
.mmw_jabber_enable
= 0x01;
3256 m
.mmw_anten_sel
= MMW_ANTEN_SEL_ALG_EN
;
3258 m
.mmw_mod_delay
= 0x04;
3259 m
.mmw_jam_time
= 0x38;
3261 m
.mmw_des_io_invert
= 0;
3263 m
.mmw_decay_prm
= 0;
3264 m
.mmw_decay_updat_prm
= 0;
3266 /* Write all info to mmc */
3267 mmc_write(base
, 0, (u_char
*)&m
, sizeof(m
));
3269 /* The following code start the modem of the 2.00 frequency
3270 * selectable cards at power on. It's not strictly needed for the
3271 * following boots...
3272 * The original patch was by Joe Finney for the PCMCIA driver, but
3273 * I've cleaned it a bit and add documentation.
3274 * Thanks to Loeke Brederveld from Lucent for the info.
3277 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
3278 * (does it work for everybody ? - especially old cards...) */
3279 /* Note : WFREQSEL verify that it is able to read from EEprom
3280 * a sensible frequency (address 0x00) + that MMR_FEE_STATUS_ID
3281 * is 0xA (Xilinx version) or 0xB (Ariadne version).
3282 * My test is more crude but do work... */
3283 if(!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
3284 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
)))
3286 /* We must download the frequency parameters to the
3287 * synthetisers (from the EEprom - area 1)
3288 * Note : as the EEprom is auto decremented, we set the end
3290 m
.mmw_fee_addr
= 0x0F;
3291 m
.mmw_fee_ctrl
= MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
;
3292 mmc_write(base
, (char *)&m
.mmw_fee_ctrl
- (char *)&m
,
3293 (unsigned char *)&m
.mmw_fee_ctrl
, 2);
3295 /* Wait until the download is finished */
3296 fee_wait(base
, 100, 100);
3298 #ifdef DEBUG_CONFIG_INFO
3299 /* The frequency was in the last word downloaded... */
3300 mmc_read(base
, (char *)&m
.mmw_fee_data_l
- (char *)&m
,
3301 (unsigned char *)&m
.mmw_fee_data_l
, 2);
3303 /* Print some info for the user */
3304 printk(KERN_DEBUG
"%s: Wavelan 2.00 recognised (frequency select) : Current frequency = %ld\n",
3306 ((m
.mmw_fee_data_h
<< 4) |
3307 (m
.mmw_fee_data_l
>> 4)) * 5 / 2 + 24000L);
3310 /* We must now download the power adjust value (gain) to
3311 * the synthetisers (from the EEprom - area 7 - DAC) */
3312 m
.mmw_fee_addr
= 0x61;
3313 m
.mmw_fee_ctrl
= MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
;
3314 mmc_write(base
, (char *)&m
.mmw_fee_ctrl
- (char *)&m
,
3315 (unsigned char *)&m
.mmw_fee_ctrl
, 2);
3317 /* Wait until the download is finished */
3318 } /* if 2.00 card */
3320 #ifdef DEBUG_CONFIG_TRACE
3321 printk(KERN_DEBUG
"%s: <-wv_mmc_init()\n", dev
->name
);
3326 /*------------------------------------------------------------------*/
3328 * Routine to gracefully turn off reception, and wait for any commands
3330 * (called in wv_ru_start() and wavelan_close() and wavelan_event())
3333 wv_ru_stop(struct net_device
* dev
)
3335 unsigned int base
= dev
->base_addr
;
3336 net_local
* lp
= netdev_priv(dev
);
3337 unsigned long flags
;
3341 #ifdef DEBUG_CONFIG_TRACE
3342 printk(KERN_DEBUG
"%s: ->wv_ru_stop()\n", dev
->name
);
3345 spin_lock_irqsave(&lp
->spinlock
, flags
);
3347 /* First, send the LAN controller a stop receive command */
3348 wv_82593_cmd(dev
, "wv_graceful_shutdown(): stop-rcv",
3349 OP0_STOP_RCV
, SR0_NO_RESULT
);
3351 /* Then, spin until the receive unit goes idle */
3356 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3357 status
= inb(LCSR(base
));
3359 while(((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_IDLE
) && (spin
-- > 0));
3361 /* Now, spin until the chip finishes executing its current command */
3365 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3366 status
= inb(LCSR(base
));
3368 while(((status
& SR3_EXEC_STATE_MASK
) != SR3_EXEC_IDLE
) && (spin
-- > 0));
3370 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3372 /* If there was a problem */
3375 #ifdef DEBUG_CONFIG_ERRORS
3376 printk(KERN_INFO
"%s: wv_ru_stop(): The chip doesn't want to stop...\n",
3382 #ifdef DEBUG_CONFIG_TRACE
3383 printk(KERN_DEBUG
"%s: <-wv_ru_stop()\n", dev
->name
);
3388 /*------------------------------------------------------------------*/
3390 * This routine starts the receive unit running. First, it checks if
3391 * the card is actually ready. Then the card is instructed to receive
3393 * (called in wv_hw_reset() & wavelan_open())
3396 wv_ru_start(struct net_device
* dev
)
3398 unsigned int base
= dev
->base_addr
;
3399 net_local
* lp
= netdev_priv(dev
);
3400 unsigned long flags
;
3402 #ifdef DEBUG_CONFIG_TRACE
3403 printk(KERN_DEBUG
"%s: ->wv_ru_start()\n", dev
->name
);
3407 * We need to start from a quiescent state. To do so, we could check
3408 * if the card is already running, but instead we just try to shut
3409 * it down. First, we disable reception (in case it was already enabled).
3411 if(!wv_ru_stop(dev
))
3414 spin_lock_irqsave(&lp
->spinlock
, flags
);
3416 /* Now we know that no command is being executed. */
3418 /* Set the receive frame pointer and stop pointer */
3420 outb(OP0_SWIT_TO_PORT_1
| CR0_CHNL
, LCCR(base
));
3422 /* Reset ring management. This sets the receive frame pointer to 1 */
3423 outb(OP1_RESET_RING_MNGMT
, LCCR(base
));
3426 /* XXX the i82593 manual page 6-4 seems to indicate that the stop register
3427 should be set as below */
3428 /* outb(CR1_STOP_REG_UPDATE|((RX_SIZE - 0x40)>> RX_SIZE_SHIFT),LCCR(base));*/
3430 /* but I set it 0 instead */
3433 /* but I set it to 3 bytes per packet less than 8K */
3434 lp
->stop
= (0 + RX_SIZE
- ((RX_SIZE
/ 64) * 3)) % RX_SIZE
;
3436 outb(CR1_STOP_REG_UPDATE
| (lp
->stop
>> RX_SIZE_SHIFT
), LCCR(base
));
3437 outb(OP1_INT_ENABLE
, LCCR(base
));
3438 outb(OP1_SWIT_TO_PORT_0
, LCCR(base
));
3440 /* Reset receive DMA pointer */
3441 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3442 hacr_write_slow(base
, HACR_DEFAULT
);
3444 /* Receive DMA on channel 1 */
3445 wv_82593_cmd(dev
, "wv_ru_start(): rcv-enable",
3446 CR0_CHNL
| OP0_RCV_ENABLE
, SR0_NO_RESULT
);
3448 #ifdef DEBUG_I82593_SHOW
3454 /* spin until the chip starts receiving */
3457 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3458 status
= inb(LCSR(base
));
3462 while(((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_ACTIVE
) &&
3463 ((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_READY
));
3464 printk(KERN_DEBUG
"rcv status is 0x%x [i:%d]\n",
3465 (status
& SR3_RCV_STATE_MASK
), i
);
3469 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3471 #ifdef DEBUG_CONFIG_TRACE
3472 printk(KERN_DEBUG
"%s: <-wv_ru_start()\n", dev
->name
);
3477 /*------------------------------------------------------------------*/
3479 * This routine does a standard config of the WaveLAN controller (i82593).
3480 * In the ISA driver, this is integrated in wavelan_hardware_reset()
3481 * (called by wv_hw_config(), wv_82593_reconfig() & wavelan_packet_xmit())
3484 wv_82593_config(struct net_device
* dev
)
3486 unsigned int base
= dev
->base_addr
;
3487 net_local
* lp
= netdev_priv(dev
);
3488 struct i82593_conf_block cfblk
;
3491 #ifdef DEBUG_CONFIG_TRACE
3492 printk(KERN_DEBUG
"%s: ->wv_82593_config()\n", dev
->name
);
3495 /* Create & fill i82593 config block
3497 * Now conform to Wavelan document WCIN085B
3499 memset(&cfblk
, 0x00, sizeof(struct i82593_conf_block
));
3500 cfblk
.d6mod
= FALSE
; /* Run in i82593 advanced mode */
3501 cfblk
.fifo_limit
= 5; /* = 56 B rx and 40 B tx fifo thresholds */
3502 cfblk
.forgnesi
= FALSE
; /* 0=82C501, 1=AMD7992B compatibility */
3504 cfblk
.throttle_enb
= FALSE
;
3505 cfblk
.contin
= TRUE
; /* enable continuous mode */
3506 cfblk
.cntrxint
= FALSE
; /* enable continuous mode receive interrupts */
3507 cfblk
.addr_len
= WAVELAN_ADDR_SIZE
;
3508 cfblk
.acloc
= TRUE
; /* Disable source addr insertion by i82593 */
3509 cfblk
.preamb_len
= 0; /* 2 bytes preamble (SFD) */
3510 cfblk
.loopback
= FALSE
;
3511 cfblk
.lin_prio
= 0; /* conform to 802.3 backoff algorithm */
3512 cfblk
.exp_prio
= 5; /* conform to 802.3 backoff algorithm */
3513 cfblk
.bof_met
= 1; /* conform to 802.3 backoff algorithm */
3514 cfblk
.ifrm_spc
= 0x20 >> 4; /* 32 bit times interframe spacing */
3515 cfblk
.slottim_low
= 0x20 >> 5; /* 32 bit times slot time */
3516 cfblk
.slottim_hi
= 0x0;
3517 cfblk
.max_retr
= 15;
3518 cfblk
.prmisc
= ((lp
->promiscuous
) ? TRUE
: FALSE
); /* Promiscuous mode */
3519 cfblk
.bc_dis
= FALSE
; /* Enable broadcast reception */
3520 cfblk
.crs_1
= TRUE
; /* Transmit without carrier sense */
3521 cfblk
.nocrc_ins
= FALSE
; /* i82593 generates CRC */
3522 cfblk
.crc_1632
= FALSE
; /* 32-bit Autodin-II CRC */
3523 cfblk
.crs_cdt
= FALSE
; /* CD not to be interpreted as CS */
3524 cfblk
.cs_filter
= 0; /* CS is recognized immediately */
3525 cfblk
.crs_src
= FALSE
; /* External carrier sense */
3526 cfblk
.cd_filter
= 0; /* CD is recognized immediately */
3527 cfblk
.min_fr_len
= ETH_ZLEN
>> 2; /* Minimum frame length 64 bytes */
3528 cfblk
.lng_typ
= FALSE
; /* Length field > 1500 = type field */
3529 cfblk
.lng_fld
= TRUE
; /* Disable 802.3 length field check */
3530 cfblk
.rxcrc_xf
= TRUE
; /* Don't transfer CRC to memory */
3531 cfblk
.artx
= TRUE
; /* Disable automatic retransmission */
3532 cfblk
.sarec
= TRUE
; /* Disable source addr trig of CD */
3533 cfblk
.tx_jabber
= TRUE
; /* Disable jabber jam sequence */
3534 cfblk
.hash_1
= FALSE
; /* Use bits 0-5 in mc address hash */
3535 cfblk
.lbpkpol
= TRUE
; /* Loopback pin active high */
3536 cfblk
.fdx
= FALSE
; /* Disable full duplex operation */
3537 cfblk
.dummy_6
= 0x3f; /* all ones */
3538 cfblk
.mult_ia
= FALSE
; /* No multiple individual addresses */
3539 cfblk
.dis_bof
= FALSE
; /* Disable the backoff algorithm ?! */
3540 cfblk
.dummy_1
= TRUE
; /* set to 1 */
3541 cfblk
.tx_ifs_retrig
= 3; /* Hmm... Disabled */
3542 #ifdef MULTICAST_ALL
3543 cfblk
.mc_all
= (lp
->allmulticast
? TRUE
: FALSE
); /* Allow all multicasts */
3545 cfblk
.mc_all
= FALSE
; /* No multicast all mode */
3547 cfblk
.rcv_mon
= 0; /* Monitor mode disabled */
3548 cfblk
.frag_acpt
= TRUE
; /* Do not accept fragments */
3549 cfblk
.tstrttrs
= FALSE
; /* No start transmission threshold */
3550 cfblk
.fretx
= TRUE
; /* FIFO automatic retransmission */
3551 cfblk
.syncrqs
= FALSE
; /* Synchronous DRQ deassertion... */
3552 cfblk
.sttlen
= TRUE
; /* 6 byte status registers */
3553 cfblk
.rx_eop
= TRUE
; /* Signal EOP on packet reception */
3554 cfblk
.tx_eop
= TRUE
; /* Signal EOP on packet transmission */
3555 cfblk
.rbuf_size
= RX_SIZE
>>11; /* Set receive buffer size */
3556 cfblk
.rcvstop
= TRUE
; /* Enable Receive Stop Register */
3558 #ifdef DEBUG_I82593_SHOW
3559 print_hex_dump(KERN_DEBUG
, "wavelan_cs: config block: ", DUMP_PREFIX_NONE
,
3560 16, 1, &cfblk
, sizeof(struct i82593_conf_block
), false);
3563 /* Copy the config block to the i82593 */
3564 outb(TX_BASE
& 0xff, PIORL(base
));
3565 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3566 outb(sizeof(struct i82593_conf_block
) & 0xff, PIOP(base
)); /* lsb */
3567 outb(sizeof(struct i82593_conf_block
) >> 8, PIOP(base
)); /* msb */
3568 outsb(PIOP(base
), (char *) &cfblk
, sizeof(struct i82593_conf_block
));
3570 /* reset transmit DMA pointer */
3571 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3572 hacr_write(base
, HACR_DEFAULT
);
3573 if(!wv_82593_cmd(dev
, "wv_82593_config(): configure",
3574 OP0_CONFIGURE
, SR0_CONFIGURE_DONE
))
3577 /* Initialize adapter's ethernet MAC address */
3578 outb(TX_BASE
& 0xff, PIORL(base
));
3579 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3580 outb(WAVELAN_ADDR_SIZE
, PIOP(base
)); /* byte count lsb */
3581 outb(0, PIOP(base
)); /* byte count msb */
3582 outsb(PIOP(base
), &dev
->dev_addr
[0], WAVELAN_ADDR_SIZE
);
3584 /* reset transmit DMA pointer */
3585 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3586 hacr_write(base
, HACR_DEFAULT
);
3587 if(!wv_82593_cmd(dev
, "wv_82593_config(): ia-setup",
3588 OP0_IA_SETUP
, SR0_IA_SETUP_DONE
))
3591 #ifdef WAVELAN_ROAMING
3592 /* If roaming is enabled, join the "Beacon Request" multicast group... */
3593 /* But only if it's not in there already! */
3595 dev_mc_add(dev
,WAVELAN_BEACON_ADDRESS
, WAVELAN_ADDR_SIZE
, 1);
3596 #endif /* WAVELAN_ROAMING */
3598 /* If any multicast address to set */
3601 struct dev_mc_list
* dmi
;
3602 int addrs_len
= WAVELAN_ADDR_SIZE
* lp
->mc_count
;
3604 #ifdef DEBUG_CONFIG_INFO
3605 printk(KERN_DEBUG
"%s: wv_hw_config(): set %d multicast addresses:\n",
3606 dev
->name
, lp
->mc_count
);
3607 for(dmi
=dev
->mc_list
; dmi
; dmi
=dmi
->next
)
3608 printk(KERN_DEBUG
" %pM\n", dmi
->dmi_addr
);
3611 /* Initialize adapter's ethernet multicast addresses */
3612 outb(TX_BASE
& 0xff, PIORL(base
));
3613 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3614 outb(addrs_len
& 0xff, PIOP(base
)); /* byte count lsb */
3615 outb((addrs_len
>> 8), PIOP(base
)); /* byte count msb */
3616 for(dmi
=dev
->mc_list
; dmi
; dmi
=dmi
->next
)
3617 outsb(PIOP(base
), dmi
->dmi_addr
, dmi
->dmi_addrlen
);
3619 /* reset transmit DMA pointer */
3620 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3621 hacr_write(base
, HACR_DEFAULT
);
3622 if(!wv_82593_cmd(dev
, "wv_82593_config(): mc-setup",
3623 OP0_MC_SETUP
, SR0_MC_SETUP_DONE
))
3625 lp
->mc_count
= dev
->mc_count
; /* remember to avoid repeated reset */
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
, &handle_to_dev(link
));
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 concurently.
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
| IRQ_HANDLE_PRESENT
;
4442 p_dev
->irq
.IRQInfo1
= IRQ_LEVEL_ID
;
4443 p_dev
->irq
.Handler
= wavelan_interrupt
;
4445 /* General socket configuration */
4446 p_dev
->conf
.Attributes
= CONF_ENABLE_IRQ
;
4447 p_dev
->conf
.IntType
= INT_MEMORY_AND_IO
;
4449 /* Allocate the generic data structure */
4450 dev
= alloc_etherdev(sizeof(net_local
));
4454 p_dev
->priv
= p_dev
->irq
.Instance
= dev
;
4456 lp
= netdev_priv(dev
);
4458 /* Init specific data */
4460 lp
->reconfig_82593
= FALSE
;
4462 /* Multicast stuff */
4463 lp
->promiscuous
= 0;
4464 lp
->allmulticast
= 0;
4468 spin_lock_init(&lp
->spinlock
);
4473 /* wavelan NET3 callbacks */
4474 dev
->netdev_ops
= &wavelan_netdev_ops
;
4475 dev
->watchdog_timeo
= WATCHDOG_JIFFIES
;
4476 SET_ETHTOOL_OPS(dev
, &ops
);
4478 dev
->wireless_handlers
= &wavelan_handler_def
;
4479 lp
->wireless_data
.spy_data
= &lp
->spy_data
;
4480 dev
->wireless_data
= &lp
->wireless_data
;
4482 /* Other specific data */
4483 dev
->mtu
= WAVELAN_MTU
;
4485 ret
= wv_pcmcia_config(p_dev
);
4489 ret
= wv_hw_config(dev
);
4492 pcmcia_disable_device(p_dev
);
4498 #ifdef DEBUG_CALLBACK_TRACE
4499 printk(KERN_DEBUG
"<- wavelan_attach()\n");
4505 /*------------------------------------------------------------------*/
4507 * This deletes a driver "instance". The device is de-registered with
4508 * Card Services. If it has been released, all local data structures
4509 * are freed. Otherwise, the structures will be freed when the device
4513 wavelan_detach(struct pcmcia_device
*link
)
4515 #ifdef DEBUG_CALLBACK_TRACE
4516 printk(KERN_DEBUG
"-> wavelan_detach(0x%p)\n", link
);
4519 /* Some others haven't done their job : give them another chance */
4520 wv_pcmcia_release(link
);
4525 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4527 /* Remove ourselves from the kernel list of ethernet devices */
4528 /* Warning : can't be called from interrupt, timer or wavelan_close() */
4530 unregister_netdev(dev
);
4531 link
->dev_node
= NULL
;
4532 ((net_local
*)netdev_priv(dev
))->link
= NULL
;
4533 ((net_local
*)netdev_priv(dev
))->dev
= NULL
;
4537 #ifdef DEBUG_CALLBACK_TRACE
4538 printk(KERN_DEBUG
"<- wavelan_detach()\n");
4542 static int wavelan_suspend(struct pcmcia_device
*link
)
4544 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4546 /* NB: wavelan_close will be called, but too late, so we are
4547 * obliged to close nicely the wavelan here. David, could you
4548 * close the device before suspending them ? And, by the way,
4549 * could you, on resume, add a "route add -net ..." after the
4550 * ifconfig up ? Thanks... */
4552 /* Stop receiving new messages and wait end of transmission */
4556 netif_device_detach(dev
);
4558 /* Power down the module */
4559 hacr_write(dev
->base_addr
, HACR_DEFAULT
& (~HACR_PWR_STAT
));
4564 static int wavelan_resume(struct pcmcia_device
*link
)
4566 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4570 netif_device_attach(dev
);
4577 static struct pcmcia_device_id wavelan_ids
[] = {
4578 PCMCIA_DEVICE_PROD_ID12("AT&T","WaveLAN/PCMCIA", 0xe7c5affd, 0x1bc50975),
4579 PCMCIA_DEVICE_PROD_ID12("Digital", "RoamAbout/DS", 0x9999ab35, 0x00d05e06),
4580 PCMCIA_DEVICE_PROD_ID12("Lucent Technologies", "WaveLAN/PCMCIA", 0x23eb9949, 0x1bc50975),
4581 PCMCIA_DEVICE_PROD_ID12("NCR", "WaveLAN/PCMCIA", 0x24358cd4, 0x1bc50975),
4584 MODULE_DEVICE_TABLE(pcmcia
, wavelan_ids
);
4586 static struct pcmcia_driver wavelan_driver
= {
4587 .owner
= THIS_MODULE
,
4589 .name
= "wavelan_cs",
4591 .probe
= wavelan_probe
,
4592 .remove
= wavelan_detach
,
4593 .id_table
= wavelan_ids
,
4594 .suspend
= wavelan_suspend
,
4595 .resume
= wavelan_resume
,
4599 init_wavelan_cs(void)
4601 return pcmcia_register_driver(&wavelan_driver
);
4605 exit_wavelan_cs(void)
4607 pcmcia_unregister_driver(&wavelan_driver
);
4610 module_init(init_wavelan_cs
);
4611 module_exit(exit_wavelan_cs
);