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 Paramter 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
1355 /*------------------------------------------------------------------*/
1357 * Get the current ethernet statistics. This may be called with the
1358 * card open or closed.
1359 * Used when the user read /proc/net/dev
1362 wavelan_get_stats(struct net_device
* dev
)
1364 #ifdef DEBUG_IOCTL_TRACE
1365 printk(KERN_DEBUG
"%s: <>wavelan_get_stats()\n", dev
->name
);
1368 return(&((net_local
*)netdev_priv(dev
))->stats
);
1371 /*------------------------------------------------------------------*/
1373 * Set or clear the multicast filter for this adaptor.
1374 * num_addrs == -1 Promiscuous mode, receive all packets
1375 * num_addrs == 0 Normal mode, clear multicast list
1376 * num_addrs > 0 Multicast mode, receive normal and MC packets,
1377 * and do best-effort filtering.
1381 wavelan_set_multicast_list(struct net_device
* dev
)
1383 net_local
* lp
= netdev_priv(dev
);
1385 #ifdef DEBUG_IOCTL_TRACE
1386 printk(KERN_DEBUG
"%s: ->wavelan_set_multicast_list()\n", dev
->name
);
1389 #ifdef DEBUG_IOCTL_INFO
1390 printk(KERN_DEBUG
"%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n",
1391 dev
->name
, dev
->flags
, dev
->mc_count
);
1394 if(dev
->flags
& IFF_PROMISC
)
1397 * Enable promiscuous mode: receive all packets.
1399 if(!lp
->promiscuous
)
1401 lp
->promiscuous
= 1;
1402 lp
->allmulticast
= 0;
1405 wv_82593_reconfig(dev
);
1409 /* If all multicast addresses
1410 * or too much multicast addresses for the hardware filter */
1411 if((dev
->flags
& IFF_ALLMULTI
) ||
1412 (dev
->mc_count
> I82593_MAX_MULTICAST_ADDRESSES
))
1415 * Disable promiscuous mode, but active the all multicast mode
1417 if(!lp
->allmulticast
)
1419 lp
->promiscuous
= 0;
1420 lp
->allmulticast
= 1;
1423 wv_82593_reconfig(dev
);
1427 /* If there is some multicast addresses to send */
1428 if(dev
->mc_list
!= (struct dev_mc_list
*) NULL
)
1431 * Disable promiscuous mode, but receive all packets
1434 #ifdef MULTICAST_AVOID
1435 if(lp
->promiscuous
|| lp
->allmulticast
||
1436 (dev
->mc_count
!= lp
->mc_count
))
1439 lp
->promiscuous
= 0;
1440 lp
->allmulticast
= 0;
1441 lp
->mc_count
= dev
->mc_count
;
1443 wv_82593_reconfig(dev
);
1449 * Switch to normal mode: disable promiscuous mode and
1450 * clear the multicast list.
1452 if(lp
->promiscuous
|| lp
->mc_count
== 0)
1454 lp
->promiscuous
= 0;
1455 lp
->allmulticast
= 0;
1458 wv_82593_reconfig(dev
);
1461 #ifdef DEBUG_IOCTL_TRACE
1462 printk(KERN_DEBUG
"%s: <-wavelan_set_multicast_list()\n", dev
->name
);
1466 /*------------------------------------------------------------------*/
1468 * This function doesn't exist...
1469 * (Note : it was a nice way to test the reconfigure stuff...)
1471 #ifdef SET_MAC_ADDRESS
1473 wavelan_set_mac_address(struct net_device
* dev
,
1476 struct sockaddr
* mac
= addr
;
1478 /* Copy the address */
1479 memcpy(dev
->dev_addr
, mac
->sa_data
, WAVELAN_ADDR_SIZE
);
1481 /* Reconfig the beast */
1482 wv_82593_reconfig(dev
);
1486 #endif /* SET_MAC_ADDRESS */
1489 /*------------------------------------------------------------------*/
1491 * Frequency setting (for hardware able of it)
1492 * It's a bit complicated and you don't really want to look into it...
1495 wv_set_frequency(u_long base
, /* i/o port of the card */
1496 iw_freq
* frequency
)
1498 const int BAND_NUM
= 10; /* Number of bands */
1499 long freq
= 0L; /* offset to 2.4 GHz in .5 MHz */
1500 #ifdef DEBUG_IOCTL_INFO
1504 /* Setting by frequency */
1505 /* Theoritically, you may set any frequency between
1506 * the two limits with a 0.5 MHz precision. In practice,
1507 * I don't want you to have trouble with local
1509 if((frequency
->e
== 1) &&
1510 (frequency
->m
>= (int) 2.412e8
) && (frequency
->m
<= (int) 2.487e8
))
1512 freq
= ((frequency
->m
/ 10000) - 24000L) / 5;
1515 /* Setting by channel (same as wfreqsel) */
1516 /* Warning : each channel is 22MHz wide, so some of the channels
1517 * will interfere... */
1518 if((frequency
->e
== 0) &&
1519 (frequency
->m
>= 0) && (frequency
->m
< BAND_NUM
))
1521 /* Get frequency offset. */
1522 freq
= channel_bands
[frequency
->m
] >> 1;
1525 /* Verify if the frequency is allowed */
1528 u_short table
[10]; /* Authorized frequency table */
1530 /* Read the frequency table */
1531 fee_read(base
, 0x71 /* frequency table */,
1534 #ifdef DEBUG_IOCTL_INFO
1535 printk(KERN_DEBUG
"Frequency table :");
1536 for(i
= 0; i
< 10; i
++)
1544 /* Look in the table if the frequency is allowed */
1545 if(!(table
[9 - ((freq
- 24) / 16)] &
1546 (1 << ((freq
- 24) % 16))))
1547 return -EINVAL
; /* not allowed */
1552 /* If we get a usable frequency */
1555 unsigned short area
[16];
1556 unsigned short dac
[2];
1557 unsigned short area_verify
[16];
1558 unsigned short dac_verify
[2];
1559 /* Corresponding gain (in the power adjust value table)
1560 * see AT&T Wavelan Data Manual, REF 407-024689/E, page 3-8
1561 * & WCIN062D.DOC, page 6.2.9 */
1562 unsigned short power_limit
[] = { 40, 80, 120, 160, 0 };
1563 int power_band
= 0; /* Selected band */
1564 unsigned short power_adjust
; /* Correct value */
1566 /* Search for the gain */
1568 while((freq
> power_limit
[power_band
]) &&
1569 (power_limit
[++power_band
] != 0))
1572 /* Read the first area */
1573 fee_read(base
, 0x00,
1577 fee_read(base
, 0x60,
1580 /* Read the new power adjust value */
1581 fee_read(base
, 0x6B - (power_band
>> 1),
1583 if(power_band
& 0x1)
1586 power_adjust
&= 0xFF;
1588 #ifdef DEBUG_IOCTL_INFO
1589 printk(KERN_DEBUG
"Wavelan EEprom Area 1 :");
1590 for(i
= 0; i
< 16; i
++)
1597 printk(KERN_DEBUG
"Wavelan EEprom DAC : %04X %04X\n",
1601 /* Frequency offset (for info only...) */
1602 area
[0] = ((freq
<< 5) & 0xFFE0) | (area
[0] & 0x1F);
1604 /* Receiver Principle main divider coefficient */
1605 area
[3] = (freq
>> 1) + 2400L - 352L;
1606 area
[2] = ((freq
& 0x1) << 4) | (area
[2] & 0xFFEF);
1608 /* Transmitter Main divider coefficient */
1609 area
[13] = (freq
>> 1) + 2400L;
1610 area
[12] = ((freq
& 0x1) << 4) | (area
[2] & 0xFFEF);
1612 /* Others part of the area are flags, bit streams or unused... */
1614 /* Set the value in the DAC */
1615 dac
[1] = ((power_adjust
>> 1) & 0x7F) | (dac
[1] & 0xFF80);
1616 dac
[0] = ((power_adjust
& 0x1) << 4) | (dac
[0] & 0xFFEF);
1618 /* Write the first area */
1619 fee_write(base
, 0x00,
1623 fee_write(base
, 0x60,
1626 /* We now should verify here that the EEprom writing was ok */
1628 /* ReRead the first area */
1629 fee_read(base
, 0x00,
1632 /* ReRead the DAC */
1633 fee_read(base
, 0x60,
1637 if(memcmp(area
, area_verify
, 16 * 2) ||
1638 memcmp(dac
, dac_verify
, 2 * 2))
1640 #ifdef DEBUG_IOCTL_ERROR
1641 printk(KERN_INFO
"Wavelan: wv_set_frequency : unable to write new frequency to EEprom (?)\n");
1646 /* We must download the frequency parameters to the
1647 * synthetisers (from the EEprom - area 1)
1648 * Note : as the EEprom is auto decremented, we set the end
1650 mmc_out(base
, mmwoff(0, mmw_fee_addr
), 0x0F);
1651 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
),
1652 MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
);
1654 /* Wait until the download is finished */
1655 fee_wait(base
, 100, 100);
1657 /* We must now download the power adjust value (gain) to
1658 * the synthetisers (from the EEprom - area 7 - DAC) */
1659 mmc_out(base
, mmwoff(0, mmw_fee_addr
), 0x61);
1660 mmc_out(base
, mmwoff(0, mmw_fee_ctrl
),
1661 MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
);
1663 /* Wait until the download is finished */
1664 fee_wait(base
, 100, 100);
1666 #ifdef DEBUG_IOCTL_INFO
1667 /* Verification of what we have done... */
1669 printk(KERN_DEBUG
"Wavelan EEprom Area 1 :");
1670 for(i
= 0; i
< 16; i
++)
1677 printk(KERN_DEBUG
"Wavelan EEprom DAC : %04X %04X\n",
1678 dac_verify
[0], dac_verify
[1]);
1684 return -EINVAL
; /* Bah, never get there... */
1687 /*------------------------------------------------------------------*/
1689 * Give the list of available frequencies
1692 wv_frequency_list(u_long base
, /* i/o port of the card */
1693 iw_freq
* list
, /* List of frequency to fill */
1694 int max
) /* Maximum number of frequencies */
1696 u_short table
[10]; /* Authorized frequency table */
1697 long freq
= 0L; /* offset to 2.4 GHz in .5 MHz + 12 MHz */
1698 int i
; /* index in the table */
1699 const int BAND_NUM
= 10; /* Number of bands */
1700 int c
= 0; /* Channel number */
1702 /* Read the frequency table */
1703 fee_read(base
, 0x71 /* frequency table */,
1706 /* Look all frequencies */
1708 for(freq
= 0; freq
< 150; freq
++)
1709 /* Look in the table if the frequency is allowed */
1710 if(table
[9 - (freq
/ 16)] & (1 << (freq
% 16)))
1712 /* Compute approximate channel number */
1713 while((((channel_bands
[c
] >> 1) - 24) < freq
) &&
1716 list
[i
].i
= c
; /* Set the list index */
1718 /* put in the list */
1719 list
[i
].m
= (((freq
+ 24) * 5) + 24000L) * 10000;
1730 #ifdef IW_WIRELESS_SPY
1731 /*------------------------------------------------------------------*/
1733 * Gather wireless spy statistics : for each packet, compare the source
1734 * address with out list, and if match, get the stats...
1735 * Sorry, but this function really need wireless extensions...
1738 wl_spy_gather(struct net_device
* dev
,
1739 u_char
* mac
, /* MAC address */
1740 u_char
* stats
) /* Statistics to gather */
1742 struct iw_quality wstats
;
1744 wstats
.qual
= stats
[2] & MMR_SGNL_QUAL
;
1745 wstats
.level
= stats
[0] & MMR_SIGNAL_LVL
;
1746 wstats
.noise
= stats
[1] & MMR_SILENCE_LVL
;
1747 wstats
.updated
= 0x7;
1749 /* Update spy records */
1750 wireless_spy_update(dev
, mac
, &wstats
);
1752 #endif /* IW_WIRELESS_SPY */
1755 /*------------------------------------------------------------------*/
1757 * This function calculate an histogram on the signal level.
1758 * As the noise is quite constant, it's like doing it on the SNR.
1759 * We have defined a set of interval (lp->his_range), and each time
1760 * the level goes in that interval, we increment the count (lp->his_sum).
1761 * With this histogram you may detect if one wavelan is really weak,
1762 * or you may also calculate the mean and standard deviation of the level...
1765 wl_his_gather(struct net_device
* dev
,
1766 u_char
* stats
) /* Statistics to gather */
1768 net_local
* lp
= netdev_priv(dev
);
1769 u_char level
= stats
[0] & MMR_SIGNAL_LVL
;
1772 /* Find the correct interval */
1774 while((i
< (lp
->his_number
- 1)) && (level
>= lp
->his_range
[i
++]))
1777 /* Increment interval counter */
1780 #endif /* HISTOGRAM */
1782 static void wl_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
1784 strncpy(info
->driver
, "wavelan_cs", sizeof(info
->driver
)-1);
1787 static const struct ethtool_ops ops
= {
1788 .get_drvinfo
= wl_get_drvinfo
1791 /*------------------------------------------------------------------*/
1793 * Wireless Handler : get protocol name
1795 static int wavelan_get_name(struct net_device
*dev
,
1796 struct iw_request_info
*info
,
1797 union iwreq_data
*wrqu
,
1800 strcpy(wrqu
->name
, "WaveLAN");
1804 /*------------------------------------------------------------------*/
1806 * Wireless Handler : set NWID
1808 static int wavelan_set_nwid(struct net_device
*dev
,
1809 struct iw_request_info
*info
,
1810 union iwreq_data
*wrqu
,
1813 unsigned int base
= dev
->base_addr
;
1814 net_local
*lp
= netdev_priv(dev
);
1817 unsigned long flags
;
1820 /* Disable interrupts and save flags. */
1821 spin_lock_irqsave(&lp
->spinlock
, flags
);
1823 /* Set NWID in WaveLAN. */
1824 if (!wrqu
->nwid
.disabled
) {
1825 /* Set NWID in psa */
1826 psa
.psa_nwid
[0] = (wrqu
->nwid
.value
& 0xFF00) >> 8;
1827 psa
.psa_nwid
[1] = wrqu
->nwid
.value
& 0xFF;
1828 psa
.psa_nwid_select
= 0x01;
1830 (char *) psa
.psa_nwid
- (char *) &psa
,
1831 (unsigned char *) psa
.psa_nwid
, 3);
1833 /* Set NWID in mmc. */
1834 m
.w
.mmw_netw_id_l
= psa
.psa_nwid
[1];
1835 m
.w
.mmw_netw_id_h
= psa
.psa_nwid
[0];
1837 (char *) &m
.w
.mmw_netw_id_l
-
1839 (unsigned char *) &m
.w
.mmw_netw_id_l
, 2);
1840 mmc_out(base
, mmwoff(0, mmw_loopt_sel
), 0x00);
1842 /* Disable NWID in the psa. */
1843 psa
.psa_nwid_select
= 0x00;
1845 (char *) &psa
.psa_nwid_select
-
1847 (unsigned char *) &psa
.psa_nwid_select
,
1850 /* Disable NWID in the mmc (no filtering). */
1851 mmc_out(base
, mmwoff(0, mmw_loopt_sel
),
1852 MMW_LOOPT_SEL_DIS_NWID
);
1854 /* update the Wavelan checksum */
1855 update_psa_checksum(dev
);
1857 /* Enable interrupts and restore flags. */
1858 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1863 /*------------------------------------------------------------------*/
1865 * Wireless Handler : get NWID
1867 static int wavelan_get_nwid(struct net_device
*dev
,
1868 struct iw_request_info
*info
,
1869 union iwreq_data
*wrqu
,
1872 net_local
*lp
= netdev_priv(dev
);
1874 unsigned long flags
;
1877 /* Disable interrupts and save flags. */
1878 spin_lock_irqsave(&lp
->spinlock
, flags
);
1880 /* Read the NWID. */
1882 (char *) psa
.psa_nwid
- (char *) &psa
,
1883 (unsigned char *) psa
.psa_nwid
, 3);
1884 wrqu
->nwid
.value
= (psa
.psa_nwid
[0] << 8) + psa
.psa_nwid
[1];
1885 wrqu
->nwid
.disabled
= !(psa
.psa_nwid_select
);
1886 wrqu
->nwid
.fixed
= 1; /* Superfluous */
1888 /* Enable interrupts and restore flags. */
1889 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1894 /*------------------------------------------------------------------*/
1896 * Wireless Handler : set frequency
1898 static int wavelan_set_freq(struct net_device
*dev
,
1899 struct iw_request_info
*info
,
1900 union iwreq_data
*wrqu
,
1903 unsigned int base
= dev
->base_addr
;
1904 net_local
*lp
= netdev_priv(dev
);
1905 unsigned long flags
;
1908 /* Disable interrupts and save flags. */
1909 spin_lock_irqsave(&lp
->spinlock
, flags
);
1911 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
1912 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
1913 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
)))
1914 ret
= wv_set_frequency(base
, &(wrqu
->freq
));
1918 /* Enable interrupts and restore flags. */
1919 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1924 /*------------------------------------------------------------------*/
1926 * Wireless Handler : get frequency
1928 static int wavelan_get_freq(struct net_device
*dev
,
1929 struct iw_request_info
*info
,
1930 union iwreq_data
*wrqu
,
1933 unsigned int base
= dev
->base_addr
;
1934 net_local
*lp
= netdev_priv(dev
);
1936 unsigned long flags
;
1939 /* Disable interrupts and save flags. */
1940 spin_lock_irqsave(&lp
->spinlock
, flags
);
1942 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable).
1943 * Does it work for everybody, especially old cards? */
1944 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
1945 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
))) {
1946 unsigned short freq
;
1948 /* Ask the EEPROM to read the frequency from the first area. */
1949 fee_read(base
, 0x00, &freq
, 1);
1950 wrqu
->freq
.m
= ((freq
>> 5) * 5 + 24000L) * 10000;
1954 (char *) &psa
.psa_subband
- (char *) &psa
,
1955 (unsigned char *) &psa
.psa_subband
, 1);
1957 if (psa
.psa_subband
<= 4) {
1958 wrqu
->freq
.m
= fixed_bands
[psa
.psa_subband
];
1959 wrqu
->freq
.e
= (psa
.psa_subband
!= 0);
1964 /* Enable interrupts and restore flags. */
1965 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
1970 /*------------------------------------------------------------------*/
1972 * Wireless Handler : set level threshold
1974 static int wavelan_set_sens(struct net_device
*dev
,
1975 struct iw_request_info
*info
,
1976 union iwreq_data
*wrqu
,
1979 unsigned int base
= dev
->base_addr
;
1980 net_local
*lp
= netdev_priv(dev
);
1982 unsigned long flags
;
1985 /* Disable interrupts and save flags. */
1986 spin_lock_irqsave(&lp
->spinlock
, flags
);
1988 /* Set the level threshold. */
1989 /* We should complain loudly if wrqu->sens.fixed = 0, because we
1990 * can't set auto mode... */
1991 psa
.psa_thr_pre_set
= wrqu
->sens
.value
& 0x3F;
1993 (char *) &psa
.psa_thr_pre_set
- (char *) &psa
,
1994 (unsigned char *) &psa
.psa_thr_pre_set
, 1);
1995 /* update the Wavelan checksum */
1996 update_psa_checksum(dev
);
1997 mmc_out(base
, mmwoff(0, mmw_thr_pre_set
),
1998 psa
.psa_thr_pre_set
);
2000 /* Enable interrupts and restore flags. */
2001 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2006 /*------------------------------------------------------------------*/
2008 * Wireless Handler : get level threshold
2010 static int wavelan_get_sens(struct net_device
*dev
,
2011 struct iw_request_info
*info
,
2012 union iwreq_data
*wrqu
,
2015 net_local
*lp
= netdev_priv(dev
);
2017 unsigned long flags
;
2020 /* Disable interrupts and save flags. */
2021 spin_lock_irqsave(&lp
->spinlock
, flags
);
2023 /* Read the level threshold. */
2025 (char *) &psa
.psa_thr_pre_set
- (char *) &psa
,
2026 (unsigned char *) &psa
.psa_thr_pre_set
, 1);
2027 wrqu
->sens
.value
= psa
.psa_thr_pre_set
& 0x3F;
2028 wrqu
->sens
.fixed
= 1;
2030 /* Enable interrupts and restore flags. */
2031 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2036 /*------------------------------------------------------------------*/
2038 * Wireless Handler : set encryption key
2040 static int wavelan_set_encode(struct net_device
*dev
,
2041 struct iw_request_info
*info
,
2042 union iwreq_data
*wrqu
,
2045 unsigned int base
= dev
->base_addr
;
2046 net_local
*lp
= netdev_priv(dev
);
2047 unsigned long flags
;
2051 /* Disable interrupts and save flags. */
2052 spin_lock_irqsave(&lp
->spinlock
, flags
);
2054 /* Check if capable of encryption */
2055 if (!mmc_encr(base
)) {
2059 /* Check the size of the key */
2060 if((wrqu
->encoding
.length
!= 8) && (wrqu
->encoding
.length
!= 0)) {
2065 /* Basic checking... */
2066 if (wrqu
->encoding
.length
== 8) {
2067 /* Copy the key in the driver */
2068 memcpy(psa
.psa_encryption_key
, extra
,
2069 wrqu
->encoding
.length
);
2070 psa
.psa_encryption_select
= 1;
2073 (char *) &psa
.psa_encryption_select
-
2075 (unsigned char *) &psa
.
2076 psa_encryption_select
, 8 + 1);
2078 mmc_out(base
, mmwoff(0, mmw_encr_enable
),
2079 MMW_ENCR_ENABLE_EN
| MMW_ENCR_ENABLE_MODE
);
2080 mmc_write(base
, mmwoff(0, mmw_encr_key
),
2081 (unsigned char *) &psa
.
2082 psa_encryption_key
, 8);
2085 /* disable encryption */
2086 if (wrqu
->encoding
.flags
& IW_ENCODE_DISABLED
) {
2087 psa
.psa_encryption_select
= 0;
2089 (char *) &psa
.psa_encryption_select
-
2091 (unsigned char *) &psa
.
2092 psa_encryption_select
, 1);
2094 mmc_out(base
, mmwoff(0, mmw_encr_enable
), 0);
2096 /* update the Wavelan checksum */
2097 update_psa_checksum(dev
);
2100 /* Enable interrupts and restore flags. */
2101 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2106 /*------------------------------------------------------------------*/
2108 * Wireless Handler : get encryption key
2110 static int wavelan_get_encode(struct net_device
*dev
,
2111 struct iw_request_info
*info
,
2112 union iwreq_data
*wrqu
,
2115 unsigned int base
= dev
->base_addr
;
2116 net_local
*lp
= netdev_priv(dev
);
2118 unsigned long flags
;
2121 /* Disable interrupts and save flags. */
2122 spin_lock_irqsave(&lp
->spinlock
, flags
);
2124 /* Check if encryption is available */
2125 if (!mmc_encr(base
)) {
2128 /* Read the encryption key */
2130 (char *) &psa
.psa_encryption_select
-
2132 (unsigned char *) &psa
.
2133 psa_encryption_select
, 1 + 8);
2135 /* encryption is enabled ? */
2136 if (psa
.psa_encryption_select
)
2137 wrqu
->encoding
.flags
= IW_ENCODE_ENABLED
;
2139 wrqu
->encoding
.flags
= IW_ENCODE_DISABLED
;
2140 wrqu
->encoding
.flags
|= mmc_encr(base
);
2142 /* Copy the key to the user buffer */
2143 wrqu
->encoding
.length
= 8;
2144 memcpy(extra
, psa
.psa_encryption_key
, wrqu
->encoding
.length
);
2147 /* Enable interrupts and restore flags. */
2148 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2153 #ifdef WAVELAN_ROAMING_EXT
2154 /*------------------------------------------------------------------*/
2156 * Wireless Handler : set ESSID (domain)
2158 static int wavelan_set_essid(struct net_device
*dev
,
2159 struct iw_request_info
*info
,
2160 union iwreq_data
*wrqu
,
2163 net_local
*lp
= netdev_priv(dev
);
2164 unsigned long flags
;
2167 /* Disable interrupts and save flags. */
2168 spin_lock_irqsave(&lp
->spinlock
, flags
);
2170 /* Check if disable */
2171 if(wrqu
->data
.flags
== 0)
2172 lp
->filter_domains
= 0;
2174 char essid
[IW_ESSID_MAX_SIZE
+ 1];
2177 /* Terminate the string */
2178 memcpy(essid
, extra
, wrqu
->data
.length
);
2179 essid
[IW_ESSID_MAX_SIZE
] = '\0';
2181 #ifdef DEBUG_IOCTL_INFO
2182 printk(KERN_DEBUG
"SetEssid : ``%s''\n", essid
);
2183 #endif /* DEBUG_IOCTL_INFO */
2185 /* Convert to a number (note : Wavelan specific) */
2186 lp
->domain_id
= simple_strtoul(essid
, &endp
, 16);
2187 /* Has it worked ? */
2189 lp
->filter_domains
= 1;
2191 lp
->filter_domains
= 0;
2196 /* Enable interrupts and restore flags. */
2197 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2202 /*------------------------------------------------------------------*/
2204 * Wireless Handler : get ESSID (domain)
2206 static int wavelan_get_essid(struct net_device
*dev
,
2207 struct iw_request_info
*info
,
2208 union iwreq_data
*wrqu
,
2211 net_local
*lp
= netdev_priv(dev
);
2213 /* Is the domain ID active ? */
2214 wrqu
->data
.flags
= lp
->filter_domains
;
2216 /* Copy Domain ID into a string (Wavelan specific) */
2217 /* Sound crazy, be we can't have a snprintf in the kernel !!! */
2218 sprintf(extra
, "%lX", lp
->domain_id
);
2219 extra
[IW_ESSID_MAX_SIZE
] = '\0';
2221 /* Set the length */
2222 wrqu
->data
.length
= strlen(extra
);
2227 /*------------------------------------------------------------------*/
2229 * Wireless Handler : set AP address
2231 static int wavelan_set_wap(struct net_device
*dev
,
2232 struct iw_request_info
*info
,
2233 union iwreq_data
*wrqu
,
2236 #ifdef DEBUG_IOCTL_INFO
2237 printk(KERN_DEBUG
"Set AP to : %pM\n", wrqu
->ap_addr
.sa_data
);
2238 #endif /* DEBUG_IOCTL_INFO */
2243 /*------------------------------------------------------------------*/
2245 * Wireless Handler : get AP address
2247 static int wavelan_get_wap(struct net_device
*dev
,
2248 struct iw_request_info
*info
,
2249 union iwreq_data
*wrqu
,
2252 /* Should get the real McCoy instead of own Ethernet address */
2253 memcpy(wrqu
->ap_addr
.sa_data
, dev
->dev_addr
, WAVELAN_ADDR_SIZE
);
2254 wrqu
->ap_addr
.sa_family
= ARPHRD_ETHER
;
2258 #endif /* WAVELAN_ROAMING_EXT */
2260 #ifdef WAVELAN_ROAMING
2261 /*------------------------------------------------------------------*/
2263 * Wireless Handler : set mode
2265 static int wavelan_set_mode(struct net_device
*dev
,
2266 struct iw_request_info
*info
,
2267 union iwreq_data
*wrqu
,
2270 net_local
*lp
= netdev_priv(dev
);
2271 unsigned long flags
;
2274 /* Disable interrupts and save flags. */
2275 spin_lock_irqsave(&lp
->spinlock
, flags
);
2278 switch(wrqu
->mode
) {
2281 wv_roam_cleanup(dev
);
2295 /* Enable interrupts and restore flags. */
2296 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2301 /*------------------------------------------------------------------*/
2303 * Wireless Handler : get mode
2305 static int wavelan_get_mode(struct net_device
*dev
,
2306 struct iw_request_info
*info
,
2307 union iwreq_data
*wrqu
,
2311 wrqu
->mode
= IW_MODE_INFRA
;
2313 wrqu
->mode
= IW_MODE_ADHOC
;
2317 #endif /* WAVELAN_ROAMING */
2319 /*------------------------------------------------------------------*/
2321 * Wireless Handler : get range info
2323 static int wavelan_get_range(struct net_device
*dev
,
2324 struct iw_request_info
*info
,
2325 union iwreq_data
*wrqu
,
2328 unsigned int base
= dev
->base_addr
;
2329 net_local
*lp
= netdev_priv(dev
);
2330 struct iw_range
*range
= (struct iw_range
*) extra
;
2331 unsigned long flags
;
2334 /* Set the length (very important for backward compatibility) */
2335 wrqu
->data
.length
= sizeof(struct iw_range
);
2337 /* Set all the info we don't care or don't know about to zero */
2338 memset(range
, 0, sizeof(struct iw_range
));
2340 /* Set the Wireless Extension versions */
2341 range
->we_version_compiled
= WIRELESS_EXT
;
2342 range
->we_version_source
= 9;
2344 /* Set information in the range struct. */
2345 range
->throughput
= 1.4 * 1000 * 1000; /* don't argue on this ! */
2346 range
->min_nwid
= 0x0000;
2347 range
->max_nwid
= 0xFFFF;
2349 range
->sensitivity
= 0x3F;
2350 range
->max_qual
.qual
= MMR_SGNL_QUAL
;
2351 range
->max_qual
.level
= MMR_SIGNAL_LVL
;
2352 range
->max_qual
.noise
= MMR_SILENCE_LVL
;
2353 range
->avg_qual
.qual
= MMR_SGNL_QUAL
; /* Always max */
2354 /* Need to get better values for those two */
2355 range
->avg_qual
.level
= 30;
2356 range
->avg_qual
.noise
= 8;
2358 range
->num_bitrates
= 1;
2359 range
->bitrate
[0] = 2000000; /* 2 Mb/s */
2361 /* Event capability (kernel + driver) */
2362 range
->event_capa
[0] = (IW_EVENT_CAPA_MASK(0x8B02) |
2363 IW_EVENT_CAPA_MASK(0x8B04) |
2364 IW_EVENT_CAPA_MASK(0x8B06));
2365 range
->event_capa
[1] = IW_EVENT_CAPA_K_1
;
2367 /* Disable interrupts and save flags. */
2368 spin_lock_irqsave(&lp
->spinlock
, flags
);
2370 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */
2371 if (!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
2372 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
))) {
2373 range
->num_channels
= 10;
2374 range
->num_frequency
= wv_frequency_list(base
, range
->freq
,
2375 IW_MAX_FREQUENCIES
);
2377 range
->num_channels
= range
->num_frequency
= 0;
2379 /* Encryption supported ? */
2380 if (mmc_encr(base
)) {
2381 range
->encoding_size
[0] = 8; /* DES = 64 bits key */
2382 range
->num_encoding_sizes
= 1;
2383 range
->max_encoding_tokens
= 1; /* Only one key possible */
2385 range
->num_encoding_sizes
= 0;
2386 range
->max_encoding_tokens
= 0;
2389 /* Enable interrupts and restore flags. */
2390 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2395 /*------------------------------------------------------------------*/
2397 * Wireless Private Handler : set quality threshold
2399 static int wavelan_set_qthr(struct net_device
*dev
,
2400 struct iw_request_info
*info
,
2401 union iwreq_data
*wrqu
,
2404 unsigned int base
= dev
->base_addr
;
2405 net_local
*lp
= netdev_priv(dev
);
2407 unsigned long flags
;
2409 /* Disable interrupts and save flags. */
2410 spin_lock_irqsave(&lp
->spinlock
, flags
);
2412 psa
.psa_quality_thr
= *(extra
) & 0x0F;
2414 (char *) &psa
.psa_quality_thr
- (char *) &psa
,
2415 (unsigned char *) &psa
.psa_quality_thr
, 1);
2416 /* update the Wavelan checksum */
2417 update_psa_checksum(dev
);
2418 mmc_out(base
, mmwoff(0, mmw_quality_thr
),
2419 psa
.psa_quality_thr
);
2421 /* Enable interrupts and restore flags. */
2422 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2427 /*------------------------------------------------------------------*/
2429 * Wireless Private Handler : get quality threshold
2431 static int wavelan_get_qthr(struct net_device
*dev
,
2432 struct iw_request_info
*info
,
2433 union iwreq_data
*wrqu
,
2436 net_local
*lp
= netdev_priv(dev
);
2438 unsigned long flags
;
2440 /* Disable interrupts and save flags. */
2441 spin_lock_irqsave(&lp
->spinlock
, flags
);
2444 (char *) &psa
.psa_quality_thr
- (char *) &psa
,
2445 (unsigned char *) &psa
.psa_quality_thr
, 1);
2446 *(extra
) = psa
.psa_quality_thr
& 0x0F;
2448 /* Enable interrupts and restore flags. */
2449 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2454 #ifdef WAVELAN_ROAMING
2455 /*------------------------------------------------------------------*/
2457 * Wireless Private Handler : set roaming
2459 static int wavelan_set_roam(struct net_device
*dev
,
2460 struct iw_request_info
*info
,
2461 union iwreq_data
*wrqu
,
2464 net_local
*lp
= netdev_priv(dev
);
2465 unsigned long flags
;
2467 /* Disable interrupts and save flags. */
2468 spin_lock_irqsave(&lp
->spinlock
, flags
);
2470 /* Note : should check if user == root */
2471 if(do_roaming
&& (*extra
)==0)
2472 wv_roam_cleanup(dev
);
2473 else if(do_roaming
==0 && (*extra
)!=0)
2476 do_roaming
= (*extra
);
2478 /* Enable interrupts and restore flags. */
2479 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2484 /*------------------------------------------------------------------*/
2486 * Wireless Private Handler : get quality threshold
2488 static int wavelan_get_roam(struct net_device
*dev
,
2489 struct iw_request_info
*info
,
2490 union iwreq_data
*wrqu
,
2493 *(extra
) = do_roaming
;
2497 #endif /* WAVELAN_ROAMING */
2500 /*------------------------------------------------------------------*/
2502 * Wireless Private Handler : set histogram
2504 static int wavelan_set_histo(struct net_device
*dev
,
2505 struct iw_request_info
*info
,
2506 union iwreq_data
*wrqu
,
2509 net_local
*lp
= netdev_priv(dev
);
2511 /* Check the number of intervals. */
2512 if (wrqu
->data
.length
> 16) {
2516 /* Disable histo while we copy the addresses.
2517 * As we don't disable interrupts, we need to do this */
2520 /* Are there ranges to copy? */
2521 if (wrqu
->data
.length
> 0) {
2522 /* Copy interval ranges to the driver */
2523 memcpy(lp
->his_range
, extra
, wrqu
->data
.length
);
2527 printk(KERN_DEBUG
"Histo :");
2528 for(i
= 0; i
< wrqu
->data
.length
; i
++)
2529 printk(" %d", lp
->his_range
[i
]);
2533 /* Reset result structure. */
2534 memset(lp
->his_sum
, 0x00, sizeof(long) * 16);
2537 /* Now we can set the number of ranges */
2538 lp
->his_number
= wrqu
->data
.length
;
2543 /*------------------------------------------------------------------*/
2545 * Wireless Private Handler : get histogram
2547 static int wavelan_get_histo(struct net_device
*dev
,
2548 struct iw_request_info
*info
,
2549 union iwreq_data
*wrqu
,
2552 net_local
*lp
= netdev_priv(dev
);
2554 /* Set the number of intervals. */
2555 wrqu
->data
.length
= lp
->his_number
;
2557 /* Give back the distribution statistics */
2558 if(lp
->his_number
> 0)
2559 memcpy(extra
, lp
->his_sum
, sizeof(long) * lp
->his_number
);
2563 #endif /* HISTOGRAM */
2565 /*------------------------------------------------------------------*/
2567 * Structures to export the Wireless Handlers
2570 static const struct iw_priv_args wavelan_private_args
[] = {
2571 /*{ cmd, set_args, get_args, name } */
2572 { SIOCSIPQTHR
, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, 0, "setqualthr" },
2573 { SIOCGIPQTHR
, 0, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, "getqualthr" },
2574 { SIOCSIPROAM
, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, 0, "setroam" },
2575 { SIOCGIPROAM
, 0, IW_PRIV_TYPE_BYTE
| IW_PRIV_SIZE_FIXED
| 1, "getroam" },
2576 { SIOCSIPHISTO
, IW_PRIV_TYPE_BYTE
| 16, 0, "sethisto" },
2577 { SIOCGIPHISTO
, 0, IW_PRIV_TYPE_INT
| 16, "gethisto" },
2580 static const iw_handler wavelan_handler
[] =
2582 NULL
, /* SIOCSIWNAME */
2583 wavelan_get_name
, /* SIOCGIWNAME */
2584 wavelan_set_nwid
, /* SIOCSIWNWID */
2585 wavelan_get_nwid
, /* SIOCGIWNWID */
2586 wavelan_set_freq
, /* SIOCSIWFREQ */
2587 wavelan_get_freq
, /* SIOCGIWFREQ */
2588 #ifdef WAVELAN_ROAMING
2589 wavelan_set_mode
, /* SIOCSIWMODE */
2590 wavelan_get_mode
, /* SIOCGIWMODE */
2591 #else /* WAVELAN_ROAMING */
2592 NULL
, /* SIOCSIWMODE */
2593 NULL
, /* SIOCGIWMODE */
2594 #endif /* WAVELAN_ROAMING */
2595 wavelan_set_sens
, /* SIOCSIWSENS */
2596 wavelan_get_sens
, /* SIOCGIWSENS */
2597 NULL
, /* SIOCSIWRANGE */
2598 wavelan_get_range
, /* SIOCGIWRANGE */
2599 NULL
, /* SIOCSIWPRIV */
2600 NULL
, /* SIOCGIWPRIV */
2601 NULL
, /* SIOCSIWSTATS */
2602 NULL
, /* SIOCGIWSTATS */
2603 iw_handler_set_spy
, /* SIOCSIWSPY */
2604 iw_handler_get_spy
, /* SIOCGIWSPY */
2605 iw_handler_set_thrspy
, /* SIOCSIWTHRSPY */
2606 iw_handler_get_thrspy
, /* SIOCGIWTHRSPY */
2607 #ifdef WAVELAN_ROAMING_EXT
2608 wavelan_set_wap
, /* SIOCSIWAP */
2609 wavelan_get_wap
, /* SIOCGIWAP */
2610 NULL
, /* -- hole -- */
2611 NULL
, /* SIOCGIWAPLIST */
2612 NULL
, /* -- hole -- */
2613 NULL
, /* -- hole -- */
2614 wavelan_set_essid
, /* SIOCSIWESSID */
2615 wavelan_get_essid
, /* SIOCGIWESSID */
2616 #else /* WAVELAN_ROAMING_EXT */
2617 NULL
, /* SIOCSIWAP */
2618 NULL
, /* SIOCGIWAP */
2619 NULL
, /* -- hole -- */
2620 NULL
, /* SIOCGIWAPLIST */
2621 NULL
, /* -- hole -- */
2622 NULL
, /* -- hole -- */
2623 NULL
, /* SIOCSIWESSID */
2624 NULL
, /* SIOCGIWESSID */
2625 #endif /* WAVELAN_ROAMING_EXT */
2626 NULL
, /* SIOCSIWNICKN */
2627 NULL
, /* SIOCGIWNICKN */
2628 NULL
, /* -- hole -- */
2629 NULL
, /* -- hole -- */
2630 NULL
, /* SIOCSIWRATE */
2631 NULL
, /* SIOCGIWRATE */
2632 NULL
, /* SIOCSIWRTS */
2633 NULL
, /* SIOCGIWRTS */
2634 NULL
, /* SIOCSIWFRAG */
2635 NULL
, /* SIOCGIWFRAG */
2636 NULL
, /* SIOCSIWTXPOW */
2637 NULL
, /* SIOCGIWTXPOW */
2638 NULL
, /* SIOCSIWRETRY */
2639 NULL
, /* SIOCGIWRETRY */
2640 wavelan_set_encode
, /* SIOCSIWENCODE */
2641 wavelan_get_encode
, /* SIOCGIWENCODE */
2644 static const iw_handler wavelan_private_handler
[] =
2646 wavelan_set_qthr
, /* SIOCIWFIRSTPRIV */
2647 wavelan_get_qthr
, /* SIOCIWFIRSTPRIV + 1 */
2648 #ifdef WAVELAN_ROAMING
2649 wavelan_set_roam
, /* SIOCIWFIRSTPRIV + 2 */
2650 wavelan_get_roam
, /* SIOCIWFIRSTPRIV + 3 */
2651 #else /* WAVELAN_ROAMING */
2652 NULL
, /* SIOCIWFIRSTPRIV + 2 */
2653 NULL
, /* SIOCIWFIRSTPRIV + 3 */
2654 #endif /* WAVELAN_ROAMING */
2656 wavelan_set_histo
, /* SIOCIWFIRSTPRIV + 4 */
2657 wavelan_get_histo
, /* SIOCIWFIRSTPRIV + 5 */
2658 #endif /* HISTOGRAM */
2661 static const struct iw_handler_def wavelan_handler_def
=
2663 .num_standard
= ARRAY_SIZE(wavelan_handler
),
2664 .num_private
= ARRAY_SIZE(wavelan_private_handler
),
2665 .num_private_args
= ARRAY_SIZE(wavelan_private_args
),
2666 .standard
= wavelan_handler
,
2667 .private = wavelan_private_handler
,
2668 .private_args
= wavelan_private_args
,
2669 .get_wireless_stats
= wavelan_get_wireless_stats
,
2672 /*------------------------------------------------------------------*/
2674 * Get wireless statistics
2675 * Called by /proc/net/wireless...
2678 wavelan_get_wireless_stats(struct net_device
* dev
)
2680 unsigned int base
= dev
->base_addr
;
2681 net_local
* lp
= netdev_priv(dev
);
2684 unsigned long flags
;
2686 #ifdef DEBUG_IOCTL_TRACE
2687 printk(KERN_DEBUG
"%s: ->wavelan_get_wireless_stats()\n", dev
->name
);
2690 /* Disable interrupts & save flags */
2691 spin_lock_irqsave(&lp
->spinlock
, flags
);
2693 wstats
= &lp
->wstats
;
2695 /* Get data from the mmc */
2696 mmc_out(base
, mmwoff(0, mmw_freeze
), 1);
2698 mmc_read(base
, mmroff(0, mmr_dce_status
), &m
.mmr_dce_status
, 1);
2699 mmc_read(base
, mmroff(0, mmr_wrong_nwid_l
), &m
.mmr_wrong_nwid_l
, 2);
2700 mmc_read(base
, mmroff(0, mmr_thr_pre_set
), &m
.mmr_thr_pre_set
, 4);
2702 mmc_out(base
, mmwoff(0, mmw_freeze
), 0);
2704 /* Copy data to wireless stuff */
2705 wstats
->status
= m
.mmr_dce_status
& MMR_DCE_STATUS
;
2706 wstats
->qual
.qual
= m
.mmr_sgnl_qual
& MMR_SGNL_QUAL
;
2707 wstats
->qual
.level
= m
.mmr_signal_lvl
& MMR_SIGNAL_LVL
;
2708 wstats
->qual
.noise
= m
.mmr_silence_lvl
& MMR_SILENCE_LVL
;
2709 wstats
->qual
.updated
= (((m
.mmr_signal_lvl
& MMR_SIGNAL_LVL_VALID
) >> 7) |
2710 ((m
.mmr_signal_lvl
& MMR_SIGNAL_LVL_VALID
) >> 6) |
2711 ((m
.mmr_silence_lvl
& MMR_SILENCE_LVL_VALID
) >> 5));
2712 wstats
->discard
.nwid
+= (m
.mmr_wrong_nwid_h
<< 8) | m
.mmr_wrong_nwid_l
;
2713 wstats
->discard
.code
= 0L;
2714 wstats
->discard
.misc
= 0L;
2716 /* ReEnable interrupts & restore flags */
2717 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
2719 #ifdef DEBUG_IOCTL_TRACE
2720 printk(KERN_DEBUG
"%s: <-wavelan_get_wireless_stats()\n", dev
->name
);
2725 /************************* PACKET RECEPTION *************************/
2727 * This part deal with receiving the packets.
2728 * The interrupt handler get an interrupt when a packet has been
2729 * successfully received and called this part...
2732 /*------------------------------------------------------------------*/
2734 * Calculate the starting address of the frame pointed to by the receive
2735 * frame pointer and verify that the frame seem correct
2736 * (called by wv_packet_rcv())
2739 wv_start_of_frame(struct net_device
* dev
,
2740 int rfp
, /* end of frame */
2741 int wrap
) /* start of buffer */
2743 unsigned int base
= dev
->base_addr
;
2747 rp
= (rfp
- 5 + RX_SIZE
) % RX_SIZE
;
2748 outb(rp
& 0xff, PIORL(base
));
2749 outb(((rp
>> 8) & PIORH_MASK
), PIORH(base
));
2750 len
= inb(PIOP(base
));
2751 len
|= inb(PIOP(base
)) << 8;
2753 /* Sanity checks on size */
2755 if(len
> MAXDATAZ
+ 100)
2757 #ifdef DEBUG_RX_ERROR
2758 printk(KERN_INFO
"%s: wv_start_of_frame: Received frame too large, rfp %d len 0x%x\n",
2759 dev
->name
, rfp
, len
);
2764 /* Frame too short */
2767 #ifdef DEBUG_RX_ERROR
2768 printk(KERN_INFO
"%s: wv_start_of_frame: Received null frame, rfp %d len 0x%x\n",
2769 dev
->name
, rfp
, len
);
2774 /* Wrap around buffer */
2775 if(len
> ((wrap
- (rfp
- len
) + RX_SIZE
) % RX_SIZE
)) /* magic formula ! */
2777 #ifdef DEBUG_RX_ERROR
2778 printk(KERN_INFO
"%s: wv_start_of_frame: wrap around buffer, wrap %d rfp %d len 0x%x\n",
2779 dev
->name
, wrap
, rfp
, len
);
2784 return((rp
- len
+ RX_SIZE
) % RX_SIZE
);
2785 } /* wv_start_of_frame */
2787 /*------------------------------------------------------------------*/
2789 * This routine does the actual copy of data (including the ethernet
2790 * header structure) from the WaveLAN card to an sk_buff chain that
2791 * will be passed up to the network interface layer. NOTE: We
2792 * currently don't handle trailer protocols (neither does the rest of
2793 * the network interface), so if that is needed, it will (at least in
2794 * part) be added here. The contents of the receive ring buffer are
2795 * copied to a message chain that is then passed to the kernel.
2797 * Note: if any errors occur, the packet is "dropped on the floor"
2798 * (called by wv_packet_rcv())
2801 wv_packet_read(struct net_device
* dev
,
2805 net_local
* lp
= netdev_priv(dev
);
2806 struct sk_buff
* skb
;
2808 #ifdef DEBUG_RX_TRACE
2809 printk(KERN_DEBUG
"%s: ->wv_packet_read(0x%X, %d)\n",
2810 dev
->name
, fd_p
, sksize
);
2813 /* Allocate some buffer for the new packet */
2814 if((skb
= dev_alloc_skb(sksize
+2)) == (struct sk_buff
*) NULL
)
2816 #ifdef DEBUG_RX_ERROR
2817 printk(KERN_INFO
"%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC)\n",
2820 lp
->stats
.rx_dropped
++;
2822 * Not only do we want to return here, but we also need to drop the
2823 * packet on the floor to clear the interrupt.
2828 skb_reserve(skb
, 2);
2829 fd_p
= read_ringbuf(dev
, fd_p
, (char *) skb_put(skb
, sksize
), sksize
);
2830 skb
->protocol
= eth_type_trans(skb
, dev
);
2832 #ifdef DEBUG_RX_INFO
2833 wv_packet_info(skb_mac_header(skb
), sksize
, dev
->name
, "wv_packet_read");
2834 #endif /* DEBUG_RX_INFO */
2836 /* Statistics gathering & stuff associated.
2837 * It seem a bit messy with all the define, but it's really simple... */
2839 #ifdef IW_WIRELESS_SPY
2840 (lp
->spy_data
.spy_number
> 0) ||
2841 #endif /* IW_WIRELESS_SPY */
2843 (lp
->his_number
> 0) ||
2844 #endif /* HISTOGRAM */
2845 #ifdef WAVELAN_ROAMING
2847 #endif /* WAVELAN_ROAMING */
2850 u_char stats
[3]; /* Signal level, Noise level, Signal quality */
2852 /* read signal level, silence level and signal quality bytes */
2853 fd_p
= read_ringbuf(dev
, (fd_p
+ 4) % RX_SIZE
+ RX_BASE
,
2855 #ifdef DEBUG_RX_INFO
2856 printk(KERN_DEBUG
"%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
2857 dev
->name
, stats
[0] & 0x3F, stats
[1] & 0x3F, stats
[2] & 0x0F);
2860 #ifdef WAVELAN_ROAMING
2862 if(WAVELAN_BEACON(skb
->data
))
2863 wl_roam_gather(dev
, skb
->data
, stats
);
2864 #endif /* WAVELAN_ROAMING */
2867 wl_spy_gather(dev
, skb_mac_header(skb
) + WAVELAN_ADDR_SIZE
, stats
);
2868 #endif /* WIRELESS_SPY */
2870 wl_his_gather(dev
, stats
);
2871 #endif /* HISTOGRAM */
2875 * Hand the packet to the Network Module
2879 /* Keep stats up to date */
2880 lp
->stats
.rx_packets
++;
2881 lp
->stats
.rx_bytes
+= sksize
;
2883 #ifdef DEBUG_RX_TRACE
2884 printk(KERN_DEBUG
"%s: <-wv_packet_read()\n", dev
->name
);
2889 /*------------------------------------------------------------------*/
2891 * This routine is called by the interrupt handler to initiate a
2892 * packet transfer from the card to the network interface layer above
2893 * this driver. This routine checks if a buffer has been successfully
2894 * received by the WaveLAN card. If so, the routine wv_packet_read is
2895 * called to do the actual transfer of the card's data including the
2896 * ethernet header into a packet consisting of an sk_buff chain.
2897 * (called by wavelan_interrupt())
2898 * Note : the spinlock is already grabbed for us and irq are disabled.
2901 wv_packet_rcv(struct net_device
* dev
)
2903 unsigned int base
= dev
->base_addr
;
2904 net_local
* lp
= netdev_priv(dev
);
2914 #ifdef DEBUG_RX_TRACE
2915 printk(KERN_DEBUG
"%s: ->wv_packet_rcv()\n", dev
->name
);
2918 /* Get the new receive frame pointer from the i82593 chip */
2919 outb(CR0_STATUS_2
| OP0_NOP
, LCCR(base
));
2920 i593_rfp
= inb(LCSR(base
));
2921 i593_rfp
|= inb(LCSR(base
)) << 8;
2922 i593_rfp
%= RX_SIZE
;
2924 /* Get the new receive frame pointer from the WaveLAN card.
2925 * It is 3 bytes more than the increment of the i82593 receive
2926 * frame pointer, for each packet. This is because it includes the
2927 * 3 roaming bytes added by the mmc.
2929 newrfp
= inb(RPLL(base
));
2930 newrfp
|= inb(RPLH(base
)) << 8;
2933 #ifdef DEBUG_RX_INFO
2934 printk(KERN_DEBUG
"%s: wv_packet_rcv(): i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2935 dev
->name
, i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2938 #ifdef DEBUG_RX_ERROR
2939 /* If no new frame pointer... */
2940 if(lp
->overrunning
|| newrfp
== lp
->rfp
)
2941 printk(KERN_INFO
"%s: wv_packet_rcv(): no new frame: i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2942 dev
->name
, i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2945 /* Read all frames (packets) received */
2946 while(newrfp
!= lp
->rfp
)
2948 /* A frame is composed of the packet, followed by a status word,
2949 * the length of the frame (word) and the mmc info (SNR & qual).
2950 * It's because the length is at the end that we can only scan
2951 * frames backward. */
2953 /* Find the first frame by skipping backwards over the frames */
2954 rp
= newrfp
; /* End of last frame */
2955 while(((f_start
= wv_start_of_frame(dev
, rp
, newrfp
)) != lp
->rfp
) &&
2959 /* If we had a problem */
2962 #ifdef DEBUG_RX_ERROR
2963 printk(KERN_INFO
"wavelan_cs: cannot find start of frame ");
2964 printk(" i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2965 i593_rfp
, lp
->stop
, newrfp
, lp
->rfp
);
2967 lp
->rfp
= rp
; /* Get to the last usable frame */
2971 /* f_start point to the beggining of the first frame received
2972 * and rp to the beggining of the next one */
2974 /* Read status & length of the frame */
2975 stat_ptr
= (rp
- 7 + RX_SIZE
) % RX_SIZE
;
2976 stat_ptr
= read_ringbuf(dev
, stat_ptr
, c
, 4);
2977 status
= c
[0] | (c
[1] << 8);
2978 len
= c
[2] | (c
[3] << 8);
2981 if((status
& RX_RCV_OK
) != RX_RCV_OK
)
2983 lp
->stats
.rx_errors
++;
2984 if(status
& RX_NO_SFD
)
2985 lp
->stats
.rx_frame_errors
++;
2986 if(status
& RX_CRC_ERR
)
2987 lp
->stats
.rx_crc_errors
++;
2988 if(status
& RX_OVRRUN
)
2989 lp
->stats
.rx_over_errors
++;
2991 #ifdef DEBUG_RX_FAIL
2992 printk(KERN_DEBUG
"%s: wv_packet_rcv(): packet not received ok, status = 0x%x\n",
2997 /* Read the packet and transmit to Linux */
2998 wv_packet_read(dev
, f_start
, len
- 2);
3000 /* One frame has been processed, skip it */
3005 * Update the frame stop register, but set it to less than
3006 * the full 8K to allow space for 3 bytes of signal strength
3009 lp
->stop
= (i593_rfp
+ RX_SIZE
- ((RX_SIZE
/ 64) * 3)) % RX_SIZE
;
3010 outb(OP0_SWIT_TO_PORT_1
| CR0_CHNL
, LCCR(base
));
3011 outb(CR1_STOP_REG_UPDATE
| (lp
->stop
>> RX_SIZE_SHIFT
), LCCR(base
));
3012 outb(OP1_SWIT_TO_PORT_0
, LCCR(base
));
3014 #ifdef DEBUG_RX_TRACE
3015 printk(KERN_DEBUG
"%s: <-wv_packet_rcv()\n", dev
->name
);
3019 /*********************** PACKET TRANSMISSION ***********************/
3021 * This part deal with sending packet through the wavelan
3022 * We copy the packet to the send buffer and then issue the send
3023 * command to the i82593. The result of this operation will be
3024 * checked in wavelan_interrupt()
3027 /*------------------------------------------------------------------*/
3029 * This routine fills in the appropriate registers and memory
3030 * locations on the WaveLAN card and starts the card off on
3032 * (called in wavelan_packet_xmit())
3035 wv_packet_write(struct net_device
* dev
,
3039 net_local
* lp
= netdev_priv(dev
);
3040 unsigned int base
= dev
->base_addr
;
3041 unsigned long flags
;
3043 register u_short xmtdata_base
= TX_BASE
;
3045 #ifdef DEBUG_TX_TRACE
3046 printk(KERN_DEBUG
"%s: ->wv_packet_write(%d)\n", dev
->name
, length
);
3049 spin_lock_irqsave(&lp
->spinlock
, flags
);
3051 /* Write the length of data buffer followed by the buffer */
3052 outb(xmtdata_base
& 0xff, PIORL(base
));
3053 outb(((xmtdata_base
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3054 outb(clen
& 0xff, PIOP(base
)); /* lsb */
3055 outb(clen
>> 8, PIOP(base
)); /* msb */
3058 outsb(PIOP(base
), buf
, clen
);
3060 /* Indicate end of transmit chain */
3061 outb(OP0_NOP
, PIOP(base
));
3062 /* josullvn@cs.cmu.edu: need to send a second NOP for alignment... */
3063 outb(OP0_NOP
, PIOP(base
));
3065 /* Reset the transmit DMA pointer */
3066 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3067 hacr_write(base
, HACR_DEFAULT
);
3068 /* Send the transmit command */
3069 wv_82593_cmd(dev
, "wv_packet_write(): transmit",
3070 OP0_TRANSMIT
, SR0_NO_RESULT
);
3072 /* Make sure the watchdog will keep quiet for a while */
3073 dev
->trans_start
= jiffies
;
3075 /* Keep stats up to date */
3076 lp
->stats
.tx_bytes
+= length
;
3078 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3080 #ifdef DEBUG_TX_INFO
3081 wv_packet_info((u_char
*) buf
, length
, dev
->name
, "wv_packet_write");
3082 #endif /* DEBUG_TX_INFO */
3084 #ifdef DEBUG_TX_TRACE
3085 printk(KERN_DEBUG
"%s: <-wv_packet_write()\n", dev
->name
);
3089 /*------------------------------------------------------------------*/
3091 * This routine is called when we want to send a packet (NET3 callback)
3092 * In this routine, we check if the harware is ready to accept
3093 * the packet. We also prevent reentrance. Then, we call the function
3094 * to send the packet...
3097 wavelan_packet_xmit(struct sk_buff
* skb
,
3098 struct net_device
* dev
)
3100 net_local
* lp
= netdev_priv(dev
);
3101 unsigned long flags
;
3103 #ifdef DEBUG_TX_TRACE
3104 printk(KERN_DEBUG
"%s: ->wavelan_packet_xmit(0x%X)\n", dev
->name
,
3109 * Block a timer-based transmit from overlapping a previous transmit.
3110 * In other words, prevent reentering this routine.
3112 netif_stop_queue(dev
);
3114 /* If somebody has asked to reconfigure the controller,
3115 * we can do it now */
3116 if(lp
->reconfig_82593
)
3118 spin_lock_irqsave(&lp
->spinlock
, flags
); /* Disable interrupts */
3119 wv_82593_config(dev
);
3120 spin_unlock_irqrestore(&lp
->spinlock
, flags
); /* Re-enable interrupts */
3121 /* Note : the configure procedure was totally synchronous,
3122 * so the Tx buffer is now free */
3125 #ifdef DEBUG_TX_ERROR
3127 printk(KERN_INFO
"skb has next\n");
3130 /* Check if we need some padding */
3131 /* Note : on wireless the propagation time is in the order of 1us,
3132 * and we don't have the Ethernet specific requirement of beeing
3133 * able to detect collisions, therefore in theory we don't really
3134 * need to pad. Jean II */
3135 if (skb_padto(skb
, ETH_ZLEN
))
3138 wv_packet_write(dev
, skb
->data
, skb
->len
);
3142 #ifdef DEBUG_TX_TRACE
3143 printk(KERN_DEBUG
"%s: <-wavelan_packet_xmit()\n", dev
->name
);
3148 /********************** HARDWARE CONFIGURATION **********************/
3150 * This part do the real job of starting and configuring the hardware.
3153 /*------------------------------------------------------------------*/
3155 * Routine to initialize the Modem Management Controller.
3156 * (called by wv_hw_config())
3159 wv_mmc_init(struct net_device
* dev
)
3161 unsigned int base
= dev
->base_addr
;
3165 int i
; /* Loop counter */
3167 #ifdef DEBUG_CONFIG_TRACE
3168 printk(KERN_DEBUG
"%s: ->wv_mmc_init()\n", dev
->name
);
3171 /* Read the parameter storage area */
3172 psa_read(dev
, 0, (unsigned char *) &psa
, sizeof(psa
));
3175 * Check the first three octets of the MAC addr for the manufacturer's code.
3176 * Note: If you get the error message below, you've got a
3177 * non-NCR/AT&T/Lucent PCMCIA cards, see wavelan_cs.h for detail on
3178 * how to configure your card...
3180 for (i
= 0; i
< ARRAY_SIZE(MAC_ADDRESSES
); i
++)
3181 if ((psa
.psa_univ_mac_addr
[0] == MAC_ADDRESSES
[i
][0]) &&
3182 (psa
.psa_univ_mac_addr
[1] == MAC_ADDRESSES
[i
][1]) &&
3183 (psa
.psa_univ_mac_addr
[2] == MAC_ADDRESSES
[i
][2]))
3186 /* If we have not found it... */
3187 if (i
== ARRAY_SIZE(MAC_ADDRESSES
))
3189 #ifdef DEBUG_CONFIG_ERRORS
3190 printk(KERN_WARNING
"%s: wv_mmc_init(): Invalid MAC address: %02X:%02X:%02X:...\n",
3191 dev
->name
, psa
.psa_univ_mac_addr
[0],
3192 psa
.psa_univ_mac_addr
[1], psa
.psa_univ_mac_addr
[2]);
3197 /* Get the MAC address */
3198 memcpy(&dev
->dev_addr
[0], &psa
.psa_univ_mac_addr
[0], WAVELAN_ADDR_SIZE
);
3200 #ifdef USE_PSA_CONFIG
3201 configured
= psa
.psa_conf_status
& 1;
3206 /* Is the PSA is not configured */
3209 /* User will be able to configure NWID after (with iwconfig) */
3210 psa
.psa_nwid
[0] = 0;
3211 psa
.psa_nwid
[1] = 0;
3213 /* As NWID is not set : no NWID checking */
3214 psa
.psa_nwid_select
= 0;
3216 /* Disable encryption */
3217 psa
.psa_encryption_select
= 0;
3219 /* Set to standard values
3222 * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document)
3224 if (psa
.psa_comp_number
& 1)
3225 psa
.psa_thr_pre_set
= 0x01;
3227 psa
.psa_thr_pre_set
= 0x04;
3228 psa
.psa_quality_thr
= 0x03;
3230 /* It is configured */
3231 psa
.psa_conf_status
|= 1;
3233 #ifdef USE_PSA_CONFIG
3235 psa_write(dev
, (char *)psa
.psa_nwid
- (char *)&psa
,
3236 (unsigned char *)psa
.psa_nwid
, 4);
3237 psa_write(dev
, (char *)&psa
.psa_thr_pre_set
- (char *)&psa
,
3238 (unsigned char *)&psa
.psa_thr_pre_set
, 1);
3239 psa_write(dev
, (char *)&psa
.psa_quality_thr
- (char *)&psa
,
3240 (unsigned char *)&psa
.psa_quality_thr
, 1);
3241 psa_write(dev
, (char *)&psa
.psa_conf_status
- (char *)&psa
,
3242 (unsigned char *)&psa
.psa_conf_status
, 1);
3243 /* update the Wavelan checksum */
3244 update_psa_checksum(dev
);
3245 #endif /* USE_PSA_CONFIG */
3248 /* Zero the mmc structure */
3249 memset(&m
, 0x00, sizeof(m
));
3251 /* Copy PSA info to the mmc */
3252 m
.mmw_netw_id_l
= psa
.psa_nwid
[1];
3253 m
.mmw_netw_id_h
= psa
.psa_nwid
[0];
3255 if(psa
.psa_nwid_select
& 1)
3256 m
.mmw_loopt_sel
= 0x00;
3258 m
.mmw_loopt_sel
= MMW_LOOPT_SEL_DIS_NWID
;
3260 memcpy(&m
.mmw_encr_key
, &psa
.psa_encryption_key
,
3261 sizeof(m
.mmw_encr_key
));
3263 if(psa
.psa_encryption_select
)
3264 m
.mmw_encr_enable
= MMW_ENCR_ENABLE_EN
| MMW_ENCR_ENABLE_MODE
;
3266 m
.mmw_encr_enable
= 0;
3268 m
.mmw_thr_pre_set
= psa
.psa_thr_pre_set
& 0x3F;
3269 m
.mmw_quality_thr
= psa
.psa_quality_thr
& 0x0F;
3272 * Set default modem control parameters.
3273 * See NCR document 407-0024326 Rev. A.
3275 m
.mmw_jabber_enable
= 0x01;
3276 m
.mmw_anten_sel
= MMW_ANTEN_SEL_ALG_EN
;
3278 m
.mmw_mod_delay
= 0x04;
3279 m
.mmw_jam_time
= 0x38;
3281 m
.mmw_des_io_invert
= 0;
3283 m
.mmw_decay_prm
= 0;
3284 m
.mmw_decay_updat_prm
= 0;
3286 /* Write all info to mmc */
3287 mmc_write(base
, 0, (u_char
*)&m
, sizeof(m
));
3289 /* The following code start the modem of the 2.00 frequency
3290 * selectable cards at power on. It's not strictly needed for the
3291 * following boots...
3292 * The original patch was by Joe Finney for the PCMCIA driver, but
3293 * I've cleaned it a bit and add documentation.
3294 * Thanks to Loeke Brederveld from Lucent for the info.
3297 /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable)
3298 * (does it work for everybody ? - especially old cards...) */
3299 /* Note : WFREQSEL verify that it is able to read from EEprom
3300 * a sensible frequency (address 0x00) + that MMR_FEE_STATUS_ID
3301 * is 0xA (Xilinx version) or 0xB (Ariadne version).
3302 * My test is more crude but do work... */
3303 if(!(mmc_in(base
, mmroff(0, mmr_fee_status
)) &
3304 (MMR_FEE_STATUS_DWLD
| MMR_FEE_STATUS_BUSY
)))
3306 /* We must download the frequency parameters to the
3307 * synthetisers (from the EEprom - area 1)
3308 * Note : as the EEprom is auto decremented, we set the end
3310 m
.mmw_fee_addr
= 0x0F;
3311 m
.mmw_fee_ctrl
= MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
;
3312 mmc_write(base
, (char *)&m
.mmw_fee_ctrl
- (char *)&m
,
3313 (unsigned char *)&m
.mmw_fee_ctrl
, 2);
3315 /* Wait until the download is finished */
3316 fee_wait(base
, 100, 100);
3318 #ifdef DEBUG_CONFIG_INFO
3319 /* The frequency was in the last word downloaded... */
3320 mmc_read(base
, (char *)&m
.mmw_fee_data_l
- (char *)&m
,
3321 (unsigned char *)&m
.mmw_fee_data_l
, 2);
3323 /* Print some info for the user */
3324 printk(KERN_DEBUG
"%s: Wavelan 2.00 recognised (frequency select) : Current frequency = %ld\n",
3326 ((m
.mmw_fee_data_h
<< 4) |
3327 (m
.mmw_fee_data_l
>> 4)) * 5 / 2 + 24000L);
3330 /* We must now download the power adjust value (gain) to
3331 * the synthetisers (from the EEprom - area 7 - DAC) */
3332 m
.mmw_fee_addr
= 0x61;
3333 m
.mmw_fee_ctrl
= MMW_FEE_CTRL_READ
| MMW_FEE_CTRL_DWLD
;
3334 mmc_write(base
, (char *)&m
.mmw_fee_ctrl
- (char *)&m
,
3335 (unsigned char *)&m
.mmw_fee_ctrl
, 2);
3337 /* Wait until the download is finished */
3338 } /* if 2.00 card */
3340 #ifdef DEBUG_CONFIG_TRACE
3341 printk(KERN_DEBUG
"%s: <-wv_mmc_init()\n", dev
->name
);
3346 /*------------------------------------------------------------------*/
3348 * Routine to gracefully turn off reception, and wait for any commands
3350 * (called in wv_ru_start() and wavelan_close() and wavelan_event())
3353 wv_ru_stop(struct net_device
* dev
)
3355 unsigned int base
= dev
->base_addr
;
3356 net_local
* lp
= netdev_priv(dev
);
3357 unsigned long flags
;
3361 #ifdef DEBUG_CONFIG_TRACE
3362 printk(KERN_DEBUG
"%s: ->wv_ru_stop()\n", dev
->name
);
3365 spin_lock_irqsave(&lp
->spinlock
, flags
);
3367 /* First, send the LAN controller a stop receive command */
3368 wv_82593_cmd(dev
, "wv_graceful_shutdown(): stop-rcv",
3369 OP0_STOP_RCV
, SR0_NO_RESULT
);
3371 /* Then, spin until the receive unit goes idle */
3376 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3377 status
= inb(LCSR(base
));
3379 while(((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_IDLE
) && (spin
-- > 0));
3381 /* Now, spin until the chip finishes executing its current command */
3385 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3386 status
= inb(LCSR(base
));
3388 while(((status
& SR3_EXEC_STATE_MASK
) != SR3_EXEC_IDLE
) && (spin
-- > 0));
3390 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3392 /* If there was a problem */
3395 #ifdef DEBUG_CONFIG_ERRORS
3396 printk(KERN_INFO
"%s: wv_ru_stop(): The chip doesn't want to stop...\n",
3402 #ifdef DEBUG_CONFIG_TRACE
3403 printk(KERN_DEBUG
"%s: <-wv_ru_stop()\n", dev
->name
);
3408 /*------------------------------------------------------------------*/
3410 * This routine starts the receive unit running. First, it checks if
3411 * the card is actually ready. Then the card is instructed to receive
3413 * (called in wv_hw_reset() & wavelan_open())
3416 wv_ru_start(struct net_device
* dev
)
3418 unsigned int base
= dev
->base_addr
;
3419 net_local
* lp
= netdev_priv(dev
);
3420 unsigned long flags
;
3422 #ifdef DEBUG_CONFIG_TRACE
3423 printk(KERN_DEBUG
"%s: ->wv_ru_start()\n", dev
->name
);
3427 * We need to start from a quiescent state. To do so, we could check
3428 * if the card is already running, but instead we just try to shut
3429 * it down. First, we disable reception (in case it was already enabled).
3431 if(!wv_ru_stop(dev
))
3434 spin_lock_irqsave(&lp
->spinlock
, flags
);
3436 /* Now we know that no command is being executed. */
3438 /* Set the receive frame pointer and stop pointer */
3440 outb(OP0_SWIT_TO_PORT_1
| CR0_CHNL
, LCCR(base
));
3442 /* Reset ring management. This sets the receive frame pointer to 1 */
3443 outb(OP1_RESET_RING_MNGMT
, LCCR(base
));
3446 /* XXX the i82593 manual page 6-4 seems to indicate that the stop register
3447 should be set as below */
3448 /* outb(CR1_STOP_REG_UPDATE|((RX_SIZE - 0x40)>> RX_SIZE_SHIFT),LCCR(base));*/
3450 /* but I set it 0 instead */
3453 /* but I set it to 3 bytes per packet less than 8K */
3454 lp
->stop
= (0 + RX_SIZE
- ((RX_SIZE
/ 64) * 3)) % RX_SIZE
;
3456 outb(CR1_STOP_REG_UPDATE
| (lp
->stop
>> RX_SIZE_SHIFT
), LCCR(base
));
3457 outb(OP1_INT_ENABLE
, LCCR(base
));
3458 outb(OP1_SWIT_TO_PORT_0
, LCCR(base
));
3460 /* Reset receive DMA pointer */
3461 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3462 hacr_write_slow(base
, HACR_DEFAULT
);
3464 /* Receive DMA on channel 1 */
3465 wv_82593_cmd(dev
, "wv_ru_start(): rcv-enable",
3466 CR0_CHNL
| OP0_RCV_ENABLE
, SR0_NO_RESULT
);
3468 #ifdef DEBUG_I82593_SHOW
3474 /* spin until the chip starts receiving */
3477 outb(OP0_NOP
| CR0_STATUS_3
, LCCR(base
));
3478 status
= inb(LCSR(base
));
3482 while(((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_ACTIVE
) &&
3483 ((status
& SR3_RCV_STATE_MASK
) != SR3_RCV_READY
));
3484 printk(KERN_DEBUG
"rcv status is 0x%x [i:%d]\n",
3485 (status
& SR3_RCV_STATE_MASK
), i
);
3489 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3491 #ifdef DEBUG_CONFIG_TRACE
3492 printk(KERN_DEBUG
"%s: <-wv_ru_start()\n", dev
->name
);
3497 /*------------------------------------------------------------------*/
3499 * This routine does a standard config of the WaveLAN controller (i82593).
3500 * In the ISA driver, this is integrated in wavelan_hardware_reset()
3501 * (called by wv_hw_config(), wv_82593_reconfig() & wavelan_packet_xmit())
3504 wv_82593_config(struct net_device
* dev
)
3506 unsigned int base
= dev
->base_addr
;
3507 net_local
* lp
= netdev_priv(dev
);
3508 struct i82593_conf_block cfblk
;
3511 #ifdef DEBUG_CONFIG_TRACE
3512 printk(KERN_DEBUG
"%s: ->wv_82593_config()\n", dev
->name
);
3515 /* Create & fill i82593 config block
3517 * Now conform to Wavelan document WCIN085B
3519 memset(&cfblk
, 0x00, sizeof(struct i82593_conf_block
));
3520 cfblk
.d6mod
= FALSE
; /* Run in i82593 advanced mode */
3521 cfblk
.fifo_limit
= 5; /* = 56 B rx and 40 B tx fifo thresholds */
3522 cfblk
.forgnesi
= FALSE
; /* 0=82C501, 1=AMD7992B compatibility */
3524 cfblk
.throttle_enb
= FALSE
;
3525 cfblk
.contin
= TRUE
; /* enable continuous mode */
3526 cfblk
.cntrxint
= FALSE
; /* enable continuous mode receive interrupts */
3527 cfblk
.addr_len
= WAVELAN_ADDR_SIZE
;
3528 cfblk
.acloc
= TRUE
; /* Disable source addr insertion by i82593 */
3529 cfblk
.preamb_len
= 0; /* 2 bytes preamble (SFD) */
3530 cfblk
.loopback
= FALSE
;
3531 cfblk
.lin_prio
= 0; /* conform to 802.3 backoff algorithm */
3532 cfblk
.exp_prio
= 5; /* conform to 802.3 backoff algorithm */
3533 cfblk
.bof_met
= 1; /* conform to 802.3 backoff algorithm */
3534 cfblk
.ifrm_spc
= 0x20 >> 4; /* 32 bit times interframe spacing */
3535 cfblk
.slottim_low
= 0x20 >> 5; /* 32 bit times slot time */
3536 cfblk
.slottim_hi
= 0x0;
3537 cfblk
.max_retr
= 15;
3538 cfblk
.prmisc
= ((lp
->promiscuous
) ? TRUE
: FALSE
); /* Promiscuous mode */
3539 cfblk
.bc_dis
= FALSE
; /* Enable broadcast reception */
3540 cfblk
.crs_1
= TRUE
; /* Transmit without carrier sense */
3541 cfblk
.nocrc_ins
= FALSE
; /* i82593 generates CRC */
3542 cfblk
.crc_1632
= FALSE
; /* 32-bit Autodin-II CRC */
3543 cfblk
.crs_cdt
= FALSE
; /* CD not to be interpreted as CS */
3544 cfblk
.cs_filter
= 0; /* CS is recognized immediately */
3545 cfblk
.crs_src
= FALSE
; /* External carrier sense */
3546 cfblk
.cd_filter
= 0; /* CD is recognized immediately */
3547 cfblk
.min_fr_len
= ETH_ZLEN
>> 2; /* Minimum frame length 64 bytes */
3548 cfblk
.lng_typ
= FALSE
; /* Length field > 1500 = type field */
3549 cfblk
.lng_fld
= TRUE
; /* Disable 802.3 length field check */
3550 cfblk
.rxcrc_xf
= TRUE
; /* Don't transfer CRC to memory */
3551 cfblk
.artx
= TRUE
; /* Disable automatic retransmission */
3552 cfblk
.sarec
= TRUE
; /* Disable source addr trig of CD */
3553 cfblk
.tx_jabber
= TRUE
; /* Disable jabber jam sequence */
3554 cfblk
.hash_1
= FALSE
; /* Use bits 0-5 in mc address hash */
3555 cfblk
.lbpkpol
= TRUE
; /* Loopback pin active high */
3556 cfblk
.fdx
= FALSE
; /* Disable full duplex operation */
3557 cfblk
.dummy_6
= 0x3f; /* all ones */
3558 cfblk
.mult_ia
= FALSE
; /* No multiple individual addresses */
3559 cfblk
.dis_bof
= FALSE
; /* Disable the backoff algorithm ?! */
3560 cfblk
.dummy_1
= TRUE
; /* set to 1 */
3561 cfblk
.tx_ifs_retrig
= 3; /* Hmm... Disabled */
3562 #ifdef MULTICAST_ALL
3563 cfblk
.mc_all
= (lp
->allmulticast
? TRUE
: FALSE
); /* Allow all multicasts */
3565 cfblk
.mc_all
= FALSE
; /* No multicast all mode */
3567 cfblk
.rcv_mon
= 0; /* Monitor mode disabled */
3568 cfblk
.frag_acpt
= TRUE
; /* Do not accept fragments */
3569 cfblk
.tstrttrs
= FALSE
; /* No start transmission threshold */
3570 cfblk
.fretx
= TRUE
; /* FIFO automatic retransmission */
3571 cfblk
.syncrqs
= FALSE
; /* Synchronous DRQ deassertion... */
3572 cfblk
.sttlen
= TRUE
; /* 6 byte status registers */
3573 cfblk
.rx_eop
= TRUE
; /* Signal EOP on packet reception */
3574 cfblk
.tx_eop
= TRUE
; /* Signal EOP on packet transmission */
3575 cfblk
.rbuf_size
= RX_SIZE
>>11; /* Set receive buffer size */
3576 cfblk
.rcvstop
= TRUE
; /* Enable Receive Stop Register */
3578 #ifdef DEBUG_I82593_SHOW
3580 u_char
*c
= (u_char
*) &cfblk
;
3582 printk(KERN_DEBUG
"wavelan_cs: config block:");
3583 for(i
= 0; i
< sizeof(struct i82593_conf_block
); i
++,c
++)
3585 if((i
% 16) == 0) printk("\n" KERN_DEBUG
);
3586 printk("%02x ", *c
);
3592 /* Copy the config block to the i82593 */
3593 outb(TX_BASE
& 0xff, PIORL(base
));
3594 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3595 outb(sizeof(struct i82593_conf_block
) & 0xff, PIOP(base
)); /* lsb */
3596 outb(sizeof(struct i82593_conf_block
) >> 8, PIOP(base
)); /* msb */
3597 outsb(PIOP(base
), (char *) &cfblk
, sizeof(struct i82593_conf_block
));
3599 /* reset transmit DMA pointer */
3600 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3601 hacr_write(base
, HACR_DEFAULT
);
3602 if(!wv_82593_cmd(dev
, "wv_82593_config(): configure",
3603 OP0_CONFIGURE
, SR0_CONFIGURE_DONE
))
3606 /* Initialize adapter's ethernet MAC address */
3607 outb(TX_BASE
& 0xff, PIORL(base
));
3608 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3609 outb(WAVELAN_ADDR_SIZE
, PIOP(base
)); /* byte count lsb */
3610 outb(0, PIOP(base
)); /* byte count msb */
3611 outsb(PIOP(base
), &dev
->dev_addr
[0], WAVELAN_ADDR_SIZE
);
3613 /* reset transmit DMA pointer */
3614 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3615 hacr_write(base
, HACR_DEFAULT
);
3616 if(!wv_82593_cmd(dev
, "wv_82593_config(): ia-setup",
3617 OP0_IA_SETUP
, SR0_IA_SETUP_DONE
))
3620 #ifdef WAVELAN_ROAMING
3621 /* If roaming is enabled, join the "Beacon Request" multicast group... */
3622 /* But only if it's not in there already! */
3624 dev_mc_add(dev
,WAVELAN_BEACON_ADDRESS
, WAVELAN_ADDR_SIZE
, 1);
3625 #endif /* WAVELAN_ROAMING */
3627 /* If any multicast address to set */
3630 struct dev_mc_list
* dmi
;
3631 int addrs_len
= WAVELAN_ADDR_SIZE
* lp
->mc_count
;
3633 #ifdef DEBUG_CONFIG_INFO
3634 printk(KERN_DEBUG
"%s: wv_hw_config(): set %d multicast addresses:\n",
3635 dev
->name
, lp
->mc_count
);
3636 for(dmi
=dev
->mc_list
; dmi
; dmi
=dmi
->next
)
3637 printk(KERN_DEBUG
" %pM\n", dmi
->dmi_addr
);
3640 /* Initialize adapter's ethernet multicast addresses */
3641 outb(TX_BASE
& 0xff, PIORL(base
));
3642 outb(((TX_BASE
>> 8) & PIORH_MASK
) | PIORH_SEL_TX
, PIORH(base
));
3643 outb(addrs_len
& 0xff, PIOP(base
)); /* byte count lsb */
3644 outb((addrs_len
>> 8), PIOP(base
)); /* byte count msb */
3645 for(dmi
=dev
->mc_list
; dmi
; dmi
=dmi
->next
)
3646 outsb(PIOP(base
), dmi
->dmi_addr
, dmi
->dmi_addrlen
);
3648 /* reset transmit DMA pointer */
3649 hacr_write_slow(base
, HACR_PWR_STAT
| HACR_TX_DMA_RESET
);
3650 hacr_write(base
, HACR_DEFAULT
);
3651 if(!wv_82593_cmd(dev
, "wv_82593_config(): mc-setup",
3652 OP0_MC_SETUP
, SR0_MC_SETUP_DONE
))
3654 lp
->mc_count
= dev
->mc_count
; /* remember to avoid repeated reset */
3657 /* Job done, clear the flag */
3658 lp
->reconfig_82593
= FALSE
;
3660 #ifdef DEBUG_CONFIG_TRACE
3661 printk(KERN_DEBUG
"%s: <-wv_82593_config()\n", dev
->name
);
3666 /*------------------------------------------------------------------*/
3668 * Read the Access Configuration Register, perform a software reset,
3669 * and then re-enable the card's software.
3671 * If I understand correctly : reset the pcmcia interface of the
3673 * (called by wv_config())
3676 wv_pcmcia_reset(struct net_device
* dev
)
3679 conf_reg_t reg
= { 0, CS_READ
, CISREG_COR
, 0 };
3680 struct pcmcia_device
* link
= ((net_local
*)netdev_priv(dev
))->link
;
3682 #ifdef DEBUG_CONFIG_TRACE
3683 printk(KERN_DEBUG
"%s: ->wv_pcmcia_reset()\n", dev
->name
);
3686 i
= pcmcia_access_configuration_register(link
, ®
);
3689 cs_error(link
, AccessConfigurationRegister
, i
);
3693 #ifdef DEBUG_CONFIG_INFO
3694 printk(KERN_DEBUG
"%s: wavelan_pcmcia_reset(): Config reg is 0x%x\n",
3695 dev
->name
, (u_int
) reg
.Value
);
3698 reg
.Action
= CS_WRITE
;
3699 reg
.Value
= reg
.Value
| COR_SW_RESET
;
3700 i
= pcmcia_access_configuration_register(link
, ®
);
3703 cs_error(link
, AccessConfigurationRegister
, i
);
3707 reg
.Action
= CS_WRITE
;
3708 reg
.Value
= COR_LEVEL_IRQ
| COR_CONFIG
;
3709 i
= pcmcia_access_configuration_register(link
, ®
);
3712 cs_error(link
, AccessConfigurationRegister
, i
);
3716 #ifdef DEBUG_CONFIG_TRACE
3717 printk(KERN_DEBUG
"%s: <-wv_pcmcia_reset()\n", dev
->name
);
3722 /*------------------------------------------------------------------*/
3724 * wavelan_hw_config() is called after a CARD_INSERTION event is
3725 * received, to configure the wavelan hardware.
3726 * Note that the reception will be enabled in wavelan->open(), so the
3727 * device is configured but idle...
3728 * Performs the following actions:
3729 * 1. A pcmcia software reset (using wv_pcmcia_reset())
3730 * 2. A power reset (reset DMA)
3731 * 3. Reset the LAN controller
3732 * 4. Initialize the radio modem (using wv_mmc_init)
3733 * 5. Configure LAN controller (using wv_82593_config)
3734 * 6. Perform a diagnostic on the LAN controller
3735 * (called by wavelan_event() & wv_hw_reset())
3738 wv_hw_config(struct net_device
* dev
)
3740 net_local
* lp
= netdev_priv(dev
);
3741 unsigned int base
= dev
->base_addr
;
3742 unsigned long flags
;
3745 #ifdef DEBUG_CONFIG_TRACE
3746 printk(KERN_DEBUG
"%s: ->wv_hw_config()\n", dev
->name
);
3749 /* compile-time check the sizes of structures */
3750 BUILD_BUG_ON(sizeof(psa_t
) != PSA_SIZE
);
3751 BUILD_BUG_ON(sizeof(mmw_t
) != MMW_SIZE
);
3752 BUILD_BUG_ON(sizeof(mmr_t
) != MMR_SIZE
);
3754 /* Reset the pcmcia interface */
3755 if(wv_pcmcia_reset(dev
) == FALSE
)
3758 /* Disable interrupts */
3759 spin_lock_irqsave(&lp
->spinlock
, flags
);
3761 /* Disguised goto ;-) */
3764 /* Power UP the module + reset the modem + reset host adapter
3765 * (in fact, reset DMA channels) */
3766 hacr_write_slow(base
, HACR_RESET
);
3767 hacr_write(base
, HACR_DEFAULT
);
3769 /* Check if the module has been powered up... */
3770 if(hasr_read(base
) & HASR_NO_CLK
)
3772 #ifdef DEBUG_CONFIG_ERRORS
3773 printk(KERN_WARNING
"%s: wv_hw_config(): modem not connected or not a wavelan card\n",
3779 /* initialize the modem */
3780 if(wv_mmc_init(dev
) == FALSE
)
3782 #ifdef DEBUG_CONFIG_ERRORS
3783 printk(KERN_WARNING
"%s: wv_hw_config(): Can't configure the modem\n",
3789 /* reset the LAN controller (i82593) */
3790 outb(OP0_RESET
, LCCR(base
));
3791 mdelay(1); /* A bit crude ! */
3793 /* Initialize the LAN controller */
3794 if(wv_82593_config(dev
) == FALSE
)
3796 #ifdef DEBUG_CONFIG_ERRORS
3797 printk(KERN_INFO
"%s: wv_hw_config(): i82593 init failed\n",
3804 if(wv_diag(dev
) == FALSE
)
3806 #ifdef DEBUG_CONFIG_ERRORS
3807 printk(KERN_INFO
"%s: wv_hw_config(): i82593 diagnostic failed\n",
3814 * insert code for loopback test here
3817 /* The device is now configured */
3823 /* Re-enable interrupts */
3824 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
3826 #ifdef DEBUG_CONFIG_TRACE
3827 printk(KERN_DEBUG
"%s: <-wv_hw_config()\n", dev
->name
);
3832 /*------------------------------------------------------------------*/
3834 * Totally reset the wavelan and restart it.
3835 * Performs the following actions:
3836 * 1. Call wv_hw_config()
3837 * 2. Start the LAN controller's receive unit
3838 * (called by wavelan_event(), wavelan_watchdog() and wavelan_open())
3841 wv_hw_reset(struct net_device
* dev
)
3843 net_local
* lp
= netdev_priv(dev
);
3845 #ifdef DEBUG_CONFIG_TRACE
3846 printk(KERN_DEBUG
"%s: ->wv_hw_reset()\n", dev
->name
);
3852 /* Call wv_hw_config() for most of the reset & init stuff */
3853 if(wv_hw_config(dev
) == FALSE
)
3856 /* start receive unit */
3859 #ifdef DEBUG_CONFIG_TRACE
3860 printk(KERN_DEBUG
"%s: <-wv_hw_reset()\n", dev
->name
);
3864 /*------------------------------------------------------------------*/
3866 * wv_pcmcia_config() is called after a CARD_INSERTION event is
3867 * received, to configure the PCMCIA socket, and to make the ethernet
3868 * device available to the system.
3869 * (called by wavelan_event())
3872 wv_pcmcia_config(struct pcmcia_device
* link
)
3874 struct net_device
* dev
= (struct net_device
*) link
->priv
;
3878 net_local
* lp
= netdev_priv(dev
);
3881 #ifdef DEBUG_CONFIG_TRACE
3882 printk(KERN_DEBUG
"->wv_pcmcia_config(0x%p)\n", link
);
3887 i
= pcmcia_request_io(link
, &link
->io
);
3890 cs_error(link
, RequestIO
, i
);
3895 * Now allocate an interrupt line. Note that this does not
3896 * actually assign a handler to the interrupt.
3898 i
= pcmcia_request_irq(link
, &link
->irq
);
3901 cs_error(link
, RequestIRQ
, i
);
3906 * This actually configures the PCMCIA socket -- setting up
3907 * the I/O windows and the interrupt mapping.
3909 link
->conf
.ConfigIndex
= 1;
3910 i
= pcmcia_request_configuration(link
, &link
->conf
);
3913 cs_error(link
, RequestConfiguration
, i
);
3918 * Allocate a small memory window. Note that the struct pcmcia_device
3919 * structure provides space for one window handle -- if your
3920 * device needs several windows, you'll need to keep track of
3921 * the handles in your private data structure, link->priv.
3923 req
.Attributes
= WIN_DATA_WIDTH_8
|WIN_MEMORY_TYPE_AM
|WIN_ENABLE
;
3924 req
.Base
= req
.Size
= 0;
3925 req
.AccessSpeed
= mem_speed
;
3926 i
= pcmcia_request_window(&link
, &req
, &link
->win
);
3929 cs_error(link
, RequestWindow
, i
);
3933 lp
->mem
= ioremap(req
.Base
, req
.Size
);
3934 dev
->mem_start
= (u_long
)lp
->mem
;
3935 dev
->mem_end
= dev
->mem_start
+ req
.Size
;
3937 mem
.CardOffset
= 0; mem
.Page
= 0;
3938 i
= pcmcia_map_mem_page(link
->win
, &mem
);
3941 cs_error(link
, MapMemPage
, i
);
3945 /* Feed device with this info... */
3946 dev
->irq
= link
->irq
.AssignedIRQ
;
3947 dev
->base_addr
= link
->io
.BasePort1
;
3948 netif_start_queue(dev
);
3950 #ifdef DEBUG_CONFIG_INFO
3951 printk(KERN_DEBUG
"wv_pcmcia_config: MEMSTART %p IRQ %d IOPORT 0x%x\n",
3952 lp
->mem
, dev
->irq
, (u_int
) dev
->base_addr
);
3955 SET_NETDEV_DEV(dev
, &handle_to_dev(link
));
3956 i
= register_netdev(dev
);
3959 #ifdef DEBUG_CONFIG_ERRORS
3960 printk(KERN_INFO
"wv_pcmcia_config(): register_netdev() failed\n");
3965 while(0); /* Humm... Disguised goto !!! */
3967 /* If any step failed, release any partially configured state */
3970 wv_pcmcia_release(link
);
3974 strcpy(((net_local
*) netdev_priv(dev
))->node
.dev_name
, dev
->name
);
3975 link
->dev_node
= &((net_local
*) netdev_priv(dev
))->node
;
3977 #ifdef DEBUG_CONFIG_TRACE
3978 printk(KERN_DEBUG
"<-wv_pcmcia_config()\n");
3983 /*------------------------------------------------------------------*/
3985 * After a card is removed, wv_pcmcia_release() will unregister the net
3986 * device, and release the PCMCIA configuration. If the device is
3987 * still open, this will be postponed until it is closed.
3990 wv_pcmcia_release(struct pcmcia_device
*link
)
3992 struct net_device
* dev
= (struct net_device
*) link
->priv
;
3993 net_local
* lp
= netdev_priv(dev
);
3995 #ifdef DEBUG_CONFIG_TRACE
3996 printk(KERN_DEBUG
"%s: -> wv_pcmcia_release(0x%p)\n", dev
->name
, link
);
4000 pcmcia_disable_device(link
);
4002 #ifdef DEBUG_CONFIG_TRACE
4003 printk(KERN_DEBUG
"%s: <- wv_pcmcia_release()\n", dev
->name
);
4007 /************************ INTERRUPT HANDLING ************************/
4010 * This function is the interrupt handler for the WaveLAN card. This
4011 * routine will be called whenever:
4012 * 1. A packet is received.
4013 * 2. A packet has successfully been transferred and the unit is
4014 * ready to transmit another packet.
4015 * 3. A command has completed execution.
4018 wavelan_interrupt(int irq
,
4021 struct net_device
* dev
= dev_id
;
4027 #ifdef DEBUG_INTERRUPT_TRACE
4028 printk(KERN_DEBUG
"%s: ->wavelan_interrupt()\n", dev
->name
);
4031 lp
= netdev_priv(dev
);
4032 base
= dev
->base_addr
;
4034 #ifdef DEBUG_INTERRUPT_INFO
4035 /* Check state of our spinlock (it should be cleared) */
4036 if(spin_is_locked(&lp
->spinlock
))
4038 "%s: wavelan_interrupt(): spinlock is already locked !!!\n",
4042 /* Prevent reentrancy. We need to do that because we may have
4043 * multiple interrupt handler running concurently.
4044 * It is safe because interrupts are disabled before aquiring
4046 spin_lock(&lp
->spinlock
);
4048 /* Treat all pending interrupts */
4051 /* ---------------- INTERRUPT CHECKING ---------------- */
4053 * Look for the interrupt and verify the validity
4055 outb(CR0_STATUS_0
| OP0_NOP
, LCCR(base
));
4056 status0
= inb(LCSR(base
));
4058 #ifdef DEBUG_INTERRUPT_INFO
4059 printk(KERN_DEBUG
"status0 0x%x [%s => 0x%x]", status0
,
4060 (status0
&SR0_INTERRUPT
)?"int":"no int",status0
&~SR0_INTERRUPT
);
4061 if(status0
&SR0_INTERRUPT
)
4063 printk(" [%s => %d]\n", (status0
& SR0_CHNL
) ? "chnl" :
4064 ((status0
& SR0_EXECUTION
) ? "cmd" :
4065 ((status0
& SR0_RECEPTION
) ? "recv" : "unknown")),
4066 (status0
& SR0_EVENT_MASK
));
4072 /* Return if no actual interrupt from i82593 (normal exit) */
4073 if(!(status0
& SR0_INTERRUPT
))
4076 /* If interrupt is both Rx and Tx or none...
4077 * This code in fact is there to catch the spurious interrupt
4078 * when you remove the wavelan pcmcia card from the socket */
4079 if(((status0
& SR0_BOTH_RX_TX
) == SR0_BOTH_RX_TX
) ||
4080 ((status0
& SR0_BOTH_RX_TX
) == 0x0))
4082 #ifdef DEBUG_INTERRUPT_INFO
4083 printk(KERN_INFO
"%s: wv_interrupt(): bogus interrupt (or from dead card) : %X\n",
4084 dev
->name
, status0
);
4086 /* Acknowledge the interrupt */
4087 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
));
4091 /* ----------------- RECEIVING PACKET ----------------- */
4093 * When the wavelan signal the reception of a new packet,
4094 * we call wv_packet_rcv() to copy if from the buffer and
4097 if(status0
& SR0_RECEPTION
)
4099 #ifdef DEBUG_INTERRUPT_INFO
4100 printk(KERN_DEBUG
"%s: wv_interrupt(): receive\n", dev
->name
);
4103 if((status0
& SR0_EVENT_MASK
) == SR0_STOP_REG_HIT
)
4105 #ifdef DEBUG_INTERRUPT_ERROR
4106 printk(KERN_INFO
"%s: wv_interrupt(): receive buffer overflow\n",
4109 lp
->stats
.rx_over_errors
++;
4110 lp
->overrunning
= 1;
4113 /* Get the packet */
4115 lp
->overrunning
= 0;
4117 /* Acknowledge the interrupt */
4118 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
));
4122 /* ---------------- COMMAND COMPLETION ---------------- */
4124 * Interrupts issued when the i82593 has completed a command.
4125 * Most likely : transmission done
4128 /* If a transmission has been done */
4129 if((status0
& SR0_EVENT_MASK
) == SR0_TRANSMIT_DONE
||
4130 (status0
& SR0_EVENT_MASK
) == SR0_RETRANSMIT_DONE
||
4131 (status0
& SR0_EVENT_MASK
) == SR0_TRANSMIT_NO_CRC_DONE
)
4133 #ifdef DEBUG_TX_ERROR
4134 if((status0
& SR0_EVENT_MASK
) == SR0_TRANSMIT_NO_CRC_DONE
)
4135 printk(KERN_INFO
"%s: wv_interrupt(): packet transmitted without CRC.\n",
4139 /* Get transmission status */
4140 tx_status
= inb(LCSR(base
));
4141 tx_status
|= (inb(LCSR(base
)) << 8);
4142 #ifdef DEBUG_INTERRUPT_INFO
4143 printk(KERN_DEBUG
"%s: wv_interrupt(): transmission done\n",
4148 rcv_bytes
= inb(LCSR(base
));
4149 rcv_bytes
|= (inb(LCSR(base
)) << 8);
4150 status3
= inb(LCSR(base
));
4151 printk(KERN_DEBUG
"tx_status 0x%02x rcv_bytes 0x%02x status3 0x%x\n",
4152 tx_status
, rcv_bytes
, (u_int
) status3
);
4155 /* Check for possible errors */
4156 if((tx_status
& TX_OK
) != TX_OK
)
4158 lp
->stats
.tx_errors
++;
4160 if(tx_status
& TX_FRTL
)
4162 #ifdef DEBUG_TX_ERROR
4163 printk(KERN_INFO
"%s: wv_interrupt(): frame too long\n",
4167 if(tx_status
& TX_UND_RUN
)
4169 #ifdef DEBUG_TX_FAIL
4170 printk(KERN_DEBUG
"%s: wv_interrupt(): DMA underrun\n",
4173 lp
->stats
.tx_aborted_errors
++;
4175 if(tx_status
& TX_LOST_CTS
)
4177 #ifdef DEBUG_TX_FAIL
4178 printk(KERN_DEBUG
"%s: wv_interrupt(): no CTS\n", dev
->name
);
4180 lp
->stats
.tx_carrier_errors
++;
4182 if(tx_status
& TX_LOST_CRS
)
4184 #ifdef DEBUG_TX_FAIL
4185 printk(KERN_DEBUG
"%s: wv_interrupt(): no carrier\n",
4188 lp
->stats
.tx_carrier_errors
++;
4190 if(tx_status
& TX_HRT_BEAT
)
4192 #ifdef DEBUG_TX_FAIL
4193 printk(KERN_DEBUG
"%s: wv_interrupt(): heart beat\n", dev
->name
);
4195 lp
->stats
.tx_heartbeat_errors
++;
4197 if(tx_status
& TX_DEFER
)
4199 #ifdef DEBUG_TX_FAIL
4200 printk(KERN_DEBUG
"%s: wv_interrupt(): channel jammed\n",
4204 /* Ignore late collisions since they're more likely to happen
4205 * here (the WaveLAN design prevents the LAN controller from
4206 * receiving while it is transmitting). We take action only when
4207 * the maximum retransmit attempts is exceeded.
4209 if(tx_status
& TX_COLL
)
4211 if(tx_status
& TX_MAX_COL
)
4213 #ifdef DEBUG_TX_FAIL
4214 printk(KERN_DEBUG
"%s: wv_interrupt(): channel congestion\n",
4217 if(!(tx_status
& TX_NCOL_MASK
))
4219 lp
->stats
.collisions
+= 0x10;
4223 } /* if(!(tx_status & TX_OK)) */
4225 lp
->stats
.collisions
+= (tx_status
& TX_NCOL_MASK
);
4226 lp
->stats
.tx_packets
++;
4228 netif_wake_queue(dev
);
4229 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
)); /* Acknowledge the interrupt */
4231 else /* if interrupt = transmit done or retransmit done */
4233 #ifdef DEBUG_INTERRUPT_ERROR
4234 printk(KERN_INFO
"wavelan_cs: unknown interrupt, status0 = %02x\n",
4237 outb(CR0_INT_ACK
| OP0_NOP
, LCCR(base
)); /* Acknowledge the interrupt */
4241 spin_unlock(&lp
->spinlock
);
4243 #ifdef DEBUG_INTERRUPT_TRACE
4244 printk(KERN_DEBUG
"%s: <-wavelan_interrupt()\n", dev
->name
);
4247 /* We always return IRQ_HANDLED, because we will receive empty
4248 * interrupts under normal operations. Anyway, it doesn't matter
4249 * as we are dealing with an ISA interrupt that can't be shared.
4251 * Explanation : under heavy receive, the following happens :
4252 * ->wavelan_interrupt()
4253 * (status0 & SR0_INTERRUPT) != 0
4255 * (status0 & SR0_INTERRUPT) != 0
4257 * (status0 & SR0_INTERRUPT) == 0 // i.e. no more event
4258 * <-wavelan_interrupt()
4259 * ->wavelan_interrupt()
4260 * (status0 & SR0_INTERRUPT) == 0 // i.e. empty interrupt
4261 * <-wavelan_interrupt()
4264 } /* wv_interrupt */
4266 /*------------------------------------------------------------------*/
4268 * Watchdog: when we start a transmission, a timer is set for us in the
4269 * kernel. If the transmission completes, this timer is disabled. If
4270 * the timer expires, we are called and we try to unlock the hardware.
4272 * Note : This watchdog is move clever than the one in the ISA driver,
4273 * because it try to abort the current command before reseting
4275 * On the other hand, it's a bit simpler, because we don't have to
4276 * deal with the multiple Tx buffers...
4279 wavelan_watchdog(struct net_device
* dev
)
4281 net_local
* lp
= netdev_priv(dev
);
4282 unsigned int base
= dev
->base_addr
;
4283 unsigned long flags
;
4284 int aborted
= FALSE
;
4286 #ifdef DEBUG_INTERRUPT_TRACE
4287 printk(KERN_DEBUG
"%s: ->wavelan_watchdog()\n", dev
->name
);
4290 #ifdef DEBUG_INTERRUPT_ERROR
4291 printk(KERN_INFO
"%s: wavelan_watchdog: watchdog timer expired\n",
4295 spin_lock_irqsave(&lp
->spinlock
, flags
);
4297 /* Ask to abort the current command */
4298 outb(OP0_ABORT
, LCCR(base
));
4300 /* Wait for the end of the command (a bit hackish) */
4301 if(wv_82593_cmd(dev
, "wavelan_watchdog(): abort",
4302 OP0_NOP
| CR0_STATUS_3
, SR0_EXECUTION_ABORTED
))
4305 /* Release spinlock here so that wv_hw_reset() can grab it */
4306 spin_unlock_irqrestore(&lp
->spinlock
, flags
);
4308 /* Check if we were successful in aborting it */
4311 /* It seem that it wasn't enough */
4312 #ifdef DEBUG_INTERRUPT_ERROR
4313 printk(KERN_INFO
"%s: wavelan_watchdog: abort failed, trying reset\n",
4319 #ifdef DEBUG_PSA_SHOW
4322 psa_read(dev
, 0, (unsigned char *) &psa
, sizeof(psa
));
4326 #ifdef DEBUG_MMC_SHOW
4329 #ifdef DEBUG_I82593_SHOW
4333 /* We are no more waiting for something... */
4334 netif_wake_queue(dev
);
4336 #ifdef DEBUG_INTERRUPT_TRACE
4337 printk(KERN_DEBUG
"%s: <-wavelan_watchdog()\n", dev
->name
);
4341 /********************* CONFIGURATION CALLBACKS *********************/
4343 * Here are the functions called by the pcmcia package (cardmgr) and
4344 * linux networking (NET3) for initialization, configuration and
4345 * deinstallations of the Wavelan Pcmcia Hardware.
4348 /*------------------------------------------------------------------*/
4350 * Configure and start up the WaveLAN PCMCIA adaptor.
4351 * Called by NET3 when it "open" the device.
4354 wavelan_open(struct net_device
* dev
)
4356 net_local
* lp
= netdev_priv(dev
);
4357 struct pcmcia_device
* link
= lp
->link
;
4358 unsigned int base
= dev
->base_addr
;
4360 #ifdef DEBUG_CALLBACK_TRACE
4361 printk(KERN_DEBUG
"%s: ->wavelan_open(dev=0x%x)\n", dev
->name
,
4362 (unsigned int) dev
);
4365 /* Check if the modem is powered up (wavelan_close() power it down */
4366 if(hasr_read(base
) & HASR_NO_CLK
)
4368 /* Power up (power up time is 250us) */
4369 hacr_write(base
, HACR_DEFAULT
);
4371 /* Check if the module has been powered up... */
4372 if(hasr_read(base
) & HASR_NO_CLK
)
4374 #ifdef DEBUG_CONFIG_ERRORS
4375 printk(KERN_WARNING
"%s: wavelan_open(): modem not connected\n",
4382 /* Start reception and declare the driver ready */
4385 if(!wv_ru_start(dev
))
4386 wv_hw_reset(dev
); /* If problem : reset */
4387 netif_start_queue(dev
);
4389 /* Mark the device as used */
4392 #ifdef WAVELAN_ROAMING
4395 #endif /* WAVELAN_ROAMING */
4397 #ifdef DEBUG_CALLBACK_TRACE
4398 printk(KERN_DEBUG
"%s: <-wavelan_open()\n", dev
->name
);
4403 /*------------------------------------------------------------------*/
4405 * Shutdown the WaveLAN PCMCIA adaptor.
4406 * Called by NET3 when it "close" the device.
4409 wavelan_close(struct net_device
* dev
)
4411 struct pcmcia_device
* link
= ((net_local
*)netdev_priv(dev
))->link
;
4412 unsigned int base
= dev
->base_addr
;
4414 #ifdef DEBUG_CALLBACK_TRACE
4415 printk(KERN_DEBUG
"%s: ->wavelan_close(dev=0x%x)\n", dev
->name
,
4416 (unsigned int) dev
);
4419 /* If the device isn't open, then nothing to do */
4422 #ifdef DEBUG_CONFIG_INFO
4423 printk(KERN_DEBUG
"%s: wavelan_close(): device not open\n", dev
->name
);
4428 #ifdef WAVELAN_ROAMING
4429 /* Cleanup of roaming stuff... */
4431 wv_roam_cleanup(dev
);
4432 #endif /* WAVELAN_ROAMING */
4436 /* If the card is still present */
4437 if(netif_running(dev
))
4439 netif_stop_queue(dev
);
4441 /* Stop receiving new messages and wait end of transmission */
4444 /* Power down the module */
4445 hacr_write(base
, HACR_DEFAULT
& (~HACR_PWR_STAT
));
4448 #ifdef DEBUG_CALLBACK_TRACE
4449 printk(KERN_DEBUG
"%s: <-wavelan_close()\n", dev
->name
);
4454 /*------------------------------------------------------------------*/
4456 * wavelan_attach() creates an "instance" of the driver, allocating
4457 * local data structures for one device (one interface). The device
4458 * is registered with Card Services.
4460 * The dev_link structure is initialized, but we don't actually
4461 * configure the card at this point -- we wait until we receive a
4462 * card insertion event.
4465 wavelan_probe(struct pcmcia_device
*p_dev
)
4467 struct net_device
* dev
; /* Interface generic data */
4468 net_local
* lp
; /* Interface specific data */
4471 #ifdef DEBUG_CALLBACK_TRACE
4472 printk(KERN_DEBUG
"-> wavelan_attach()\n");
4475 /* The io structure describes IO port mapping */
4476 p_dev
->io
.NumPorts1
= 8;
4477 p_dev
->io
.Attributes1
= IO_DATA_PATH_WIDTH_8
;
4478 p_dev
->io
.IOAddrLines
= 3;
4480 /* Interrupt setup */
4481 p_dev
->irq
.Attributes
= IRQ_TYPE_DYNAMIC_SHARING
| IRQ_HANDLE_PRESENT
;
4482 p_dev
->irq
.IRQInfo1
= IRQ_LEVEL_ID
;
4483 p_dev
->irq
.Handler
= wavelan_interrupt
;
4485 /* General socket configuration */
4486 p_dev
->conf
.Attributes
= CONF_ENABLE_IRQ
;
4487 p_dev
->conf
.IntType
= INT_MEMORY_AND_IO
;
4489 /* Allocate the generic data structure */
4490 dev
= alloc_etherdev(sizeof(net_local
));
4494 p_dev
->priv
= p_dev
->irq
.Instance
= dev
;
4496 lp
= netdev_priv(dev
);
4498 /* Init specific data */
4500 lp
->reconfig_82593
= FALSE
;
4502 /* Multicast stuff */
4503 lp
->promiscuous
= 0;
4504 lp
->allmulticast
= 0;
4508 spin_lock_init(&lp
->spinlock
);
4513 /* wavelan NET3 callbacks */
4514 dev
->open
= &wavelan_open
;
4515 dev
->stop
= &wavelan_close
;
4516 dev
->hard_start_xmit
= &wavelan_packet_xmit
;
4517 dev
->get_stats
= &wavelan_get_stats
;
4518 dev
->set_multicast_list
= &wavelan_set_multicast_list
;
4519 #ifdef SET_MAC_ADDRESS
4520 dev
->set_mac_address
= &wavelan_set_mac_address
;
4521 #endif /* SET_MAC_ADDRESS */
4523 /* Set the watchdog timer */
4524 dev
->tx_timeout
= &wavelan_watchdog
;
4525 dev
->watchdog_timeo
= WATCHDOG_JIFFIES
;
4526 SET_ETHTOOL_OPS(dev
, &ops
);
4528 dev
->wireless_handlers
= &wavelan_handler_def
;
4529 lp
->wireless_data
.spy_data
= &lp
->spy_data
;
4530 dev
->wireless_data
= &lp
->wireless_data
;
4532 /* Other specific data */
4533 dev
->mtu
= WAVELAN_MTU
;
4535 ret
= wv_pcmcia_config(p_dev
);
4539 ret
= wv_hw_config(dev
);
4542 pcmcia_disable_device(p_dev
);
4548 #ifdef DEBUG_CALLBACK_TRACE
4549 printk(KERN_DEBUG
"<- wavelan_attach()\n");
4555 /*------------------------------------------------------------------*/
4557 * This deletes a driver "instance". The device is de-registered with
4558 * Card Services. If it has been released, all local data structures
4559 * are freed. Otherwise, the structures will be freed when the device
4563 wavelan_detach(struct pcmcia_device
*link
)
4565 #ifdef DEBUG_CALLBACK_TRACE
4566 printk(KERN_DEBUG
"-> wavelan_detach(0x%p)\n", link
);
4569 /* Some others haven't done their job : give them another chance */
4570 wv_pcmcia_release(link
);
4575 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4577 /* Remove ourselves from the kernel list of ethernet devices */
4578 /* Warning : can't be called from interrupt, timer or wavelan_close() */
4580 unregister_netdev(dev
);
4581 link
->dev_node
= NULL
;
4582 ((net_local
*)netdev_priv(dev
))->link
= NULL
;
4583 ((net_local
*)netdev_priv(dev
))->dev
= NULL
;
4587 #ifdef DEBUG_CALLBACK_TRACE
4588 printk(KERN_DEBUG
"<- wavelan_detach()\n");
4592 static int wavelan_suspend(struct pcmcia_device
*link
)
4594 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4596 /* NB: wavelan_close will be called, but too late, so we are
4597 * obliged to close nicely the wavelan here. David, could you
4598 * close the device before suspending them ? And, by the way,
4599 * could you, on resume, add a "route add -net ..." after the
4600 * ifconfig up ? Thanks... */
4602 /* Stop receiving new messages and wait end of transmission */
4606 netif_device_detach(dev
);
4608 /* Power down the module */
4609 hacr_write(dev
->base_addr
, HACR_DEFAULT
& (~HACR_PWR_STAT
));
4614 static int wavelan_resume(struct pcmcia_device
*link
)
4616 struct net_device
* dev
= (struct net_device
*) link
->priv
;
4620 netif_device_attach(dev
);
4627 static struct pcmcia_device_id wavelan_ids
[] = {
4628 PCMCIA_DEVICE_PROD_ID12("AT&T","WaveLAN/PCMCIA", 0xe7c5affd, 0x1bc50975),
4629 PCMCIA_DEVICE_PROD_ID12("Digital", "RoamAbout/DS", 0x9999ab35, 0x00d05e06),
4630 PCMCIA_DEVICE_PROD_ID12("Lucent Technologies", "WaveLAN/PCMCIA", 0x23eb9949, 0x1bc50975),
4631 PCMCIA_DEVICE_PROD_ID12("NCR", "WaveLAN/PCMCIA", 0x24358cd4, 0x1bc50975),
4634 MODULE_DEVICE_TABLE(pcmcia
, wavelan_ids
);
4636 static struct pcmcia_driver wavelan_driver
= {
4637 .owner
= THIS_MODULE
,
4639 .name
= "wavelan_cs",
4641 .probe
= wavelan_probe
,
4642 .remove
= wavelan_detach
,
4643 .id_table
= wavelan_ids
,
4644 .suspend
= wavelan_suspend
,
4645 .resume
= wavelan_resume
,
4649 init_wavelan_cs(void)
4651 return pcmcia_register_driver(&wavelan_driver
);
4655 exit_wavelan_cs(void)
4657 pcmcia_unregister_driver(&wavelan_driver
);
4660 module_init(init_wavelan_cs
);
4661 module_exit(exit_wavelan_cs
);