1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60#include "wavelan_cs.p.h"
61
62#ifdef WAVELAN_ROAMING
63static void wl_cell_expiry(unsigned long data);
64static void wl_del_wavepoint(wavepoint_history *wavepoint, struct net_local *lp);
65static void wv_nwid_filter(unsigned char mode, net_local *lp);
66#endif
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83static inline u_char
84hasr_read(u_long base)
85{
86 return(inb(HASR(base)));
87}
88
89
90
91
92
93static inline void
94hacr_write(u_long base,
95 u_char hacr)
96{
97 outb(hacr, HACR(base));
98}
99
100
101
102
103
104
105static void
106hacr_write_slow(u_long base,
107 u_char hacr)
108{
109 hacr_write(base, hacr);
110
111 mdelay(1);
112}
113
114
115
116
117
118static void
119psa_read(struct net_device * dev,
120 int o,
121 u_char * b,
122 int n)
123{
124 net_local *lp = netdev_priv(dev);
125 u_char __iomem *ptr = lp->mem + PSA_ADDR + (o << 1);
126
127 while(n-- > 0)
128 {
129 *b++ = readb(ptr);
130
131
132
133
134
135 ptr += 2;
136 }
137}
138
139
140
141
142
143static void
144psa_write(struct net_device * dev,
145 int o,
146 u_char * b,
147 int n)
148{
149 net_local *lp = netdev_priv(dev);
150 u_char __iomem *ptr = lp->mem + PSA_ADDR + (o << 1);
151 int count = 0;
152 unsigned int base = dev->base_addr;
153
154
155 volatile u_char __iomem *verify = lp->mem + PSA_ADDR +
156 (psaoff(0, psa_comp_number) << 1);
157
158
159 hacr_write(base, HACR_PWR_STAT | HACR_ROM_WEN);
160
161 while(n-- > 0)
162 {
163
164 writeb(*b++, ptr);
165 ptr += 2;
166
167
168
169 count = 0;
170 while((readb(verify) != PSA_COMP_PCMCIA_915) && (count++ < 100))
171 mdelay(1);
172 }
173
174
175 hacr_write(base, HACR_DEFAULT);
176}
177
178#ifdef SET_PSA_CRC
179
180
181
182
183
184
185
186
187
188
189static u_short
190psa_crc(unsigned char * psa,
191 int size)
192{
193 int byte_cnt;
194 u_short crc_bytes = 0;
195 int bit_cnt;
196
197 for(byte_cnt = 0; byte_cnt < size; byte_cnt++ )
198 {
199 crc_bytes ^= psa[byte_cnt];
200
201 for(bit_cnt = 1; bit_cnt < 9; bit_cnt++ )
202 {
203 if(crc_bytes & 0x0001)
204 crc_bytes = (crc_bytes >> 1) ^ 0xA001;
205 else
206 crc_bytes >>= 1 ;
207 }
208 }
209
210 return crc_bytes;
211}
212#endif
213
214
215
216
217
218static void
219update_psa_checksum(struct net_device * dev)
220{
221#ifdef SET_PSA_CRC
222 psa_t psa;
223 u_short crc;
224
225
226 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
227
228
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));
232
233 psa.psa_crc[0] = crc & 0xFF;
234 psa.psa_crc[1] = (crc & 0xFF00) >> 8;
235
236
237 psa_write(dev, (char *)&psa.psa_crc - (char *)&psa,
238 (unsigned char *)&psa.psa_crc, 2);
239
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]);
243
244
245 crc = psa_crc((unsigned char *) &psa,
246 sizeof(psa) - sizeof(psa.psa_crc_status));
247
248 if(crc != 0)
249 printk(KERN_WARNING "%s: update_psa_checksum(): CRC does not agree with PSA data (even after recalculating)\n", dev->name);
250#endif
251#endif
252}
253
254
255
256
257
258static void
259mmc_out(u_long base,
260 u_short o,
261 u_char d)
262{
263 int count = 0;
264
265
266 while((count++ < 100) && (inb(HASR(base)) & HASR_MMI_BUSY))
267 udelay(10);
268
269 outb((u_char)((o << 1) | MMR_MMI_WR), MMR(base));
270 outb(d, MMD(base));
271}
272
273
274
275
276
277
278static void
279mmc_write(u_long base,
280 u_char o,
281 u_char * b,
282 int n)
283{
284 o += n;
285 b += n;
286
287 while(n-- > 0 )
288 mmc_out(base, --o, *(--b));
289}
290
291
292
293
294
295
296static u_char
297mmc_in(u_long base,
298 u_short o)
299{
300 int count = 0;
301
302 while((count++ < 100) && (inb(HASR(base)) & HASR_MMI_BUSY))
303 udelay(10);
304 outb(o << 1, MMR(base));
305
306 outb(0, MMD(base));
307
308 while((count++ < 100) && (inb(HASR(base)) & HASR_MMI_BUSY))
309 udelay(10);
310 return (u_char) (inb(MMD(base)));
311}
312
313
314
315
316
317
318
319
320
321static void
322mmc_read(u_long base,
323 u_char o,
324 u_char * b,
325 int n)
326{
327 o += n;
328 b += n;
329
330 while(n-- > 0)
331 *(--b) = mmc_in(base, --o);
332}
333
334
335
336
337
338static inline int
339mmc_encr(u_long base)
340{
341 int temp;
342
343 temp = mmc_in(base, mmroff(0, mmr_des_avail));
344 if((temp != MMR_DES_AVAIL_DES) && (temp != MMR_DES_AVAIL_AES))
345 return 0;
346 else
347 return temp;
348}
349
350
351
352
353
354static void
355fee_wait(u_long base,
356 int delay,
357 int number)
358{
359 int count = 0;
360
361 while((count++ < number) &&
362 (mmc_in(base, mmroff(0, mmr_fee_status)) & MMR_FEE_STATUS_BUSY))
363 udelay(delay);
364}
365
366
367
368
369
370static void
371fee_read(u_long base,
372 u_short o,
373 u_short * b,
374 int n)
375{
376 b += n;
377
378
379 mmc_out(base, mmwoff(0, mmw_fee_addr), o + n - 1);
380
381
382 while(n-- > 0)
383 {
384
385 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_READ);
386
387
388 fee_wait(base, 10, 100);
389
390
391 *--b = ((mmc_in(base, mmroff(0, mmr_fee_data_h)) << 8) |
392 mmc_in(base, mmroff(0, mmr_fee_data_l)));
393 }
394}
395
396
397
398
399
400
401
402
403
404static void
405fee_write(u_long base,
406 u_short o,
407 u_short * b,
408 int n)
409{
410 b += n;
411
412#ifdef EEPROM_IS_PROTECTED
413#ifdef DOESNT_SEEM_TO_WORK
414
415 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRREAD);
416
417 fee_wait(base, 10, 100);
418
419
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
424
425
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);
428
429 fee_wait(base, 10, 100);
430
431
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
435
436 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRCLEAR);
437#endif
438
439 fee_wait(base, 10, 100);
440#endif
441
442
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);
445
446 fee_wait(base, 10, 100);
447
448
449 mmc_out(base, mmwoff(0, mmw_fee_addr), o + n - 1);
450
451
452 while(n-- > 0)
453 {
454
455 mmc_out(base, mmwoff(0, mmw_fee_data_h), (*--b) >> 8);
456 mmc_out(base, mmwoff(0, mmw_fee_data_l), *b & 0xFF);
457
458
459 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WRITE);
460
461
462 mdelay(10);
463 fee_wait(base, 10, 100);
464 }
465
466
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);
469
470 fee_wait(base, 10, 100);
471
472#ifdef EEPROM_IS_PROTECTED
473
474 mmc_out(base, mmwoff(0, mmw_fee_addr), 0x00);
475 mmc_out(base, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE);
476
477 fee_wait(base, 10, 100);
478#endif
479}
480
481
482
483#ifdef WAVELAN_ROAMING
484
485static unsigned char WAVELAN_BEACON_ADDRESS[] = {0x09,0x00,0x0e,0x20,0x03,0x00};
486
487static void wv_roam_init(struct net_device *dev)
488{
489 net_local *lp= netdev_priv(dev);
490
491
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");
498
499 lp->wavepoint_table.head=NULL;
500 lp->wavepoint_table.num_wavepoints=0;
501 lp->wavepoint_table.locked=0;
502 lp->curr_point=NULL;
503 lp->cell_search=0;
504
505 lp->cell_timer.data=(long)lp;
506 lp->cell_timer.function=wl_cell_expiry;
507 lp->cell_timer.expires=jiffies+CELL_TIMEOUT;
508 add_timer(&lp->cell_timer);
509
510 wv_nwid_filter(NWID_PROMISC,lp) ;
511
512
513 printk(KERN_DEBUG "WaveLAN: Roaming enabled on device %s\n",dev->name);
514}
515
516static void wv_roam_cleanup(struct net_device *dev)
517{
518 wavepoint_history *ptr,*old_ptr;
519 net_local *lp= netdev_priv(dev);
520
521 printk(KERN_DEBUG "WaveLAN: Roaming Disabled on device %s\n",dev->name);
522
523
524 del_timer(&lp->cell_timer);
525 ptr=lp->wavepoint_table.head;
526 while(ptr!=NULL)
527 {
528 old_ptr=ptr;
529 ptr=ptr->next;
530 wl_del_wavepoint(old_ptr,lp);
531 }
532}
533
534
535static void wv_nwid_filter(unsigned char mode, net_local *lp)
536{
537 mm_t m;
538 unsigned long flags;
539
540#ifdef WAVELAN_ROAMING_DEBUG
541 printk(KERN_DEBUG "WaveLAN: NWID promisc %s, device %s\n",(mode==NWID_PROMISC) ? "on" : "off", lp->dev->name);
542#endif
543
544
545 spin_lock_irqsave(&lp->spinlock, flags);
546
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);
549
550 if(mode==NWID_PROMISC)
551 lp->cell_search=1;
552 else
553 lp->cell_search=0;
554
555
556 spin_unlock_irqrestore(&lp->spinlock, flags);
557}
558
559
560static wavepoint_history *wl_roam_check(unsigned short nwid, net_local *lp)
561{
562 wavepoint_history *ptr=lp->wavepoint_table.head;
563
564 while(ptr!=NULL){
565 if(ptr->nwid==nwid)
566 return ptr;
567 ptr=ptr->next;
568 }
569 return NULL;
570}
571
572
573static wavepoint_history *wl_new_wavepoint(unsigned short nwid, unsigned char seq, net_local* lp)
574{
575 wavepoint_history *new_wavepoint;
576
577#ifdef WAVELAN_ROAMING_DEBUG
578 printk(KERN_DEBUG "WaveLAN: New Wavepoint, NWID:%.4X\n",nwid);
579#endif
580
581 if(lp->wavepoint_table.num_wavepoints==MAX_WAVEPOINTS)
582 return NULL;
583
584 new_wavepoint = kmalloc(sizeof(wavepoint_history),GFP_ATOMIC);
585 if(new_wavepoint==NULL)
586 return NULL;
587
588 new_wavepoint->nwid=nwid;
589 new_wavepoint->average_fast=0;
590 new_wavepoint->average_slow=0;
591 new_wavepoint->qualptr=0;
592 new_wavepoint->last_seq=seq-1;
593 memset(new_wavepoint->sigqual,0,WAVEPOINT_HISTORY);
594
595 new_wavepoint->next=lp->wavepoint_table.head;
596 new_wavepoint->prev=NULL;
597
598 if(lp->wavepoint_table.head!=NULL)
599 lp->wavepoint_table.head->prev=new_wavepoint;
600
601 lp->wavepoint_table.head=new_wavepoint;
602
603 lp->wavepoint_table.num_wavepoints++;
604
605 return new_wavepoint;
606}
607
608
609static void wl_del_wavepoint(wavepoint_history *wavepoint, struct net_local *lp)
610{
611 if(wavepoint==NULL)
612 return;
613
614 if(lp->curr_point==wavepoint)
615 lp->curr_point=NULL;
616
617 if(wavepoint->prev!=NULL)
618 wavepoint->prev->next=wavepoint->next;
619
620 if(wavepoint->next!=NULL)
621 wavepoint->next->prev=wavepoint->prev;
622
623 if(lp->wavepoint_table.head==wavepoint)
624 lp->wavepoint_table.head=wavepoint->next;
625
626 lp->wavepoint_table.num_wavepoints--;
627 kfree(wavepoint);
628}
629
630
631static void wl_cell_expiry(unsigned long data)
632{
633 net_local *lp=(net_local *)data;
634 wavepoint_history *wavepoint=lp->wavepoint_table.head,*old_point;
635
636#if WAVELAN_ROAMING_DEBUG > 1
637 printk(KERN_DEBUG "WaveLAN: Wavepoint timeout, dev %s\n",lp->dev->name);
638#endif
639
640 if(lp->wavepoint_table.locked)
641 {
642#if WAVELAN_ROAMING_DEBUG > 1
643 printk(KERN_DEBUG "WaveLAN: Wavepoint table locked...\n");
644#endif
645
646 lp->cell_timer.expires=jiffies+1;
647 add_timer(&lp->cell_timer);
648 return;
649 }
650
651 while(wavepoint!=NULL)
652 {
653 if(time_after(jiffies, wavepoint->last_seen + CELL_TIMEOUT))
654 {
655#ifdef WAVELAN_ROAMING_DEBUG
656 printk(KERN_DEBUG "WaveLAN: Bye bye %.4X\n",wavepoint->nwid);
657#endif
658
659 old_point=wavepoint;
660 wavepoint=wavepoint->next;
661 wl_del_wavepoint(old_point,lp);
662 }
663 else
664 wavepoint=wavepoint->next;
665 }
666 lp->cell_timer.expires=jiffies+CELL_TIMEOUT;
667 add_timer(&lp->cell_timer);
668}
669
670
671static void wl_update_history(wavepoint_history *wavepoint, unsigned char sigqual, unsigned char seq)
672{
673 int i=0,num_missed=0,ptr=0;
674 int average_fast=0,average_slow=0;
675
676 num_missed=(seq-wavepoint->last_seq)%WAVEPOINT_HISTORY;
677
678 if(num_missed)
679 for(i=0;i<num_missed;i++)
680 {
681 wavepoint->sigqual[wavepoint->qualptr++]=0;
682 wavepoint->qualptr %=WAVEPOINT_HISTORY;
683 }
684 wavepoint->last_seen=jiffies;
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;
689
690 for(i=0;i<WAVEPOINT_FAST_HISTORY;i++)
691 {
692 average_fast+=wavepoint->sigqual[ptr++];
693 ptr %=WAVEPOINT_HISTORY;
694 }
695
696 average_slow=average_fast;
697 for(i=WAVEPOINT_FAST_HISTORY;i<WAVEPOINT_HISTORY;i++)
698 {
699 average_slow+=wavepoint->sigqual[ptr++];
700 ptr %=WAVEPOINT_HISTORY;
701 }
702
703 wavepoint->average_fast=average_fast/WAVEPOINT_FAST_HISTORY;
704 wavepoint->average_slow=average_slow/WAVEPOINT_HISTORY;
705}
706
707
708static void wv_roam_handover(wavepoint_history *wavepoint, net_local *lp)
709{
710 unsigned int base = lp->dev->base_addr;
711 mm_t m;
712 unsigned long flags;
713
714 if(wavepoint==lp->curr_point)
715 {
716 wv_nwid_filter(!NWID_PROMISC,lp);
717 return;
718 }
719
720#ifdef WAVELAN_ROAMING_DEBUG
721 printk(KERN_DEBUG "WaveLAN: Doing handover to %.4X, dev %s\n",wavepoint->nwid,lp->dev->name);
722#endif
723
724
725 spin_lock_irqsave(&lp->spinlock, flags);
726
727 m.w.mmw_netw_id_l = wavepoint->nwid & 0xFF;
728 m.w.mmw_netw_id_h = (wavepoint->nwid & 0xFF00) >> 8;
729
730 mmc_write(base, (char *)&m.w.mmw_netw_id_l - (char *)&m, (unsigned char *)&m.w.mmw_netw_id_l, 2);
731
732
733 spin_unlock_irqrestore(&lp->spinlock, flags);
734
735 wv_nwid_filter(!NWID_PROMISC,lp);
736 lp->curr_point=wavepoint;
737}
738
739
740static void wl_roam_gather(struct net_device * dev,
741 u_char * hdr,
742 u_char * stats)
743
744{
745 wavepoint_beacon *beacon= (wavepoint_beacon *)hdr;
746 unsigned short nwid=ntohs(beacon->nwid);
747 unsigned short sigqual=stats[2] & MMR_SGNL_QUAL;
748 wavepoint_history *wavepoint=NULL;
749 net_local *lp = netdev_priv(dev);
750
751#ifdef I_NEED_THIS_FEATURE
752
753 nwid=nwid^ntohs(beacon->domain_id);
754#endif
755
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);
759#endif
760
761 lp->wavepoint_table.locked=1;
762
763 wavepoint=wl_roam_check(nwid,lp);
764 if(wavepoint==NULL)
765 {
766 wavepoint=wl_new_wavepoint(nwid,beacon->seq,lp);
767 if(wavepoint==NULL)
768 goto out;
769 }
770 if(lp->curr_point==NULL)
771 wv_roam_handover(wavepoint, lp);
772
773 wl_update_history(wavepoint, sigqual, beacon->seq);
774
775
776 if(lp->curr_point->average_slow < SEARCH_THRESH_LOW)
777 if(!lp->cell_search)
778 wv_nwid_filter(NWID_PROMISC,lp);
779
780 if(wavepoint->average_slow >
781 lp->curr_point->average_slow + WAVELAN_ROAMING_DELTA)
782 wv_roam_handover(wavepoint, lp);
783
784 if(lp->curr_point->average_slow > SEARCH_THRESH_HIGH)
785 if(lp->cell_search)
786 wv_nwid_filter(!NWID_PROMISC,lp);
787
788out:
789 lp->wavepoint_table.locked=0;
790}
791
792
793static inline int WAVELAN_BEACON(unsigned char *data)
794{
795 wavepoint_beacon *beacon= (wavepoint_beacon *)data;
796 static const wavepoint_beacon beacon_template={0xaa,0xaa,0x03,0x08,0x00,0x0e,0x20,0x03,0x00};
797
798 if(memcmp(beacon,&beacon_template,9)==0)
799 return 1;
800 else
801 return 0;
802}
803#endif
804
805
806
807
808
809
810
811
812
813
814
815
816
817static int
818wv_82593_cmd(struct net_device * dev,
819 char * str,
820 int cmd,
821 int result)
822{
823 unsigned int base = dev->base_addr;
824 int status;
825 int wait_completed;
826 long spin;
827
828
829 spin = 1000;
830 do
831 {
832
833 udelay(10);
834
835
836 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
837 status = inb(LCSR(base));
838 }
839 while(((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE) && (spin-- > 0));
840
841
842 if(spin <= 0)
843 {
844#ifdef DEBUG_INTERRUPT_ERROR
845 printk(KERN_INFO "wv_82593_cmd: %s timeout (previous command), status 0x%02x\n",
846 str, status);
847#endif
848 return(FALSE);
849 }
850
851
852 outb(cmd, LCCR(base));
853
854
855
856 if(result == SR0_NO_RESULT)
857 return(TRUE);
858
859
860 wait_completed = TRUE;
861
862
863 spin = 1000;
864 do
865 {
866
867 udelay(10);
868
869
870 outb(CR0_STATUS_0 | OP0_NOP, LCCR(base));
871 status = inb(LCSR(base));
872
873
874 if((status & SR0_INTERRUPT))
875 {
876
877 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
878
879
880 if(((status & SR0_BOTH_RX_TX) != SR0_BOTH_RX_TX) &&
881 ((status & SR0_BOTH_RX_TX) != 0x0) &&
882 !(status & SR0_RECEPTION))
883 {
884
885 wait_completed = FALSE;
886 }
887 else
888 {
889
890
891#ifdef DEBUG_INTERRUPT_INFO
892 printk(KERN_INFO "wv_82593_cmd: not our interrupt\n");
893#endif
894 }
895 }
896 }
897 while(wait_completed && (spin-- > 0));
898
899
900 if(wait_completed)
901 {
902#ifdef DEBUG_INTERRUPT_ERROR
903 printk(KERN_INFO "wv_82593_cmd: %s timeout, status 0x%02x\n",
904 str, status);
905#endif
906 return(FALSE);
907 }
908
909
910
911 if((status & SR0_EVENT_MASK) != result)
912 {
913#ifdef DEBUG_INTERRUPT_ERROR
914 printk(KERN_INFO "wv_82593_cmd: %s failed, status = 0x%x\n",
915 str, status);
916#endif
917 return(FALSE);
918 }
919
920 return(TRUE);
921}
922
923
924
925
926
927
928static inline int
929wv_diag(struct net_device * dev)
930{
931 return(wv_82593_cmd(dev, "wv_diag(): diagnose",
932 OP0_DIAGNOSE, SR0_DIAGNOSE_PASSED));
933}
934
935
936
937
938
939
940
941static int
942read_ringbuf(struct net_device * dev,
943 int addr,
944 char * buf,
945 int len)
946{
947 unsigned int base = dev->base_addr;
948 int ring_ptr = addr;
949 int chunk_len;
950 char * buf_ptr = buf;
951
952
953 while(len > 0)
954 {
955
956 outb(ring_ptr & 0xff, PIORL(base));
957 outb(((ring_ptr >> 8) & PIORH_MASK), PIORH(base));
958
959
960
961 if((addr + len) < (RX_BASE + RX_SIZE))
962 chunk_len = len;
963 else
964 chunk_len = RX_BASE + RX_SIZE - addr;
965 insb(PIOP(base), buf_ptr, chunk_len);
966 buf_ptr += chunk_len;
967 len -= chunk_len;
968 ring_ptr = (ring_ptr - RX_BASE + chunk_len) % RX_SIZE + RX_BASE;
969 }
970 return(ring_ptr);
971}
972
973
974
975
976
977
978
979
980
981
982static void
983wv_82593_reconfig(struct net_device * dev)
984{
985 net_local * lp = netdev_priv(dev);
986 struct pcmcia_device * link = lp->link;
987 unsigned long flags;
988
989
990 lp->reconfig_82593 = TRUE;
991
992
993 if((link->open) && (netif_running(dev)) && !(netif_queue_stopped(dev)))
994 {
995 spin_lock_irqsave(&lp->spinlock, flags);
996 wv_82593_config(dev);
997 spin_unlock_irqrestore(&lp->spinlock, flags);
998 }
999 else
1000 {
1001#ifdef DEBUG_IOCTL_INFO
1002 printk(KERN_DEBUG
1003 "%s: wv_82593_reconfig(): delayed (state = %lX, link = %d)\n",
1004 dev->name, dev->state, link->open);
1005#endif
1006 }
1007}
1008
1009
1010
1011
1012
1013
1014
1015#ifdef DEBUG_PSA_SHOW
1016
1017
1018
1019
1020static void
1021wv_psa_show(psa_t * p)
1022{
1023 DECLARE_MAC_BUF(mac);
1024 printk(KERN_DEBUG "##### wavelan psa contents: #####\n");
1025 printk(KERN_DEBUG "psa_io_base_addr_1: 0x%02X %02X %02X %02X\n",
1026 p->psa_io_base_addr_1,
1027 p->psa_io_base_addr_2,
1028 p->psa_io_base_addr_3,
1029 p->psa_io_base_addr_4);
1030 printk(KERN_DEBUG "psa_rem_boot_addr_1: 0x%02X %02X %02X\n",
1031 p->psa_rem_boot_addr_1,
1032 p->psa_rem_boot_addr_2,
1033 p->psa_rem_boot_addr_3);
1034 printk(KERN_DEBUG "psa_holi_params: 0x%02x, ", p->psa_holi_params);
1035 printk("psa_int_req_no: %d\n", p->psa_int_req_no);
1036#ifdef DEBUG_SHOW_UNUSED
1037 printk(KERN_DEBUG "psa_unused0[]: %s\n",
1038 print_mac(mac, p->psa_unused0));
1039#endif
1040 printk(KERN_DEBUG "psa_univ_mac_addr[]: %s\n",
1041 print_mac(mac, p->psa_univ_mac_addr));
1042 printk(KERN_DEBUG "psa_local_mac_addr[]: %s\n",
1043 print_mac(mac, p->psa_local_mac_addr));
1044 printk(KERN_DEBUG "psa_univ_local_sel: %d, ", p->psa_univ_local_sel);
1045 printk("psa_comp_number: %d, ", p->psa_comp_number);
1046 printk("psa_thr_pre_set: 0x%02x\n", p->psa_thr_pre_set);
1047 printk(KERN_DEBUG "psa_feature_select/decay_prm: 0x%02x, ",
1048 p->psa_feature_select);
1049 printk("psa_subband/decay_update_prm: %d\n", p->psa_subband);
1050 printk(KERN_DEBUG "psa_quality_thr: 0x%02x, ", p->psa_quality_thr);
1051 printk("psa_mod_delay: 0x%02x\n", p->psa_mod_delay);
1052 printk(KERN_DEBUG "psa_nwid: 0x%02x%02x, ", p->psa_nwid[0], p->psa_nwid[1]);
1053 printk("psa_nwid_select: %d\n", p->psa_nwid_select);
1054 printk(KERN_DEBUG "psa_encryption_select: %d, ", p->psa_encryption_select);
1055 printk("psa_encryption_key[]: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
1056 p->psa_encryption_key[0],
1057 p->psa_encryption_key[1],
1058 p->psa_encryption_key[2],
1059 p->psa_encryption_key[3],
1060 p->psa_encryption_key[4],
1061 p->psa_encryption_key[5],
1062 p->psa_encryption_key[6],
1063 p->psa_encryption_key[7]);
1064 printk(KERN_DEBUG "psa_databus_width: %d\n", p->psa_databus_width);
1065 printk(KERN_DEBUG "psa_call_code/auto_squelch: 0x%02x, ",
1066 p->psa_call_code[0]);
1067 printk("psa_call_code[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
1068 p->psa_call_code[0],
1069 p->psa_call_code[1],
1070 p->psa_call_code[2],
1071 p->psa_call_code[3],
1072 p->psa_call_code[4],
1073 p->psa_call_code[5],
1074 p->psa_call_code[6],
1075 p->psa_call_code[7]);
1076#ifdef DEBUG_SHOW_UNUSED
1077 printk(KERN_DEBUG "psa_reserved[]: %02X:%02X\n",
1078 p->psa_reserved[0],
1079 p->psa_reserved[1]);
1080#endif
1081 printk(KERN_DEBUG "psa_conf_status: %d, ", p->psa_conf_status);
1082 printk("psa_crc: 0x%02x%02x, ", p->psa_crc[0], p->psa_crc[1]);
1083 printk("psa_crc_status: 0x%02x\n", p->psa_crc_status);
1084}
1085#endif
1086
1087#ifdef DEBUG_MMC_SHOW
1088
1089
1090
1091
1092
1093static void
1094wv_mmc_show(struct net_device * dev)
1095{
1096 unsigned int base = dev->base_addr;
1097 net_local * lp = netdev_priv(dev);
1098 mmr_t m;
1099
1100
1101 if(hasr_read(base) & HASR_NO_CLK)
1102 {
1103 printk(KERN_WARNING "%s: wv_mmc_show: modem not connected\n",
1104 dev->name);
1105 return;
1106 }
1107
1108 spin_lock_irqsave(&lp->spinlock, flags);
1109
1110
1111 mmc_out(base, mmwoff(0, mmw_freeze), 1);
1112 mmc_read(base, 0, (u_char *)&m, sizeof(m));
1113 mmc_out(base, mmwoff(0, mmw_freeze), 0);
1114
1115
1116 lp->wstats.discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
1117
1118 spin_unlock_irqrestore(&lp->spinlock, flags);
1119
1120 printk(KERN_DEBUG "##### wavelan modem status registers: #####\n");
1121#ifdef DEBUG_SHOW_UNUSED
1122 printk(KERN_DEBUG "mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
1123 m.mmr_unused0[0],
1124 m.mmr_unused0[1],
1125 m.mmr_unused0[2],
1126 m.mmr_unused0[3],
1127 m.mmr_unused0[4],
1128 m.mmr_unused0[5],
1129 m.mmr_unused0[6],
1130 m.mmr_unused0[7]);
1131#endif
1132 printk(KERN_DEBUG "Encryption algorithm: %02X - Status: %02X\n",
1133 m.mmr_des_avail, m.mmr_des_status);
1134#ifdef DEBUG_SHOW_UNUSED
1135 printk(KERN_DEBUG "mmc_unused1[]: %02X:%02X:%02X:%02X:%02X\n",
1136 m.mmr_unused1[0],
1137 m.mmr_unused1[1],
1138 m.mmr_unused1[2],
1139 m.mmr_unused1[3],
1140 m.mmr_unused1[4]);
1141#endif
1142 printk(KERN_DEBUG "dce_status: 0x%x [%s%s%s%s]\n",
1143 m.mmr_dce_status,
1144 (m.mmr_dce_status & MMR_DCE_STATUS_RX_BUSY) ? "energy detected,":"",
1145 (m.mmr_dce_status & MMR_DCE_STATUS_LOOPT_IND) ?
1146 "loop test indicated," : "",
1147 (m.mmr_dce_status & MMR_DCE_STATUS_TX_BUSY) ? "transmitter on," : "",
1148 (m.mmr_dce_status & MMR_DCE_STATUS_JBR_EXPIRED) ?
1149 "jabber timer expired," : "");
1150 printk(KERN_DEBUG "Dsp ID: %02X\n",
1151 m.mmr_dsp_id);
1152#ifdef DEBUG_SHOW_UNUSED
1153 printk(KERN_DEBUG "mmc_unused2[]: %02X:%02X\n",
1154 m.mmr_unused2[0],
1155 m.mmr_unused2[1]);
1156#endif
1157 printk(KERN_DEBUG "# correct_nwid: %d, # wrong_nwid: %d\n",
1158 (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l,
1159 (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l);
1160 printk(KERN_DEBUG "thr_pre_set: 0x%x [current signal %s]\n",
1161 m.mmr_thr_pre_set & MMR_THR_PRE_SET,
1162 (m.mmr_thr_pre_set & MMR_THR_PRE_SET_CUR) ? "above" : "below");
1163 printk(KERN_DEBUG "signal_lvl: %d [%s], ",
1164 m.mmr_signal_lvl & MMR_SIGNAL_LVL,
1165 (m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) ? "new msg" : "no new msg");
1166 printk("silence_lvl: %d [%s], ", m.mmr_silence_lvl & MMR_SILENCE_LVL,
1167 (m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) ? "update done" : "no new update");
1168 printk("sgnl_qual: 0x%x [%s]\n", m.mmr_sgnl_qual & MMR_SGNL_QUAL,
1169 (m.mmr_sgnl_qual & MMR_SGNL_QUAL_ANT) ? "Antenna 1" : "Antenna 0");
1170#ifdef DEBUG_SHOW_UNUSED
1171 printk(KERN_DEBUG "netw_id_l: %x\n", m.mmr_netw_id_l);
1172#endif
1173}
1174#endif
1175
1176#ifdef DEBUG_I82593_SHOW
1177
1178
1179
1180
1181static void
1182wv_ru_show(struct net_device * dev)
1183{
1184 net_local *lp = netdev_priv(dev);
1185
1186 printk(KERN_DEBUG "##### wavelan i82593 receiver status: #####\n");
1187 printk(KERN_DEBUG "ru: rfp %d stop %d", lp->rfp, lp->stop);
1188
1189
1190
1191 printk("\n");
1192}
1193#endif
1194
1195#ifdef DEBUG_DEVICE_SHOW
1196
1197
1198
1199
1200static void
1201wv_dev_show(struct net_device * dev)
1202{
1203 printk(KERN_DEBUG "dev:");
1204 printk(" state=%lX,", dev->state);
1205 printk(" trans_start=%ld,", dev->trans_start);
1206 printk(" flags=0x%x,", dev->flags);
1207 printk("\n");
1208}
1209
1210
1211
1212
1213
1214
1215static void
1216wv_local_show(struct net_device * dev)
1217{
1218 net_local *lp = netdev_priv(dev);
1219
1220 printk(KERN_DEBUG "local:");
1221
1222
1223
1224 printk("\n");
1225}
1226#endif
1227
1228#if defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO)
1229
1230
1231
1232
1233static void
1234wv_packet_info(u_char * p,
1235 int length,
1236 char * msg1,
1237 char * msg2)
1238{
1239 int i;
1240 int maxi;
1241 DECLARE_MAC_BUF(mac);
1242
1243 printk(KERN_DEBUG "%s: %s(): dest %s, length %d\n",
1244 msg1, msg2, print_mac(mac, p), length);
1245 printk(KERN_DEBUG "%s: %s(): src %s, type 0x%02X%02X\n",
1246 msg1, msg2, print_mac(mac, &p[6]), p[12], p[13]);
1247
1248#ifdef DEBUG_PACKET_DUMP
1249
1250 printk(KERN_DEBUG "data=\"");
1251
1252 if((maxi = length) > DEBUG_PACKET_DUMP)
1253 maxi = DEBUG_PACKET_DUMP;
1254 for(i = 14; i < maxi; i++)
1255 if(p[i] >= ' ' && p[i] <= '~')
1256 printk(" %c", p[i]);
1257 else
1258 printk("%02X", p[i]);
1259 if(maxi < length)
1260 printk("..");
1261 printk("\"\n");
1262 printk(KERN_DEBUG "\n");
1263#endif
1264}
1265#endif
1266
1267
1268
1269
1270
1271
1272static void
1273wv_init_info(struct net_device * dev)
1274{
1275 unsigned int base = dev->base_addr;
1276 psa_t psa;
1277 DECLARE_MAC_BUF(mac);
1278
1279
1280 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
1281
1282#ifdef DEBUG_PSA_SHOW
1283 wv_psa_show(&psa);
1284#endif
1285#ifdef DEBUG_MMC_SHOW
1286 wv_mmc_show(dev);
1287#endif
1288#ifdef DEBUG_I82593_SHOW
1289 wv_ru_show(dev);
1290#endif
1291
1292#ifdef DEBUG_BASIC_SHOW
1293
1294 printk(KERN_NOTICE "%s: WaveLAN: port %#x, irq %d, "
1295 "hw_addr %s",
1296 dev->name, base, dev->irq,
1297 print_mac(mac, dev->dev_addr));
1298
1299
1300 if(psa.psa_nwid_select)
1301 printk(", nwid 0x%02X-%02X", psa.psa_nwid[0], psa.psa_nwid[1]);
1302 else
1303 printk(", nwid off");
1304
1305
1306 if(!(mmc_in(base, mmroff(0, mmr_fee_status)) &
1307 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
1308 {
1309 unsigned short freq;
1310
1311
1312 fee_read(base, 0x00 ,
1313 &freq, 1);
1314
1315
1316 printk(", 2.00, %ld", (freq >> 6) + 2400L);
1317
1318
1319 if(freq & 0x20)
1320 printk(".5");
1321 }
1322 else
1323 {
1324 printk(", PCMCIA, ");
1325 switch (psa.psa_subband)
1326 {
1327 case PSA_SUBBAND_915:
1328 printk("915");
1329 break;
1330 case PSA_SUBBAND_2425:
1331 printk("2425");
1332 break;
1333 case PSA_SUBBAND_2460:
1334 printk("2460");
1335 break;
1336 case PSA_SUBBAND_2484:
1337 printk("2484");
1338 break;
1339 case PSA_SUBBAND_2430_5:
1340 printk("2430.5");
1341 break;
1342 default:
1343 printk("unknown");
1344 }
1345 }
1346
1347 printk(" MHz\n");
1348#endif
1349
1350#ifdef DEBUG_VERSION_SHOW
1351
1352 printk(KERN_NOTICE "%s", version);
1353#endif
1354}
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370static en_stats *
1371wavelan_get_stats(struct net_device * dev)
1372{
1373#ifdef DEBUG_IOCTL_TRACE
1374 printk(KERN_DEBUG "%s: <>wavelan_get_stats()\n", dev->name);
1375#endif
1376
1377 return(&((net_local *)netdev_priv(dev))->stats);
1378}
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389static void
1390wavelan_set_multicast_list(struct net_device * dev)
1391{
1392 net_local * lp = netdev_priv(dev);
1393
1394#ifdef DEBUG_IOCTL_TRACE
1395 printk(KERN_DEBUG "%s: ->wavelan_set_multicast_list()\n", dev->name);
1396#endif
1397
1398#ifdef DEBUG_IOCTL_INFO
1399 printk(KERN_DEBUG "%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n",
1400 dev->name, dev->flags, dev->mc_count);
1401#endif
1402
1403 if(dev->flags & IFF_PROMISC)
1404 {
1405
1406
1407
1408 if(!lp->promiscuous)
1409 {
1410 lp->promiscuous = 1;
1411 lp->allmulticast = 0;
1412 lp->mc_count = 0;
1413
1414 wv_82593_reconfig(dev);
1415 }
1416 }
1417 else
1418
1419
1420 if((dev->flags & IFF_ALLMULTI) ||
1421 (dev->mc_count > I82593_MAX_MULTICAST_ADDRESSES))
1422 {
1423
1424
1425
1426 if(!lp->allmulticast)
1427 {
1428 lp->promiscuous = 0;
1429 lp->allmulticast = 1;
1430 lp->mc_count = 0;
1431
1432 wv_82593_reconfig(dev);
1433 }
1434 }
1435 else
1436
1437 if(dev->mc_list != (struct dev_mc_list *) NULL)
1438 {
1439
1440
1441
1442
1443#ifdef MULTICAST_AVOID
1444 if(lp->promiscuous || lp->allmulticast ||
1445 (dev->mc_count != lp->mc_count))
1446#endif
1447 {
1448 lp->promiscuous = 0;
1449 lp->allmulticast = 0;
1450 lp->mc_count = dev->mc_count;
1451
1452 wv_82593_reconfig(dev);
1453 }
1454 }
1455 else
1456 {
1457
1458
1459
1460
1461 if(lp->promiscuous || lp->mc_count == 0)
1462 {
1463 lp->promiscuous = 0;
1464 lp->allmulticast = 0;
1465 lp->mc_count = 0;
1466
1467 wv_82593_reconfig(dev);
1468 }
1469 }
1470#ifdef DEBUG_IOCTL_TRACE
1471 printk(KERN_DEBUG "%s: <-wavelan_set_multicast_list()\n", dev->name);
1472#endif
1473}
1474
1475
1476
1477
1478
1479
1480#ifdef SET_MAC_ADDRESS
1481static int
1482wavelan_set_mac_address(struct net_device * dev,
1483 void * addr)
1484{
1485 struct sockaddr * mac = addr;
1486
1487
1488 memcpy(dev->dev_addr, mac->sa_data, WAVELAN_ADDR_SIZE);
1489
1490
1491 wv_82593_reconfig(dev);
1492
1493 return 0;
1494}
1495#endif
1496
1497
1498
1499
1500
1501
1502
1503static int
1504wv_set_frequency(u_long base,
1505 iw_freq * frequency)
1506{
1507 const int BAND_NUM = 10;
1508 long freq = 0L;
1509#ifdef DEBUG_IOCTL_INFO
1510 int i;
1511#endif
1512
1513
1514
1515
1516
1517
1518 if((frequency->e == 1) &&
1519 (frequency->m >= (int) 2.412e8) && (frequency->m <= (int) 2.487e8))
1520 {
1521 freq = ((frequency->m / 10000) - 24000L) / 5;
1522 }
1523
1524
1525
1526
1527 if((frequency->e == 0) &&
1528 (frequency->m >= 0) && (frequency->m < BAND_NUM))
1529 {
1530
1531 freq = channel_bands[frequency->m] >> 1;
1532 }
1533
1534
1535 if(freq != 0L)
1536 {
1537 u_short table[10];
1538
1539
1540 fee_read(base, 0x71 ,
1541 table, 10);
1542
1543#ifdef DEBUG_IOCTL_INFO
1544 printk(KERN_DEBUG "Frequency table :");
1545 for(i = 0; i < 10; i++)
1546 {
1547 printk(" %04X",
1548 table[i]);
1549 }
1550 printk("\n");
1551#endif
1552
1553
1554 if(!(table[9 - ((freq - 24) / 16)] &
1555 (1 << ((freq - 24) % 16))))
1556 return -EINVAL;
1557 }
1558 else
1559 return -EINVAL;
1560
1561
1562 if(freq != 0L)
1563 {
1564 unsigned short area[16];
1565 unsigned short dac[2];
1566 unsigned short area_verify[16];
1567 unsigned short dac_verify[2];
1568
1569
1570
1571 unsigned short power_limit[] = { 40, 80, 120, 160, 0 };
1572 int power_band = 0;
1573 unsigned short power_adjust;
1574
1575
1576 power_band = 0;
1577 while((freq > power_limit[power_band]) &&
1578 (power_limit[++power_band] != 0))
1579 ;
1580
1581
1582 fee_read(base, 0x00,
1583 area, 16);
1584
1585
1586 fee_read(base, 0x60,
1587 dac, 2);
1588
1589
1590 fee_read(base, 0x6B - (power_band >> 1),
1591 &power_adjust, 1);
1592 if(power_band & 0x1)
1593 power_adjust >>= 8;
1594 else
1595 power_adjust &= 0xFF;
1596
1597#ifdef DEBUG_IOCTL_INFO
1598 printk(KERN_DEBUG "Wavelan EEprom Area 1 :");
1599 for(i = 0; i < 16; i++)
1600 {
1601 printk(" %04X",
1602 area[i]);
1603 }
1604 printk("\n");
1605
1606 printk(KERN_DEBUG "Wavelan EEprom DAC : %04X %04X\n",
1607 dac[0], dac[1]);
1608#endif
1609
1610
1611 area[0] = ((freq << 5) & 0xFFE0) | (area[0] & 0x1F);
1612
1613
1614 area[3] = (freq >> 1) + 2400L - 352L;
1615 area[2] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1616
1617
1618 area[13] = (freq >> 1) + 2400L;
1619 area[12] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF);
1620
1621
1622
1623
1624 dac[1] = ((power_adjust >> 1) & 0x7F) | (dac[1] & 0xFF80);
1625 dac[0] = ((power_adjust & 0x1) << 4) | (dac[0] & 0xFFEF);
1626
1627
1628 fee_write(base, 0x00,
1629 area, 16);
1630
1631
1632 fee_write(base, 0x60,
1633 dac, 2);
1634
1635
1636
1637
1638 fee_read(base, 0x00,
1639 area_verify, 16);
1640
1641
1642 fee_read(base, 0x60,
1643 dac_verify, 2);
1644
1645
1646 if(memcmp(area, area_verify, 16 * 2) ||
1647 memcmp(dac, dac_verify, 2 * 2))
1648 {
1649#ifdef DEBUG_IOCTL_ERROR
1650 printk(KERN_INFO "Wavelan: wv_set_frequency : unable to write new frequency to EEprom (?)\n");
1651#endif
1652 return -EOPNOTSUPP;
1653 }
1654
1655
1656
1657
1658
1659 mmc_out(base, mmwoff(0, mmw_fee_addr), 0x0F);
1660 mmc_out(base, mmwoff(0, mmw_fee_ctrl),
1661 MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1662
1663
1664 fee_wait(base, 100, 100);
1665
1666
1667
1668 mmc_out(base, mmwoff(0, mmw_fee_addr), 0x61);
1669 mmc_out(base, mmwoff(0, mmw_fee_ctrl),
1670 MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD);
1671
1672
1673 fee_wait(base, 100, 100);
1674
1675#ifdef DEBUG_IOCTL_INFO
1676
1677
1678 printk(KERN_DEBUG "Wavelan EEprom Area 1 :");
1679 for(i = 0; i < 16; i++)
1680 {
1681 printk(" %04X",
1682 area_verify[i]);
1683 }
1684 printk("\n");
1685
1686 printk(KERN_DEBUG "Wavelan EEprom DAC : %04X %04X\n",
1687 dac_verify[0], dac_verify[1]);
1688#endif
1689
1690 return 0;
1691 }
1692 else
1693 return -EINVAL;
1694}
1695
1696
1697
1698
1699
1700static int
1701wv_frequency_list(u_long base,
1702 iw_freq * list,
1703 int max)
1704{
1705 u_short table[10];
1706 long freq = 0L;
1707 int i;
1708 const int BAND_NUM = 10;
1709 int c = 0;
1710
1711
1712 fee_read(base, 0x71 ,
1713 table, 10);
1714
1715
1716 i = 0;
1717 for(freq = 0; freq < 150; freq++)
1718
1719 if(table[9 - (freq / 16)] & (1 << (freq % 16)))
1720 {
1721
1722 while((((channel_bands[c] >> 1) - 24) < freq) &&
1723 (c < BAND_NUM))
1724 c++;
1725 list[i].i = c;
1726
1727
1728 list[i].m = (((freq + 24) * 5) + 24000L) * 10000;
1729 list[i++].e = 1;
1730
1731
1732 if(i >= max)
1733 return(i);
1734 }
1735
1736 return(i);
1737}
1738
1739#ifdef IW_WIRELESS_SPY
1740
1741
1742
1743
1744
1745
1746static inline void
1747wl_spy_gather(struct net_device * dev,
1748 u_char * mac,
1749 u_char * stats)
1750{
1751 struct iw_quality wstats;
1752
1753 wstats.qual = stats[2] & MMR_SGNL_QUAL;
1754 wstats.level = stats[0] & MMR_SIGNAL_LVL;
1755 wstats.noise = stats[1] & MMR_SILENCE_LVL;
1756 wstats.updated = 0x7;
1757
1758
1759 wireless_spy_update(dev, mac, &wstats);
1760}
1761#endif
1762
1763#ifdef HISTOGRAM
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773static inline void
1774wl_his_gather(struct net_device * dev,
1775 u_char * stats)
1776{
1777 net_local * lp = netdev_priv(dev);
1778 u_char level = stats[0] & MMR_SIGNAL_LVL;
1779 int i;
1780
1781
1782 i = 0;
1783 while((i < (lp->his_number - 1)) && (level >= lp->his_range[i++]))
1784 ;
1785
1786
1787 (lp->his_sum[i])++;
1788}
1789#endif
1790
1791static void wl_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1792{
1793 strncpy(info->driver, "wavelan_cs", sizeof(info->driver)-1);
1794}
1795
1796static const struct ethtool_ops ops = {
1797 .get_drvinfo = wl_get_drvinfo
1798};
1799
1800
1801
1802
1803
1804static int wavelan_get_name(struct net_device *dev,
1805 struct iw_request_info *info,
1806 union iwreq_data *wrqu,
1807 char *extra)
1808{
1809 strcpy(wrqu->name, "WaveLAN");
1810 return 0;
1811}
1812
1813
1814
1815
1816
1817static int wavelan_set_nwid(struct net_device *dev,
1818 struct iw_request_info *info,
1819 union iwreq_data *wrqu,
1820 char *extra)
1821{
1822 unsigned int base = dev->base_addr;
1823 net_local *lp = netdev_priv(dev);
1824 psa_t psa;
1825 mm_t m;
1826 unsigned long flags;
1827 int ret = 0;
1828
1829
1830 spin_lock_irqsave(&lp->spinlock, flags);
1831
1832
1833 if (!wrqu->nwid.disabled) {
1834
1835 psa.psa_nwid[0] = (wrqu->nwid.value & 0xFF00) >> 8;
1836 psa.psa_nwid[1] = wrqu->nwid.value & 0xFF;
1837 psa.psa_nwid_select = 0x01;
1838 psa_write(dev,
1839 (char *) psa.psa_nwid - (char *) &psa,
1840 (unsigned char *) psa.psa_nwid, 3);
1841
1842
1843 m.w.mmw_netw_id_l = psa.psa_nwid[1];
1844 m.w.mmw_netw_id_h = psa.psa_nwid[0];
1845 mmc_write(base,
1846 (char *) &m.w.mmw_netw_id_l -
1847 (char *) &m,
1848 (unsigned char *) &m.w.mmw_netw_id_l, 2);
1849 mmc_out(base, mmwoff(0, mmw_loopt_sel), 0x00);
1850 } else {
1851
1852 psa.psa_nwid_select = 0x00;
1853 psa_write(dev,
1854 (char *) &psa.psa_nwid_select -
1855 (char *) &psa,
1856 (unsigned char *) &psa.psa_nwid_select,
1857 1);
1858
1859
1860 mmc_out(base, mmwoff(0, mmw_loopt_sel),
1861 MMW_LOOPT_SEL_DIS_NWID);
1862 }
1863
1864 update_psa_checksum(dev);
1865
1866
1867 spin_unlock_irqrestore(&lp->spinlock, flags);
1868
1869 return ret;
1870}
1871
1872
1873
1874
1875
1876static int wavelan_get_nwid(struct net_device *dev,
1877 struct iw_request_info *info,
1878 union iwreq_data *wrqu,
1879 char *extra)
1880{
1881 net_local *lp = netdev_priv(dev);
1882 psa_t psa;
1883 unsigned long flags;
1884 int ret = 0;
1885
1886
1887 spin_lock_irqsave(&lp->spinlock, flags);
1888
1889
1890 psa_read(dev,
1891 (char *) psa.psa_nwid - (char *) &psa,
1892 (unsigned char *) psa.psa_nwid, 3);
1893 wrqu->nwid.value = (psa.psa_nwid[0] << 8) + psa.psa_nwid[1];
1894 wrqu->nwid.disabled = !(psa.psa_nwid_select);
1895 wrqu->nwid.fixed = 1;
1896
1897
1898 spin_unlock_irqrestore(&lp->spinlock, flags);
1899
1900 return ret;
1901}
1902
1903
1904
1905
1906
1907static int wavelan_set_freq(struct net_device *dev,
1908 struct iw_request_info *info,
1909 union iwreq_data *wrqu,
1910 char *extra)
1911{
1912 unsigned int base = dev->base_addr;
1913 net_local *lp = netdev_priv(dev);
1914 unsigned long flags;
1915 int ret;
1916
1917
1918 spin_lock_irqsave(&lp->spinlock, flags);
1919
1920
1921 if (!(mmc_in(base, mmroff(0, mmr_fee_status)) &
1922 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
1923 ret = wv_set_frequency(base, &(wrqu->freq));
1924 else
1925 ret = -EOPNOTSUPP;
1926
1927
1928 spin_unlock_irqrestore(&lp->spinlock, flags);
1929
1930 return ret;
1931}
1932
1933
1934
1935
1936
1937static int wavelan_get_freq(struct net_device *dev,
1938 struct iw_request_info *info,
1939 union iwreq_data *wrqu,
1940 char *extra)
1941{
1942 unsigned int base = dev->base_addr;
1943 net_local *lp = netdev_priv(dev);
1944 psa_t psa;
1945 unsigned long flags;
1946 int ret = 0;
1947
1948
1949 spin_lock_irqsave(&lp->spinlock, flags);
1950
1951
1952
1953 if (!(mmc_in(base, mmroff(0, mmr_fee_status)) &
1954 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
1955 unsigned short freq;
1956
1957
1958 fee_read(base, 0x00, &freq, 1);
1959 wrqu->freq.m = ((freq >> 5) * 5 + 24000L) * 10000;
1960 wrqu->freq.e = 1;
1961 } else {
1962 psa_read(dev,
1963 (char *) &psa.psa_subband - (char *) &psa,
1964 (unsigned char *) &psa.psa_subband, 1);
1965
1966 if (psa.psa_subband <= 4) {
1967 wrqu->freq.m = fixed_bands[psa.psa_subband];
1968 wrqu->freq.e = (psa.psa_subband != 0);
1969 } else
1970 ret = -EOPNOTSUPP;
1971 }
1972
1973
1974 spin_unlock_irqrestore(&lp->spinlock, flags);
1975
1976 return ret;
1977}
1978
1979
1980
1981
1982
1983static int wavelan_set_sens(struct net_device *dev,
1984 struct iw_request_info *info,
1985 union iwreq_data *wrqu,
1986 char *extra)
1987{
1988 unsigned int base = dev->base_addr;
1989 net_local *lp = netdev_priv(dev);
1990 psa_t psa;
1991 unsigned long flags;
1992 int ret = 0;
1993
1994
1995 spin_lock_irqsave(&lp->spinlock, flags);
1996
1997
1998
1999
2000 psa.psa_thr_pre_set = wrqu->sens.value & 0x3F;
2001 psa_write(dev,
2002 (char *) &psa.psa_thr_pre_set - (char *) &psa,
2003 (unsigned char *) &psa.psa_thr_pre_set, 1);
2004
2005 update_psa_checksum(dev);
2006 mmc_out(base, mmwoff(0, mmw_thr_pre_set),
2007 psa.psa_thr_pre_set);
2008
2009
2010 spin_unlock_irqrestore(&lp->spinlock, flags);
2011
2012 return ret;
2013}
2014
2015
2016
2017
2018
2019static int wavelan_get_sens(struct net_device *dev,
2020 struct iw_request_info *info,
2021 union iwreq_data *wrqu,
2022 char *extra)
2023{
2024 net_local *lp = netdev_priv(dev);
2025 psa_t psa;
2026 unsigned long flags;
2027 int ret = 0;
2028
2029
2030 spin_lock_irqsave(&lp->spinlock, flags);
2031
2032
2033 psa_read(dev,
2034 (char *) &psa.psa_thr_pre_set - (char *) &psa,
2035 (unsigned char *) &psa.psa_thr_pre_set, 1);
2036 wrqu->sens.value = psa.psa_thr_pre_set & 0x3F;
2037 wrqu->sens.fixed = 1;
2038
2039
2040 spin_unlock_irqrestore(&lp->spinlock, flags);
2041
2042 return ret;
2043}
2044
2045
2046
2047
2048
2049static int wavelan_set_encode(struct net_device *dev,
2050 struct iw_request_info *info,
2051 union iwreq_data *wrqu,
2052 char *extra)
2053{
2054 unsigned int base = dev->base_addr;
2055 net_local *lp = netdev_priv(dev);
2056 unsigned long flags;
2057 psa_t psa;
2058 int ret = 0;
2059
2060
2061 spin_lock_irqsave(&lp->spinlock, flags);
2062
2063
2064 if (!mmc_encr(base)) {
2065 ret = -EOPNOTSUPP;
2066 }
2067
2068
2069 if((wrqu->encoding.length != 8) && (wrqu->encoding.length != 0)) {
2070 ret = -EINVAL;
2071 }
2072
2073 if(!ret) {
2074
2075 if (wrqu->encoding.length == 8) {
2076
2077 memcpy(psa.psa_encryption_key, extra,
2078 wrqu->encoding.length);
2079 psa.psa_encryption_select = 1;
2080
2081 psa_write(dev,
2082 (char *) &psa.psa_encryption_select -
2083 (char *) &psa,
2084 (unsigned char *) &psa.
2085 psa_encryption_select, 8 + 1);
2086
2087 mmc_out(base, mmwoff(0, mmw_encr_enable),
2088 MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE);
2089 mmc_write(base, mmwoff(0, mmw_encr_key),
2090 (unsigned char *) &psa.
2091 psa_encryption_key, 8);
2092 }
2093
2094
2095 if (wrqu->encoding.flags & IW_ENCODE_DISABLED) {
2096 psa.psa_encryption_select = 0;
2097 psa_write(dev,
2098 (char *) &psa.psa_encryption_select -
2099 (char *) &psa,
2100 (unsigned char *) &psa.
2101 psa_encryption_select, 1);
2102
2103 mmc_out(base, mmwoff(0, mmw_encr_enable), 0);
2104 }
2105
2106 update_psa_checksum(dev);
2107 }
2108
2109
2110 spin_unlock_irqrestore(&lp->spinlock, flags);
2111
2112 return ret;
2113}
2114
2115
2116
2117
2118
2119static int wavelan_get_encode(struct net_device *dev,
2120 struct iw_request_info *info,
2121 union iwreq_data *wrqu,
2122 char *extra)
2123{
2124 unsigned int base = dev->base_addr;
2125 net_local *lp = netdev_priv(dev);
2126 psa_t psa;
2127 unsigned long flags;
2128 int ret = 0;
2129
2130
2131 spin_lock_irqsave(&lp->spinlock, flags);
2132
2133
2134 if (!mmc_encr(base)) {
2135 ret = -EOPNOTSUPP;
2136 } else {
2137
2138 psa_read(dev,
2139 (char *) &psa.psa_encryption_select -
2140 (char *) &psa,
2141 (unsigned char *) &psa.
2142 psa_encryption_select, 1 + 8);
2143
2144
2145 if (psa.psa_encryption_select)
2146 wrqu->encoding.flags = IW_ENCODE_ENABLED;
2147 else
2148 wrqu->encoding.flags = IW_ENCODE_DISABLED;
2149 wrqu->encoding.flags |= mmc_encr(base);
2150
2151
2152 wrqu->encoding.length = 8;
2153 memcpy(extra, psa.psa_encryption_key, wrqu->encoding.length);
2154 }
2155
2156
2157 spin_unlock_irqrestore(&lp->spinlock, flags);
2158
2159 return ret;
2160}
2161
2162#ifdef WAVELAN_ROAMING_EXT
2163
2164
2165
2166
2167static int wavelan_set_essid(struct net_device *dev,
2168 struct iw_request_info *info,
2169 union iwreq_data *wrqu,
2170 char *extra)
2171{
2172 net_local *lp = netdev_priv(dev);
2173 unsigned long flags;
2174 int ret = 0;
2175
2176
2177 spin_lock_irqsave(&lp->spinlock, flags);
2178
2179
2180 if(wrqu->data.flags == 0)
2181 lp->filter_domains = 0;
2182 else {
2183 char essid[IW_ESSID_MAX_SIZE + 1];
2184 char * endp;
2185
2186
2187 memcpy(essid, extra, wrqu->data.length);
2188 essid[IW_ESSID_MAX_SIZE] = '\0';
2189
2190#ifdef DEBUG_IOCTL_INFO
2191 printk(KERN_DEBUG "SetEssid : ``%s''\n", essid);
2192#endif
2193
2194
2195 lp->domain_id = simple_strtoul(essid, &endp, 16);
2196
2197 if(endp > essid)
2198 lp->filter_domains = 1;
2199 else {
2200 lp->filter_domains = 0;
2201 ret = -EINVAL;
2202 }
2203 }
2204
2205
2206 spin_unlock_irqrestore(&lp->spinlock, flags);
2207
2208 return ret;
2209}
2210
2211
2212
2213
2214
2215static int wavelan_get_essid(struct net_device *dev,
2216 struct iw_request_info *info,
2217 union iwreq_data *wrqu,
2218 char *extra)
2219{
2220 net_local *lp = netdev_priv(dev);
2221
2222
2223 wrqu->data.flags = lp->filter_domains;
2224
2225
2226
2227 sprintf(extra, "%lX", lp->domain_id);
2228 extra[IW_ESSID_MAX_SIZE] = '\0';
2229
2230
2231 wrqu->data.length = strlen(extra);
2232
2233 return 0;
2234}
2235
2236
2237
2238
2239
2240static int wavelan_set_wap(struct net_device *dev,
2241 struct iw_request_info *info,
2242 union iwreq_data *wrqu,
2243 char *extra)
2244{
2245#ifdef DEBUG_IOCTL_INFO
2246 printk(KERN_DEBUG "Set AP to : %02X:%02X:%02X:%02X:%02X:%02X\n",
2247 wrqu->ap_addr.sa_data[0],
2248 wrqu->ap_addr.sa_data[1],
2249 wrqu->ap_addr.sa_data[2],
2250 wrqu->ap_addr.sa_data[3],
2251 wrqu->ap_addr.sa_data[4],
2252 wrqu->ap_addr.sa_data[5]);
2253#endif
2254
2255 return -EOPNOTSUPP;
2256}
2257
2258
2259
2260
2261
2262static int wavelan_get_wap(struct net_device *dev,
2263 struct iw_request_info *info,
2264 union iwreq_data *wrqu,
2265 char *extra)
2266{
2267
2268 memcpy(wrqu->ap_addr.sa_data, dev->dev_addr, WAVELAN_ADDR_SIZE);
2269 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
2270
2271 return -EOPNOTSUPP;
2272}
2273#endif
2274
2275#ifdef WAVELAN_ROAMING
2276
2277
2278
2279
2280static int wavelan_set_mode(struct net_device *dev,
2281 struct iw_request_info *info,
2282 union iwreq_data *wrqu,
2283 char *extra)
2284{
2285 net_local *lp = netdev_priv(dev);
2286 unsigned long flags;
2287 int ret = 0;
2288
2289
2290 spin_lock_irqsave(&lp->spinlock, flags);
2291
2292
2293 switch(wrqu->mode) {
2294 case IW_MODE_ADHOC:
2295 if(do_roaming) {
2296 wv_roam_cleanup(dev);
2297 do_roaming = 0;
2298 }
2299 break;
2300 case IW_MODE_INFRA:
2301 if(!do_roaming) {
2302 wv_roam_init(dev);
2303 do_roaming = 1;
2304 }
2305 break;
2306 default:
2307 ret = -EINVAL;
2308 }
2309
2310
2311 spin_unlock_irqrestore(&lp->spinlock, flags);
2312
2313 return ret;
2314}
2315
2316
2317
2318
2319
2320static int wavelan_get_mode(struct net_device *dev,
2321 struct iw_request_info *info,
2322 union iwreq_data *wrqu,
2323 char *extra)
2324{
2325 if(do_roaming)
2326 wrqu->mode = IW_MODE_INFRA;
2327 else
2328 wrqu->mode = IW_MODE_ADHOC;
2329
2330 return 0;
2331}
2332#endif
2333
2334
2335
2336
2337
2338static int wavelan_get_range(struct net_device *dev,
2339 struct iw_request_info *info,
2340 union iwreq_data *wrqu,
2341 char *extra)
2342{
2343 unsigned int base = dev->base_addr;
2344 net_local *lp = netdev_priv(dev);
2345 struct iw_range *range = (struct iw_range *) extra;
2346 unsigned long flags;
2347 int ret = 0;
2348
2349
2350 wrqu->data.length = sizeof(struct iw_range);
2351
2352
2353 memset(range, 0, sizeof(struct iw_range));
2354
2355
2356 range->we_version_compiled = WIRELESS_EXT;
2357 range->we_version_source = 9;
2358
2359
2360 range->throughput = 1.4 * 1000 * 1000;
2361 range->min_nwid = 0x0000;
2362 range->max_nwid = 0xFFFF;
2363
2364 range->sensitivity = 0x3F;
2365 range->max_qual.qual = MMR_SGNL_QUAL;
2366 range->max_qual.level = MMR_SIGNAL_LVL;
2367 range->max_qual.noise = MMR_SILENCE_LVL;
2368 range->avg_qual.qual = MMR_SGNL_QUAL;
2369
2370 range->avg_qual.level = 30;
2371 range->avg_qual.noise = 8;
2372
2373 range->num_bitrates = 1;
2374 range->bitrate[0] = 2000000;
2375
2376
2377 range->event_capa[0] = (IW_EVENT_CAPA_MASK(0x8B02) |
2378 IW_EVENT_CAPA_MASK(0x8B04) |
2379 IW_EVENT_CAPA_MASK(0x8B06));
2380 range->event_capa[1] = IW_EVENT_CAPA_K_1;
2381
2382
2383 spin_lock_irqsave(&lp->spinlock, flags);
2384
2385
2386 if (!(mmc_in(base, mmroff(0, mmr_fee_status)) &
2387 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) {
2388 range->num_channels = 10;
2389 range->num_frequency = wv_frequency_list(base, range->freq,
2390 IW_MAX_FREQUENCIES);
2391 } else
2392 range->num_channels = range->num_frequency = 0;
2393
2394
2395 if (mmc_encr(base)) {
2396 range->encoding_size[0] = 8;
2397 range->num_encoding_sizes = 1;
2398 range->max_encoding_tokens = 1;
2399 } else {
2400 range->num_encoding_sizes = 0;
2401 range->max_encoding_tokens = 0;
2402 }
2403
2404
2405 spin_unlock_irqrestore(&lp->spinlock, flags);
2406
2407 return ret;
2408}
2409
2410
2411
2412
2413
2414static int wavelan_set_qthr(struct net_device *dev,
2415 struct iw_request_info *info,
2416 union iwreq_data *wrqu,
2417 char *extra)
2418{
2419 unsigned int base = dev->base_addr;
2420 net_local *lp = netdev_priv(dev);
2421 psa_t psa;
2422 unsigned long flags;
2423
2424
2425 spin_lock_irqsave(&lp->spinlock, flags);
2426
2427 psa.psa_quality_thr = *(extra) & 0x0F;
2428 psa_write(dev,
2429 (char *) &psa.psa_quality_thr - (char *) &psa,
2430 (unsigned char *) &psa.psa_quality_thr, 1);
2431
2432 update_psa_checksum(dev);
2433 mmc_out(base, mmwoff(0, mmw_quality_thr),
2434 psa.psa_quality_thr);
2435
2436
2437 spin_unlock_irqrestore(&lp->spinlock, flags);
2438
2439 return 0;
2440}
2441
2442
2443
2444
2445
2446static int wavelan_get_qthr(struct net_device *dev,
2447 struct iw_request_info *info,
2448 union iwreq_data *wrqu,
2449 char *extra)
2450{
2451 net_local *lp = netdev_priv(dev);
2452 psa_t psa;
2453 unsigned long flags;
2454
2455
2456 spin_lock_irqsave(&lp->spinlock, flags);
2457
2458 psa_read(dev,
2459 (char *) &psa.psa_quality_thr - (char *) &psa,
2460 (unsigned char *) &psa.psa_quality_thr, 1);
2461 *(extra) = psa.psa_quality_thr & 0x0F;
2462
2463
2464 spin_unlock_irqrestore(&lp->spinlock, flags);
2465
2466 return 0;
2467}
2468
2469#ifdef WAVELAN_ROAMING
2470
2471
2472
2473
2474static int wavelan_set_roam(struct net_device *dev,
2475 struct iw_request_info *info,
2476 union iwreq_data *wrqu,
2477 char *extra)
2478{
2479 net_local *lp = netdev_priv(dev);
2480 unsigned long flags;
2481
2482
2483 spin_lock_irqsave(&lp->spinlock, flags);
2484
2485
2486 if(do_roaming && (*extra)==0)
2487 wv_roam_cleanup(dev);
2488 else if(do_roaming==0 && (*extra)!=0)
2489 wv_roam_init(dev);
2490
2491 do_roaming = (*extra);
2492
2493
2494 spin_unlock_irqrestore(&lp->spinlock, flags);
2495
2496 return 0;
2497}
2498
2499
2500
2501
2502
2503static int wavelan_get_roam(struct net_device *dev,
2504 struct iw_request_info *info,
2505 union iwreq_data *wrqu,
2506 char *extra)
2507{
2508 *(extra) = do_roaming;
2509
2510 return 0;
2511}
2512#endif
2513
2514#ifdef HISTOGRAM
2515
2516
2517
2518
2519static int wavelan_set_histo(struct net_device *dev,
2520 struct iw_request_info *info,
2521 union iwreq_data *wrqu,
2522 char *extra)
2523{
2524 net_local *lp = netdev_priv(dev);
2525
2526
2527 if (wrqu->data.length > 16) {
2528 return(-E2BIG);
2529 }
2530
2531
2532
2533 lp->his_number = 0;
2534
2535
2536 if (wrqu->data.length > 0) {
2537
2538 memcpy(lp->his_range, extra, wrqu->data.length);
2539
2540 {
2541 int i;
2542 printk(KERN_DEBUG "Histo :");
2543 for(i = 0; i < wrqu->data.length; i++)
2544 printk(" %d", lp->his_range[i]);
2545 printk("\n");
2546 }
2547
2548
2549 memset(lp->his_sum, 0x00, sizeof(long) * 16);
2550 }
2551
2552
2553 lp->his_number = wrqu->data.length;
2554
2555 return(0);
2556}
2557
2558
2559
2560
2561
2562static int wavelan_get_histo(struct net_device *dev,
2563 struct iw_request_info *info,
2564 union iwreq_data *wrqu,
2565 char *extra)
2566{
2567 net_local *lp = netdev_priv(dev);
2568
2569
2570 wrqu->data.length = lp->his_number;
2571
2572
2573 if(lp->his_number > 0)
2574 memcpy(extra, lp->his_sum, sizeof(long) * lp->his_number);
2575
2576 return(0);
2577}
2578#endif
2579
2580
2581
2582
2583
2584
2585static const struct iw_priv_args wavelan_private_args[] = {
2586
2587 { SIOCSIPQTHR, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setqualthr" },
2588 { SIOCGIPQTHR, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getqualthr" },
2589 { SIOCSIPROAM, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setroam" },
2590 { SIOCGIPROAM, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getroam" },
2591 { SIOCSIPHISTO, IW_PRIV_TYPE_BYTE | 16, 0, "sethisto" },
2592 { SIOCGIPHISTO, 0, IW_PRIV_TYPE_INT | 16, "gethisto" },
2593};
2594
2595static const iw_handler wavelan_handler[] =
2596{
2597 NULL,
2598 wavelan_get_name,
2599 wavelan_set_nwid,
2600 wavelan_get_nwid,
2601 wavelan_set_freq,
2602 wavelan_get_freq,
2603#ifdef WAVELAN_ROAMING
2604 wavelan_set_mode,
2605 wavelan_get_mode,
2606#else
2607 NULL,
2608 NULL,
2609#endif
2610 wavelan_set_sens,
2611 wavelan_get_sens,
2612 NULL,
2613 wavelan_get_range,
2614 NULL,
2615 NULL,
2616 NULL,
2617 NULL,
2618 iw_handler_set_spy,
2619 iw_handler_get_spy,
2620 iw_handler_set_thrspy,
2621 iw_handler_get_thrspy,
2622#ifdef WAVELAN_ROAMING_EXT
2623 wavelan_set_wap,
2624 wavelan_get_wap,
2625 NULL,
2626 NULL,
2627 NULL,
2628 NULL,
2629 wavelan_set_essid,
2630 wavelan_get_essid,
2631#else
2632 NULL,
2633 NULL,
2634 NULL,
2635 NULL,
2636 NULL,
2637 NULL,
2638 NULL,
2639 NULL,
2640#endif
2641 NULL,
2642 NULL,
2643 NULL,
2644 NULL,
2645 NULL,
2646 NULL,
2647 NULL,
2648 NULL,
2649 NULL,
2650 NULL,
2651 NULL,
2652 NULL,
2653 NULL,
2654 NULL,
2655 wavelan_set_encode,
2656 wavelan_get_encode,
2657};
2658
2659static const iw_handler wavelan_private_handler[] =
2660{
2661 wavelan_set_qthr,
2662 wavelan_get_qthr,
2663#ifdef WAVELAN_ROAMING
2664 wavelan_set_roam,
2665 wavelan_get_roam,
2666#else
2667 NULL,
2668 NULL,
2669#endif
2670#ifdef HISTOGRAM
2671 wavelan_set_histo,
2672 wavelan_get_histo,
2673#endif
2674};
2675
2676static const struct iw_handler_def wavelan_handler_def =
2677{
2678 .num_standard = ARRAY_SIZE(wavelan_handler),
2679 .num_private = ARRAY_SIZE(wavelan_private_handler),
2680 .num_private_args = ARRAY_SIZE(wavelan_private_args),
2681 .standard = wavelan_handler,
2682 .private = wavelan_private_handler,
2683 .private_args = wavelan_private_args,
2684 .get_wireless_stats = wavelan_get_wireless_stats,
2685};
2686
2687
2688
2689
2690
2691
2692static iw_stats *
2693wavelan_get_wireless_stats(struct net_device * dev)
2694{
2695 unsigned int base = dev->base_addr;
2696 net_local * lp = netdev_priv(dev);
2697 mmr_t m;
2698 iw_stats * wstats;
2699 unsigned long flags;
2700
2701#ifdef DEBUG_IOCTL_TRACE
2702 printk(KERN_DEBUG "%s: ->wavelan_get_wireless_stats()\n", dev->name);
2703#endif
2704
2705
2706 spin_lock_irqsave(&lp->spinlock, flags);
2707
2708 wstats = &lp->wstats;
2709
2710
2711 mmc_out(base, mmwoff(0, mmw_freeze), 1);
2712
2713 mmc_read(base, mmroff(0, mmr_dce_status), &m.mmr_dce_status, 1);
2714 mmc_read(base, mmroff(0, mmr_wrong_nwid_l), &m.mmr_wrong_nwid_l, 2);
2715 mmc_read(base, mmroff(0, mmr_thr_pre_set), &m.mmr_thr_pre_set, 4);
2716
2717 mmc_out(base, mmwoff(0, mmw_freeze), 0);
2718
2719
2720 wstats->status = m.mmr_dce_status & MMR_DCE_STATUS;
2721 wstats->qual.qual = m.mmr_sgnl_qual & MMR_SGNL_QUAL;
2722 wstats->qual.level = m.mmr_signal_lvl & MMR_SIGNAL_LVL;
2723 wstats->qual.noise = m.mmr_silence_lvl & MMR_SILENCE_LVL;
2724 wstats->qual.updated = (((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 7) |
2725 ((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 6) |
2726 ((m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) >> 5));
2727 wstats->discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
2728 wstats->discard.code = 0L;
2729 wstats->discard.misc = 0L;
2730
2731
2732 spin_unlock_irqrestore(&lp->spinlock, flags);
2733
2734#ifdef DEBUG_IOCTL_TRACE
2735 printk(KERN_DEBUG "%s: <-wavelan_get_wireless_stats()\n", dev->name);
2736#endif
2737 return &lp->wstats;
2738}
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753static int
2754wv_start_of_frame(struct net_device * dev,
2755 int rfp,
2756 int wrap)
2757{
2758 unsigned int base = dev->base_addr;
2759 int rp;
2760 int len;
2761
2762 rp = (rfp - 5 + RX_SIZE) % RX_SIZE;
2763 outb(rp & 0xff, PIORL(base));
2764 outb(((rp >> 8) & PIORH_MASK), PIORH(base));
2765 len = inb(PIOP(base));
2766 len |= inb(PIOP(base)) << 8;
2767
2768
2769
2770 if(len > MAXDATAZ + 100)
2771 {
2772#ifdef DEBUG_RX_ERROR
2773 printk(KERN_INFO "%s: wv_start_of_frame: Received frame too large, rfp %d len 0x%x\n",
2774 dev->name, rfp, len);
2775#endif
2776 return(-1);
2777 }
2778
2779
2780 if(len < 7)
2781 {
2782#ifdef DEBUG_RX_ERROR
2783 printk(KERN_INFO "%s: wv_start_of_frame: Received null frame, rfp %d len 0x%x\n",
2784 dev->name, rfp, len);
2785#endif
2786 return(-1);
2787 }
2788
2789
2790 if(len > ((wrap - (rfp - len) + RX_SIZE) % RX_SIZE))
2791 {
2792#ifdef DEBUG_RX_ERROR
2793 printk(KERN_INFO "%s: wv_start_of_frame: wrap around buffer, wrap %d rfp %d len 0x%x\n",
2794 dev->name, wrap, rfp, len);
2795#endif
2796 return(-1);
2797 }
2798
2799 return((rp - len + RX_SIZE) % RX_SIZE);
2800}
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815static void
2816wv_packet_read(struct net_device * dev,
2817 int fd_p,
2818 int sksize)
2819{
2820 net_local * lp = netdev_priv(dev);
2821 struct sk_buff * skb;
2822
2823#ifdef DEBUG_RX_TRACE
2824 printk(KERN_DEBUG "%s: ->wv_packet_read(0x%X, %d)\n",
2825 dev->name, fd_p, sksize);
2826#endif
2827
2828
2829 if((skb = dev_alloc_skb(sksize+2)) == (struct sk_buff *) NULL)
2830 {
2831#ifdef DEBUG_RX_ERROR
2832 printk(KERN_INFO "%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC)\n",
2833 dev->name, sksize);
2834#endif
2835 lp->stats.rx_dropped++;
2836
2837
2838
2839
2840 return;
2841 }
2842
2843 skb_reserve(skb, 2);
2844 fd_p = read_ringbuf(dev, fd_p, (char *) skb_put(skb, sksize), sksize);
2845 skb->protocol = eth_type_trans(skb, dev);
2846
2847#ifdef DEBUG_RX_INFO
2848 wv_packet_info(skb_mac_header(skb), sksize, dev->name, "wv_packet_read");
2849#endif
2850
2851
2852
2853 if(
2854#ifdef IW_WIRELESS_SPY
2855 (lp->spy_data.spy_number > 0) ||
2856#endif
2857#ifdef HISTOGRAM
2858 (lp->his_number > 0) ||
2859#endif
2860#ifdef WAVELAN_ROAMING
2861 (do_roaming) ||
2862#endif
2863 0)
2864 {
2865 u_char stats[3];
2866
2867
2868 fd_p = read_ringbuf(dev, (fd_p + 4) % RX_SIZE + RX_BASE,
2869 stats, 3);
2870#ifdef DEBUG_RX_INFO
2871 printk(KERN_DEBUG "%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n",
2872 dev->name, stats[0] & 0x3F, stats[1] & 0x3F, stats[2] & 0x0F);
2873#endif
2874
2875#ifdef WAVELAN_ROAMING
2876 if(do_roaming)
2877 if(WAVELAN_BEACON(skb->data))
2878 wl_roam_gather(dev, skb->data, stats);
2879#endif
2880
2881#ifdef WIRELESS_SPY
2882 wl_spy_gather(dev, skb_mac_header(skb) + WAVELAN_ADDR_SIZE, stats);
2883#endif
2884#ifdef HISTOGRAM
2885 wl_his_gather(dev, stats);
2886#endif
2887 }
2888
2889
2890
2891
2892 netif_rx(skb);
2893
2894
2895 dev->last_rx = jiffies;
2896 lp->stats.rx_packets++;
2897 lp->stats.rx_bytes += sksize;
2898
2899#ifdef DEBUG_RX_TRACE
2900 printk(KERN_DEBUG "%s: <-wv_packet_read()\n", dev->name);
2901#endif
2902 return;
2903}
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916static void
2917wv_packet_rcv(struct net_device * dev)
2918{
2919 unsigned int base = dev->base_addr;
2920 net_local * lp = netdev_priv(dev);
2921 int newrfp;
2922 int rp;
2923 int len;
2924 int f_start;
2925 int status;
2926 int i593_rfp;
2927 int stat_ptr;
2928 u_char c[4];
2929
2930#ifdef DEBUG_RX_TRACE
2931 printk(KERN_DEBUG "%s: ->wv_packet_rcv()\n", dev->name);
2932#endif
2933
2934
2935 outb(CR0_STATUS_2 | OP0_NOP, LCCR(base));
2936 i593_rfp = inb(LCSR(base));
2937 i593_rfp |= inb(LCSR(base)) << 8;
2938 i593_rfp %= RX_SIZE;
2939
2940
2941
2942
2943
2944
2945 newrfp = inb(RPLL(base));
2946 newrfp |= inb(RPLH(base)) << 8;
2947 newrfp %= RX_SIZE;
2948
2949#ifdef DEBUG_RX_INFO
2950 printk(KERN_DEBUG "%s: wv_packet_rcv(): i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2951 dev->name, i593_rfp, lp->stop, newrfp, lp->rfp);
2952#endif
2953
2954#ifdef DEBUG_RX_ERROR
2955
2956 if(lp->overrunning || newrfp == lp->rfp)
2957 printk(KERN_INFO "%s: wv_packet_rcv(): no new frame: i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2958 dev->name, i593_rfp, lp->stop, newrfp, lp->rfp);
2959#endif
2960
2961
2962 while(newrfp != lp->rfp)
2963 {
2964
2965
2966
2967
2968
2969
2970 rp = newrfp;
2971 while(((f_start = wv_start_of_frame(dev, rp, newrfp)) != lp->rfp) &&
2972 (f_start != -1))
2973 rp = f_start;
2974
2975
2976 if(f_start == -1)
2977 {
2978#ifdef DEBUG_RX_ERROR
2979 printk(KERN_INFO "wavelan_cs: cannot find start of frame ");
2980 printk(" i593_rfp %d stop %d newrfp %d lp->rfp %d\n",
2981 i593_rfp, lp->stop, newrfp, lp->rfp);
2982#endif
2983 lp->rfp = rp;
2984 continue;
2985 }
2986
2987
2988
2989
2990
2991 stat_ptr = (rp - 7 + RX_SIZE) % RX_SIZE;
2992 stat_ptr = read_ringbuf(dev, stat_ptr, c, 4);
2993 status = c[0] | (c[1] << 8);
2994 len = c[2] | (c[3] << 8);
2995
2996
2997 if((status & RX_RCV_OK) != RX_RCV_OK)
2998 {
2999 lp->stats.rx_errors++;
3000 if(status & RX_NO_SFD)
3001 lp->stats.rx_frame_errors++;
3002 if(status & RX_CRC_ERR)
3003 lp->stats.rx_crc_errors++;
3004 if(status & RX_OVRRUN)
3005 lp->stats.rx_over_errors++;
3006
3007#ifdef DEBUG_RX_FAIL
3008 printk(KERN_DEBUG "%s: wv_packet_rcv(): packet not received ok, status = 0x%x\n",
3009 dev->name, status);
3010#endif
3011 }
3012 else
3013
3014 wv_packet_read(dev, f_start, len - 2);
3015
3016
3017 lp->rfp = rp;
3018 }
3019
3020
3021
3022
3023
3024
3025 lp->stop = (i593_rfp + RX_SIZE - ((RX_SIZE / 64) * 3)) % RX_SIZE;
3026 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, LCCR(base));
3027 outb(CR1_STOP_REG_UPDATE | (lp->stop >> RX_SIZE_SHIFT), LCCR(base));
3028 outb(OP1_SWIT_TO_PORT_0, LCCR(base));
3029
3030#ifdef DEBUG_RX_TRACE
3031 printk(KERN_DEBUG "%s: <-wv_packet_rcv()\n", dev->name);
3032#endif
3033}
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050static void
3051wv_packet_write(struct net_device * dev,
3052 void * buf,
3053 short length)
3054{
3055 net_local * lp = netdev_priv(dev);
3056 unsigned int base = dev->base_addr;
3057 unsigned long flags;
3058 int clen = length;
3059 register u_short xmtdata_base = TX_BASE;
3060
3061#ifdef DEBUG_TX_TRACE
3062 printk(KERN_DEBUG "%s: ->wv_packet_write(%d)\n", dev->name, length);
3063#endif
3064
3065 spin_lock_irqsave(&lp->spinlock, flags);
3066
3067
3068 outb(xmtdata_base & 0xff, PIORL(base));
3069 outb(((xmtdata_base >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3070 outb(clen & 0xff, PIOP(base));
3071 outb(clen >> 8, PIOP(base));
3072
3073
3074 outsb(PIOP(base), buf, clen);
3075
3076
3077 outb(OP0_NOP, PIOP(base));
3078
3079 outb(OP0_NOP, PIOP(base));
3080
3081
3082 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3083 hacr_write(base, HACR_DEFAULT);
3084
3085 wv_82593_cmd(dev, "wv_packet_write(): transmit",
3086 OP0_TRANSMIT, SR0_NO_RESULT);
3087
3088
3089 dev->trans_start = jiffies;
3090
3091
3092 lp->stats.tx_bytes += length;
3093
3094 spin_unlock_irqrestore(&lp->spinlock, flags);
3095
3096#ifdef DEBUG_TX_INFO
3097 wv_packet_info((u_char *) buf, length, dev->name, "wv_packet_write");
3098#endif
3099
3100#ifdef DEBUG_TX_TRACE
3101 printk(KERN_DEBUG "%s: <-wv_packet_write()\n", dev->name);
3102#endif
3103}
3104
3105
3106
3107
3108
3109
3110
3111
3112static int
3113wavelan_packet_xmit(struct sk_buff * skb,
3114 struct net_device * dev)
3115{
3116 net_local * lp = netdev_priv(dev);
3117 unsigned long flags;
3118
3119#ifdef DEBUG_TX_TRACE
3120 printk(KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name,
3121 (unsigned) skb);
3122#endif
3123
3124
3125
3126
3127
3128 netif_stop_queue(dev);
3129
3130
3131
3132 if(lp->reconfig_82593)
3133 {
3134 spin_lock_irqsave(&lp->spinlock, flags);
3135 wv_82593_config(dev);
3136 spin_unlock_irqrestore(&lp->spinlock, flags);
3137
3138
3139 }
3140
3141#ifdef DEBUG_TX_ERROR
3142 if (skb->next)
3143 printk(KERN_INFO "skb has next\n");
3144#endif
3145
3146
3147
3148
3149
3150
3151 if (skb_padto(skb, ETH_ZLEN))
3152 return 0;
3153
3154 wv_packet_write(dev, skb->data, skb->len);
3155
3156 dev_kfree_skb(skb);
3157
3158#ifdef DEBUG_TX_TRACE
3159 printk(KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name);
3160#endif
3161 return(0);
3162}
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174static int
3175wv_mmc_init(struct net_device * dev)
3176{
3177 unsigned int base = dev->base_addr;
3178 psa_t psa;
3179 mmw_t m;
3180 int configured;
3181 int i;
3182
3183#ifdef DEBUG_CONFIG_TRACE
3184 printk(KERN_DEBUG "%s: ->wv_mmc_init()\n", dev->name);
3185#endif
3186
3187
3188 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
3189
3190
3191
3192
3193
3194
3195
3196 for (i = 0; i < ARRAY_SIZE(MAC_ADDRESSES); i++)
3197 if ((psa.psa_univ_mac_addr[0] == MAC_ADDRESSES[i][0]) &&
3198 (psa.psa_univ_mac_addr[1] == MAC_ADDRESSES[i][1]) &&
3199 (psa.psa_univ_mac_addr[2] == MAC_ADDRESSES[i][2]))
3200 break;
3201
3202
3203 if (i == ARRAY_SIZE(MAC_ADDRESSES))
3204 {
3205#ifdef DEBUG_CONFIG_ERRORS
3206 printk(KERN_WARNING "%s: wv_mmc_init(): Invalid MAC address: %02X:%02X:%02X:...\n",
3207 dev->name, psa.psa_univ_mac_addr[0],
3208 psa.psa_univ_mac_addr[1], psa.psa_univ_mac_addr[2]);
3209#endif
3210 return FALSE;
3211 }
3212
3213
3214 memcpy(&dev->dev_addr[0], &psa.psa_univ_mac_addr[0], WAVELAN_ADDR_SIZE);
3215
3216#ifdef USE_PSA_CONFIG
3217 configured = psa.psa_conf_status & 1;
3218#else
3219 configured = 0;
3220#endif
3221
3222
3223 if(!configured)
3224 {
3225
3226 psa.psa_nwid[0] = 0;
3227 psa.psa_nwid[1] = 0;
3228
3229
3230 psa.psa_nwid_select = 0;
3231
3232
3233 psa.psa_encryption_select = 0;
3234
3235
3236
3237
3238
3239
3240 if (psa.psa_comp_number & 1)
3241 psa.psa_thr_pre_set = 0x01;
3242 else
3243 psa.psa_thr_pre_set = 0x04;
3244 psa.psa_quality_thr = 0x03;
3245
3246
3247 psa.psa_conf_status |= 1;
3248
3249#ifdef USE_PSA_CONFIG
3250
3251 psa_write(dev, (char *)psa.psa_nwid - (char *)&psa,
3252 (unsigned char *)psa.psa_nwid, 4);
3253 psa_write(dev, (char *)&psa.psa_thr_pre_set - (char *)&psa,
3254 (unsigned char *)&psa.psa_thr_pre_set, 1);
3255 psa_write(dev, (char *)&psa.psa_quality_thr - (char *)&psa,
3256 (unsigned char *)&psa.psa_quality_thr, 1);
3257 psa_write(dev, (char *)&psa.psa_conf_status - (char *)&psa,
3258 (unsigned char *)&psa.psa_conf_status, 1);
3259
3260 update_psa_checksum(dev);
3261#endif
3262 }
3263
3264
3265 memset(&m, 0x00, sizeof(m));
3266
3267
3268 m.mmw_netw_id_l = psa.psa_nwid[1];
3269 m.mmw_netw_id_h = psa.psa_nwid[0];
3270
3271 if(psa.psa_nwid_select & 1)
3272 m.mmw_loopt_sel = 0x00;
3273 else
3274 m.mmw_loopt_sel = MMW_LOOPT_SEL_DIS_NWID;
3275
3276 memcpy(&m.mmw_encr_key, &psa.psa_encryption_key,
3277 sizeof(m.mmw_encr_key));
3278
3279 if(psa.psa_encryption_select)
3280 m.mmw_encr_enable = MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE;
3281 else
3282 m.mmw_encr_enable = 0;
3283
3284 m.mmw_thr_pre_set = psa.psa_thr_pre_set & 0x3F;
3285 m.mmw_quality_thr = psa.psa_quality_thr & 0x0F;
3286
3287
3288
3289
3290
3291 m.mmw_jabber_enable = 0x01;
3292 m.mmw_anten_sel = MMW_ANTEN_SEL_ALG_EN;
3293 m.mmw_ifs = 0x20;
3294 m.mmw_mod_delay = 0x04;
3295 m.mmw_jam_time = 0x38;
3296
3297 m.mmw_des_io_invert = 0;
3298 m.mmw_freeze = 0;
3299 m.mmw_decay_prm = 0;
3300 m.mmw_decay_updat_prm = 0;
3301
3302
3303 mmc_write(base, 0, (u_char *)&m, sizeof(m));
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319 if(!(mmc_in(base, mmroff(0, mmr_fee_status)) &
3320 (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY)))
3321 {
3322
3323
3324
3325
3326 m.mmw_fee_addr = 0x0F;
3327 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3328 mmc_write(base, (char *)&m.mmw_fee_ctrl - (char *)&m,
3329 (unsigned char *)&m.mmw_fee_ctrl, 2);
3330
3331
3332 fee_wait(base, 100, 100);
3333
3334#ifdef DEBUG_CONFIG_INFO
3335
3336 mmc_read(base, (char *)&m.mmw_fee_data_l - (char *)&m,
3337 (unsigned char *)&m.mmw_fee_data_l, 2);
3338
3339
3340 printk(KERN_DEBUG "%s: Wavelan 2.00 recognised (frequency select) : Current frequency = %ld\n",
3341 dev->name,
3342 ((m.mmw_fee_data_h << 4) |
3343 (m.mmw_fee_data_l >> 4)) * 5 / 2 + 24000L);
3344#endif
3345
3346
3347
3348 m.mmw_fee_addr = 0x61;
3349 m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD;
3350 mmc_write(base, (char *)&m.mmw_fee_ctrl - (char *)&m,
3351 (unsigned char *)&m.mmw_fee_ctrl, 2);
3352
3353
3354 }
3355
3356#ifdef DEBUG_CONFIG_TRACE
3357 printk(KERN_DEBUG "%s: <-wv_mmc_init()\n", dev->name);
3358#endif
3359 return TRUE;
3360}
3361
3362
3363
3364
3365
3366
3367
3368static int
3369wv_ru_stop(struct net_device * dev)
3370{
3371 unsigned int base = dev->base_addr;
3372 net_local * lp = netdev_priv(dev);
3373 unsigned long flags;
3374 int status;
3375 int spin;
3376
3377#ifdef DEBUG_CONFIG_TRACE
3378 printk(KERN_DEBUG "%s: ->wv_ru_stop()\n", dev->name);
3379#endif
3380
3381 spin_lock_irqsave(&lp->spinlock, flags);
3382
3383
3384 wv_82593_cmd(dev, "wv_graceful_shutdown(): stop-rcv",
3385 OP0_STOP_RCV, SR0_NO_RESULT);
3386
3387
3388 spin = 300;
3389 do
3390 {
3391 udelay(10);
3392 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
3393 status = inb(LCSR(base));
3394 }
3395 while(((status & SR3_RCV_STATE_MASK) != SR3_RCV_IDLE) && (spin-- > 0));
3396
3397
3398 do
3399 {
3400 udelay(10);
3401 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
3402 status = inb(LCSR(base));
3403 }
3404 while(((status & SR3_EXEC_STATE_MASK) != SR3_EXEC_IDLE) && (spin-- > 0));
3405
3406 spin_unlock_irqrestore(&lp->spinlock, flags);
3407
3408
3409 if(spin <= 0)
3410 {
3411#ifdef DEBUG_CONFIG_ERRORS
3412 printk(KERN_INFO "%s: wv_ru_stop(): The chip doesn't want to stop...\n",
3413 dev->name);
3414#endif
3415 return FALSE;
3416 }
3417
3418#ifdef DEBUG_CONFIG_TRACE
3419 printk(KERN_DEBUG "%s: <-wv_ru_stop()\n", dev->name);
3420#endif
3421 return TRUE;
3422}
3423
3424
3425
3426
3427
3428
3429
3430
3431static int
3432wv_ru_start(struct net_device * dev)
3433{
3434 unsigned int base = dev->base_addr;
3435 net_local * lp = netdev_priv(dev);
3436 unsigned long flags;
3437
3438#ifdef DEBUG_CONFIG_TRACE
3439 printk(KERN_DEBUG "%s: ->wv_ru_start()\n", dev->name);
3440#endif
3441
3442
3443
3444
3445
3446
3447 if(!wv_ru_stop(dev))
3448 return FALSE;
3449
3450 spin_lock_irqsave(&lp->spinlock, flags);
3451
3452
3453
3454
3455 lp->rfp = 0;
3456 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, LCCR(base));
3457
3458
3459 outb(OP1_RESET_RING_MNGMT, LCCR(base));
3460
3461
3462
3463
3464
3465
3466
3467 lp->stop = 0;
3468#else
3469
3470 lp->stop = (0 + RX_SIZE - ((RX_SIZE / 64) * 3)) % RX_SIZE;
3471#endif
3472 outb(CR1_STOP_REG_UPDATE | (lp->stop >> RX_SIZE_SHIFT), LCCR(base));
3473 outb(OP1_INT_ENABLE, LCCR(base));
3474 outb(OP1_SWIT_TO_PORT_0, LCCR(base));
3475
3476
3477 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3478 hacr_write_slow(base, HACR_DEFAULT);
3479
3480
3481 wv_82593_cmd(dev, "wv_ru_start(): rcv-enable",
3482 CR0_CHNL | OP0_RCV_ENABLE, SR0_NO_RESULT);
3483
3484#ifdef DEBUG_I82593_SHOW
3485 {
3486 int status;
3487 int opri;
3488 int spin = 10000;
3489
3490
3491 do
3492 {
3493 outb(OP0_NOP | CR0_STATUS_3, LCCR(base));
3494 status = inb(LCSR(base));
3495 if(spin-- <= 0)
3496 break;
3497 }
3498 while(((status & SR3_RCV_STATE_MASK) != SR3_RCV_ACTIVE) &&
3499 ((status & SR3_RCV_STATE_MASK) != SR3_RCV_READY));
3500 printk(KERN_DEBUG "rcv status is 0x%x [i:%d]\n",
3501 (status & SR3_RCV_STATE_MASK), i);
3502 }
3503#endif
3504
3505 spin_unlock_irqrestore(&lp->spinlock, flags);
3506
3507#ifdef DEBUG_CONFIG_TRACE
3508 printk(KERN_DEBUG "%s: <-wv_ru_start()\n", dev->name);
3509#endif
3510 return TRUE;
3511}
3512
3513
3514
3515
3516
3517
3518
3519static int
3520wv_82593_config(struct net_device * dev)
3521{
3522 unsigned int base = dev->base_addr;
3523 net_local * lp = netdev_priv(dev);
3524 struct i82593_conf_block cfblk;
3525 int ret = TRUE;
3526
3527#ifdef DEBUG_CONFIG_TRACE
3528 printk(KERN_DEBUG "%s: ->wv_82593_config()\n", dev->name);
3529#endif
3530
3531
3532
3533
3534
3535 memset(&cfblk, 0x00, sizeof(struct i82593_conf_block));
3536 cfblk.d6mod = FALSE;
3537 cfblk.fifo_limit = 5;
3538 cfblk.forgnesi = FALSE;
3539 cfblk.fifo_32 = 1;
3540 cfblk.throttle_enb = FALSE;
3541 cfblk.contin = TRUE;
3542 cfblk.cntrxint = FALSE;
3543 cfblk.addr_len = WAVELAN_ADDR_SIZE;
3544 cfblk.acloc = TRUE;
3545 cfblk.preamb_len = 0;
3546 cfblk.loopback = FALSE;
3547 cfblk.lin_prio = 0;
3548 cfblk.exp_prio = 5;
3549 cfblk.bof_met = 1;
3550 cfblk.ifrm_spc = 0x20 >> 4;
3551 cfblk.slottim_low = 0x20 >> 5;
3552 cfblk.slottim_hi = 0x0;
3553 cfblk.max_retr = 15;
3554 cfblk.prmisc = ((lp->promiscuous) ? TRUE: FALSE);
3555 cfblk.bc_dis = FALSE;
3556 cfblk.crs_1 = TRUE;
3557 cfblk.nocrc_ins = FALSE;
3558 cfblk.crc_1632 = FALSE;
3559 cfblk.crs_cdt = FALSE;
3560 cfblk.cs_filter = 0;
3561 cfblk.crs_src = FALSE;
3562 cfblk.cd_filter = 0;
3563 cfblk.min_fr_len = ETH_ZLEN >> 2;
3564 cfblk.lng_typ = FALSE;
3565 cfblk.lng_fld = TRUE;
3566 cfblk.rxcrc_xf = TRUE;
3567 cfblk.artx = TRUE;
3568 cfblk.sarec = TRUE;
3569 cfblk.tx_jabber = TRUE;
3570 cfblk.hash_1 = FALSE;
3571 cfblk.lbpkpol = TRUE;
3572 cfblk.fdx = FALSE;
3573 cfblk.dummy_6 = 0x3f;
3574 cfblk.mult_ia = FALSE;
3575 cfblk.dis_bof = FALSE;
3576 cfblk.dummy_1 = TRUE;
3577 cfblk.tx_ifs_retrig = 3;
3578#ifdef MULTICAST_ALL
3579 cfblk.mc_all = (lp->allmulticast ? TRUE: FALSE);
3580#else
3581 cfblk.mc_all = FALSE;
3582#endif
3583 cfblk.rcv_mon = 0;
3584 cfblk.frag_acpt = TRUE;
3585 cfblk.tstrttrs = FALSE;
3586 cfblk.fretx = TRUE;
3587 cfblk.syncrqs = FALSE;
3588 cfblk.sttlen = TRUE;
3589 cfblk.rx_eop = TRUE;
3590 cfblk.tx_eop = TRUE;
3591 cfblk.rbuf_size = RX_SIZE>>11;
3592 cfblk.rcvstop = TRUE;
3593
3594#ifdef DEBUG_I82593_SHOW
3595 {
3596 u_char *c = (u_char *) &cfblk;
3597 int i;
3598 printk(KERN_DEBUG "wavelan_cs: config block:");
3599 for(i = 0; i < sizeof(struct i82593_conf_block); i++,c++)
3600 {
3601 if((i % 16) == 0) printk("\n" KERN_DEBUG);
3602 printk("%02x ", *c);
3603 }
3604 printk("\n");
3605 }
3606#endif
3607
3608
3609 outb(TX_BASE & 0xff, PIORL(base));
3610 outb(((TX_BASE >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3611 outb(sizeof(struct i82593_conf_block) & 0xff, PIOP(base));
3612 outb(sizeof(struct i82593_conf_block) >> 8, PIOP(base));
3613 outsb(PIOP(base), (char *) &cfblk, sizeof(struct i82593_conf_block));
3614
3615
3616 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3617 hacr_write(base, HACR_DEFAULT);
3618 if(!wv_82593_cmd(dev, "wv_82593_config(): configure",
3619 OP0_CONFIGURE, SR0_CONFIGURE_DONE))
3620 ret = FALSE;
3621
3622
3623 outb(TX_BASE & 0xff, PIORL(base));
3624 outb(((TX_BASE >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3625 outb(WAVELAN_ADDR_SIZE, PIOP(base));
3626 outb(0, PIOP(base));
3627 outsb(PIOP(base), &dev->dev_addr[0], WAVELAN_ADDR_SIZE);
3628
3629
3630 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3631 hacr_write(base, HACR_DEFAULT);
3632 if(!wv_82593_cmd(dev, "wv_82593_config(): ia-setup",
3633 OP0_IA_SETUP, SR0_IA_SETUP_DONE))
3634 ret = FALSE;
3635
3636#ifdef WAVELAN_ROAMING
3637
3638
3639 if(do_roaming)
3640 dev_mc_add(dev,WAVELAN_BEACON_ADDRESS, WAVELAN_ADDR_SIZE, 1);
3641#endif
3642
3643
3644 if(lp->mc_count)
3645 {
3646 struct dev_mc_list * dmi;
3647 int addrs_len = WAVELAN_ADDR_SIZE * lp->mc_count;
3648
3649#ifdef DEBUG_CONFIG_INFO
3650 DECLARE_MAC_BUF(mac);
3651 printk(KERN_DEBUG "%s: wv_hw_config(): set %d multicast addresses:\n",
3652 dev->name, lp->mc_count);
3653 for(dmi=dev->mc_list; dmi; dmi=dmi->next)
3654 printk(KERN_DEBUG " %s\n",
3655 print_mac(mac, dmi->dmi_addr));
3656#endif
3657
3658
3659 outb(TX_BASE & 0xff, PIORL(base));
3660 outb(((TX_BASE >> 8) & PIORH_MASK) | PIORH_SEL_TX, PIORH(base));
3661 outb(addrs_len & 0xff, PIOP(base));
3662 outb((addrs_len >> 8), PIOP(base));
3663 for(dmi=dev->mc_list; dmi; dmi=dmi->next)
3664 outsb(PIOP(base), dmi->dmi_addr, dmi->dmi_addrlen);
3665
3666
3667 hacr_write_slow(base, HACR_PWR_STAT | HACR_TX_DMA_RESET);
3668 hacr_write(base, HACR_DEFAULT);
3669 if(!wv_82593_cmd(dev, "wv_82593_config(): mc-setup",
3670 OP0_MC_SETUP, SR0_MC_SETUP_DONE))
3671 ret = FALSE;
3672 lp->mc_count = dev->mc_count;
3673 }
3674
3675
3676 lp->reconfig_82593 = FALSE;
3677
3678#ifdef DEBUG_CONFIG_TRACE
3679 printk(KERN_DEBUG "%s: <-wv_82593_config()\n", dev->name);
3680#endif
3681 return(ret);
3682}
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693static int
3694wv_pcmcia_reset(struct net_device * dev)
3695{
3696 int i;
3697 conf_reg_t reg = { 0, CS_READ, CISREG_COR, 0 };
3698 struct pcmcia_device * link = ((net_local *)netdev_priv(dev))->link;
3699
3700#ifdef DEBUG_CONFIG_TRACE
3701 printk(KERN_DEBUG "%s: ->wv_pcmcia_reset()\n", dev->name);
3702#endif
3703
3704 i = pcmcia_access_configuration_register(link, ®);
3705 if (i != 0)
3706 {
3707 cs_error(link, AccessConfigurationRegister, i);
3708 return FALSE;
3709 }
3710
3711#ifdef DEBUG_CONFIG_INFO
3712 printk(KERN_DEBUG "%s: wavelan_pcmcia_reset(): Config reg is 0x%x\n",
3713 dev->name, (u_int) reg.Value);
3714#endif
3715
3716 reg.Action = CS_WRITE;
3717 reg.Value = reg.Value | COR_SW_RESET;
3718 i = pcmcia_access_configuration_register(link, ®);
3719 if (i != 0)
3720 {
3721 cs_error(link, AccessConfigurationRegister, i);
3722 return FALSE;
3723 }
3724
3725 reg.Action = CS_WRITE;
3726 reg.Value = COR_LEVEL_IRQ | COR_CONFIG;
3727 i = pcmcia_access_configuration_register(link, ®);
3728 if (i != 0)
3729 {
3730 cs_error(link, AccessConfigurationRegister, i);
3731 return FALSE;
3732 }
3733
3734#ifdef DEBUG_CONFIG_TRACE
3735 printk(KERN_DEBUG "%s: <-wv_pcmcia_reset()\n", dev->name);
3736#endif
3737 return TRUE;
3738}
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755static int
3756wv_hw_config(struct net_device * dev)
3757{
3758 net_local * lp = netdev_priv(dev);
3759 unsigned int base = dev->base_addr;
3760 unsigned long flags;
3761 int ret = FALSE;
3762
3763#ifdef DEBUG_CONFIG_TRACE
3764 printk(KERN_DEBUG "%s: ->wv_hw_config()\n", dev->name);
3765#endif
3766
3767
3768 BUILD_BUG_ON(sizeof(psa_t) != PSA_SIZE);
3769 BUILD_BUG_ON(sizeof(mmw_t) != MMW_SIZE);
3770 BUILD_BUG_ON(sizeof(mmr_t) != MMR_SIZE);
3771
3772
3773 if(wv_pcmcia_reset(dev) == FALSE)
3774 return FALSE;
3775
3776
3777 spin_lock_irqsave(&lp->spinlock, flags);
3778
3779
3780 do
3781 {
3782
3783
3784 hacr_write_slow(base, HACR_RESET);
3785 hacr_write(base, HACR_DEFAULT);
3786
3787
3788 if(hasr_read(base) & HASR_NO_CLK)
3789 {
3790#ifdef DEBUG_CONFIG_ERRORS
3791 printk(KERN_WARNING "%s: wv_hw_config(): modem not connected or not a wavelan card\n",
3792 dev->name);
3793#endif
3794 break;
3795 }
3796
3797
3798 if(wv_mmc_init(dev) == FALSE)
3799 {
3800#ifdef DEBUG_CONFIG_ERRORS
3801 printk(KERN_WARNING "%s: wv_hw_config(): Can't configure the modem\n",
3802 dev->name);
3803#endif
3804 break;
3805 }
3806
3807
3808 outb(OP0_RESET, LCCR(base));
3809 mdelay(1);
3810
3811
3812 if(wv_82593_config(dev) == FALSE)
3813 {
3814#ifdef DEBUG_CONFIG_ERRORS
3815 printk(KERN_INFO "%s: wv_hw_config(): i82593 init failed\n",
3816 dev->name);
3817#endif
3818 break;
3819 }
3820
3821
3822 if(wv_diag(dev) == FALSE)
3823 {
3824#ifdef DEBUG_CONFIG_ERRORS
3825 printk(KERN_INFO "%s: wv_hw_config(): i82593 diagnostic failed\n",
3826 dev->name);
3827#endif
3828 break;
3829 }
3830
3831
3832
3833
3834
3835
3836 lp->configured = 1;
3837 ret = TRUE;
3838 }
3839 while(0);
3840
3841
3842 spin_unlock_irqrestore(&lp->spinlock, flags);
3843
3844#ifdef DEBUG_CONFIG_TRACE
3845 printk(KERN_DEBUG "%s: <-wv_hw_config()\n", dev->name);
3846#endif
3847 return(ret);
3848}
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858static void
3859wv_hw_reset(struct net_device * dev)
3860{
3861 net_local * lp = netdev_priv(dev);
3862
3863#ifdef DEBUG_CONFIG_TRACE
3864 printk(KERN_DEBUG "%s: ->wv_hw_reset()\n", dev->name);
3865#endif
3866
3867 lp->nresets++;
3868 lp->configured = 0;
3869
3870
3871 if(wv_hw_config(dev) == FALSE)
3872 return;
3873
3874
3875 wv_ru_start(dev);
3876
3877#ifdef DEBUG_CONFIG_TRACE
3878 printk(KERN_DEBUG "%s: <-wv_hw_reset()\n", dev->name);
3879#endif
3880}
3881
3882
3883
3884
3885
3886
3887
3888
3889static int
3890wv_pcmcia_config(struct pcmcia_device * link)
3891{
3892 struct net_device * dev = (struct net_device *) link->priv;
3893 int i;
3894 win_req_t req;
3895 memreq_t mem;
3896 net_local * lp = netdev_priv(dev);
3897
3898
3899#ifdef DEBUG_CONFIG_TRACE
3900 printk(KERN_DEBUG "->wv_pcmcia_config(0x%p)\n", link);
3901#endif
3902
3903 do
3904 {
3905 i = pcmcia_request_io(link, &link->io);
3906 if (i != 0)
3907 {
3908 cs_error(link, RequestIO, i);
3909 break;
3910 }
3911
3912
3913
3914
3915
3916 i = pcmcia_request_irq(link, &link->irq);
3917 if (i != 0)
3918 {
3919 cs_error(link, RequestIRQ, i);
3920 break;
3921 }
3922
3923
3924
3925
3926
3927 link->conf.ConfigIndex = 1;
3928 i = pcmcia_request_configuration(link, &link->conf);
3929 if (i != 0)
3930 {
3931 cs_error(link, RequestConfiguration, i);
3932 break;
3933 }
3934
3935
3936
3937
3938
3939
3940
3941 req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
3942 req.Base = req.Size = 0;
3943 req.AccessSpeed = mem_speed;
3944 i = pcmcia_request_window(&link, &req, &link->win);
3945 if (i != 0)
3946 {
3947 cs_error(link, RequestWindow, i);
3948 break;
3949 }
3950
3951 lp->mem = ioremap(req.Base, req.Size);
3952 dev->mem_start = (u_long)lp->mem;
3953 dev->mem_end = dev->mem_start + req.Size;
3954
3955 mem.CardOffset = 0; mem.Page = 0;
3956 i = pcmcia_map_mem_page(link->win, &mem);
3957 if (i != 0)
3958 {
3959 cs_error(link, MapMemPage, i);
3960 break;
3961 }
3962
3963
3964 dev->irq = link->irq.AssignedIRQ;
3965 dev->base_addr = link->io.BasePort1;
3966 netif_start_queue(dev);
3967
3968#ifdef DEBUG_CONFIG_INFO
3969 printk(KERN_DEBUG "wv_pcmcia_config: MEMSTART %p IRQ %d IOPORT 0x%x\n",
3970 lp->mem, dev->irq, (u_int) dev->base_addr);
3971#endif
3972
3973 SET_NETDEV_DEV(dev, &handle_to_dev(link));
3974 i = register_netdev(dev);
3975 if(i != 0)
3976 {
3977#ifdef DEBUG_CONFIG_ERRORS
3978 printk(KERN_INFO "wv_pcmcia_config(): register_netdev() failed\n");
3979#endif
3980 break;
3981 }
3982 }
3983 while(0);
3984
3985
3986 if(i != 0)
3987 {
3988 wv_pcmcia_release(link);
3989 return FALSE;
3990 }
3991
3992 strcpy(((net_local *) netdev_priv(dev))->node.dev_name, dev->name);
3993 link->dev_node = &((net_local *) netdev_priv(dev))->node;
3994
3995#ifdef DEBUG_CONFIG_TRACE
3996 printk(KERN_DEBUG "<-wv_pcmcia_config()\n");
3997#endif
3998 return TRUE;
3999}
4000
4001
4002
4003
4004
4005
4006
4007static void
4008wv_pcmcia_release(struct pcmcia_device *link)
4009{
4010 struct net_device * dev = (struct net_device *) link->priv;
4011 net_local * lp = netdev_priv(dev);
4012
4013#ifdef DEBUG_CONFIG_TRACE
4014 printk(KERN_DEBUG "%s: -> wv_pcmcia_release(0x%p)\n", dev->name, link);
4015#endif
4016
4017 iounmap(lp->mem);
4018 pcmcia_disable_device(link);
4019
4020#ifdef DEBUG_CONFIG_TRACE
4021 printk(KERN_DEBUG "%s: <- wv_pcmcia_release()\n", dev->name);
4022#endif
4023}
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035static irqreturn_t
4036wavelan_interrupt(int irq,
4037 void * dev_id)
4038{
4039 struct net_device * dev = dev_id;
4040 net_local * lp;
4041 unsigned int base;
4042 int status0;
4043 u_int tx_status;
4044
4045#ifdef DEBUG_INTERRUPT_TRACE
4046 printk(KERN_DEBUG "%s: ->wavelan_interrupt()\n", dev->name);
4047#endif
4048
4049 lp = netdev_priv(dev);
4050 base = dev->base_addr;
4051
4052#ifdef DEBUG_INTERRUPT_INFO
4053
4054 if(spin_is_locked(&lp->spinlock))
4055 printk(KERN_DEBUG
4056 "%s: wavelan_interrupt(): spinlock is already locked !!!\n",
4057 dev->name);
4058#endif
4059
4060
4061
4062
4063
4064 spin_lock(&lp->spinlock);
4065
4066
4067 while(1)
4068 {
4069
4070
4071
4072
4073 outb(CR0_STATUS_0 | OP0_NOP, LCCR(base));
4074 status0 = inb(LCSR(base));
4075
4076#ifdef DEBUG_INTERRUPT_INFO
4077 printk(KERN_DEBUG "status0 0x%x [%s => 0x%x]", status0,
4078 (status0&SR0_INTERRUPT)?"int":"no int",status0&~SR0_INTERRUPT);
4079 if(status0&SR0_INTERRUPT)
4080 {
4081 printk(" [%s => %d]\n", (status0 & SR0_CHNL) ? "chnl" :
4082 ((status0 & SR0_EXECUTION) ? "cmd" :
4083 ((status0 & SR0_RECEPTION) ? "recv" : "unknown")),
4084 (status0 & SR0_EVENT_MASK));
4085 }
4086 else
4087 printk("\n");
4088#endif
4089
4090
4091 if(!(status0 & SR0_INTERRUPT))
4092 break;
4093
4094
4095
4096
4097 if(((status0 & SR0_BOTH_RX_TX) == SR0_BOTH_RX_TX) ||
4098 ((status0 & SR0_BOTH_RX_TX) == 0x0))
4099 {
4100#ifdef DEBUG_INTERRUPT_INFO
4101 printk(KERN_INFO "%s: wv_interrupt(): bogus interrupt (or from dead card) : %X\n",
4102 dev->name, status0);
4103#endif
4104
4105 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
4106 break;
4107 }
4108
4109
4110
4111
4112
4113
4114
4115 if(status0 & SR0_RECEPTION)
4116 {
4117#ifdef DEBUG_INTERRUPT_INFO
4118 printk(KERN_DEBUG "%s: wv_interrupt(): receive\n", dev->name);
4119#endif
4120
4121 if((status0 & SR0_EVENT_MASK) == SR0_STOP_REG_HIT)
4122 {
4123#ifdef DEBUG_INTERRUPT_ERROR
4124 printk(KERN_INFO "%s: wv_interrupt(): receive buffer overflow\n",
4125 dev->name);
4126#endif
4127 lp->stats.rx_over_errors++;
4128 lp->overrunning = 1;
4129 }
4130
4131
4132 wv_packet_rcv(dev);
4133 lp->overrunning = 0;
4134
4135
4136 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
4137 continue;
4138 }
4139
4140
4141
4142
4143
4144
4145
4146
4147 if((status0 & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
4148 (status0 & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
4149 (status0 & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE)
4150 {
4151#ifdef DEBUG_TX_ERROR
4152 if((status0 & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE)
4153 printk(KERN_INFO "%s: wv_interrupt(): packet transmitted without CRC.\n",
4154 dev->name);
4155#endif
4156
4157
4158 tx_status = inb(LCSR(base));
4159 tx_status |= (inb(LCSR(base)) << 8);
4160#ifdef DEBUG_INTERRUPT_INFO
4161 printk(KERN_DEBUG "%s: wv_interrupt(): transmission done\n",
4162 dev->name);
4163 {
4164 u_int rcv_bytes;
4165 u_char status3;
4166 rcv_bytes = inb(LCSR(base));
4167 rcv_bytes |= (inb(LCSR(base)) << 8);
4168 status3 = inb(LCSR(base));
4169 printk(KERN_DEBUG "tx_status 0x%02x rcv_bytes 0x%02x status3 0x%x\n",
4170 tx_status, rcv_bytes, (u_int) status3);
4171 }
4172#endif
4173
4174 if((tx_status & TX_OK) != TX_OK)
4175 {
4176 lp->stats.tx_errors++;
4177
4178 if(tx_status & TX_FRTL)
4179 {
4180#ifdef DEBUG_TX_ERROR
4181 printk(KERN_INFO "%s: wv_interrupt(): frame too long\n",
4182 dev->name);
4183#endif
4184 }
4185 if(tx_status & TX_UND_RUN)
4186 {
4187#ifdef DEBUG_TX_FAIL
4188 printk(KERN_DEBUG "%s: wv_interrupt(): DMA underrun\n",
4189 dev->name);
4190#endif
4191 lp->stats.tx_aborted_errors++;
4192 }
4193 if(tx_status & TX_LOST_CTS)
4194 {
4195#ifdef DEBUG_TX_FAIL
4196 printk(KERN_DEBUG "%s: wv_interrupt(): no CTS\n", dev->name);
4197#endif
4198 lp->stats.tx_carrier_errors++;
4199 }
4200 if(tx_status & TX_LOST_CRS)
4201 {
4202#ifdef DEBUG_TX_FAIL
4203 printk(KERN_DEBUG "%s: wv_interrupt(): no carrier\n",
4204 dev->name);
4205#endif
4206 lp->stats.tx_carrier_errors++;
4207 }
4208 if(tx_status & TX_HRT_BEAT)
4209 {
4210#ifdef DEBUG_TX_FAIL
4211 printk(KERN_DEBUG "%s: wv_interrupt(): heart beat\n", dev->name);
4212#endif
4213 lp->stats.tx_heartbeat_errors++;
4214 }
4215 if(tx_status & TX_DEFER)
4216 {
4217#ifdef DEBUG_TX_FAIL
4218 printk(KERN_DEBUG "%s: wv_interrupt(): channel jammed\n",
4219 dev->name);
4220#endif
4221 }
4222
4223
4224
4225
4226
4227 if(tx_status & TX_COLL)
4228 {
4229 if(tx_status & TX_MAX_COL)
4230 {
4231#ifdef DEBUG_TX_FAIL
4232 printk(KERN_DEBUG "%s: wv_interrupt(): channel congestion\n",
4233 dev->name);
4234#endif
4235 if(!(tx_status & TX_NCOL_MASK))
4236 {
4237 lp->stats.collisions += 0x10;
4238 }
4239 }
4240 }
4241 }
4242
4243 lp->stats.collisions += (tx_status & TX_NCOL_MASK);
4244 lp->stats.tx_packets++;
4245
4246 netif_wake_queue(dev);
4247 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
4248 }
4249 else
4250 {
4251#ifdef DEBUG_INTERRUPT_ERROR
4252 printk(KERN_INFO "wavelan_cs: unknown interrupt, status0 = %02x\n",
4253 status0);
4254#endif
4255 outb(CR0_INT_ACK | OP0_NOP, LCCR(base));
4256 }
4257 }
4258
4259 spin_unlock(&lp->spinlock);
4260
4261#ifdef DEBUG_INTERRUPT_TRACE
4262 printk(KERN_DEBUG "%s: <-wavelan_interrupt()\n", dev->name);
4263#endif
4264
4265
4266
4267
4268
4269
4270
4271
4272
4273
4274
4275
4276
4277
4278
4279
4280
4281 return IRQ_HANDLED;
4282}
4283
4284
4285
4286
4287
4288
4289
4290
4291
4292
4293
4294
4295
4296static void
4297wavelan_watchdog(struct net_device * dev)
4298{
4299 net_local * lp = netdev_priv(dev);
4300 unsigned int base = dev->base_addr;
4301 unsigned long flags;
4302 int aborted = FALSE;
4303
4304#ifdef DEBUG_INTERRUPT_TRACE
4305 printk(KERN_DEBUG "%s: ->wavelan_watchdog()\n", dev->name);
4306#endif
4307
4308#ifdef DEBUG_INTERRUPT_ERROR
4309 printk(KERN_INFO "%s: wavelan_watchdog: watchdog timer expired\n",
4310 dev->name);
4311#endif
4312
4313 spin_lock_irqsave(&lp->spinlock, flags);
4314
4315
4316 outb(OP0_ABORT, LCCR(base));
4317
4318
4319 if(wv_82593_cmd(dev, "wavelan_watchdog(): abort",
4320 OP0_NOP | CR0_STATUS_3, SR0_EXECUTION_ABORTED))
4321 aborted = TRUE;
4322
4323
4324 spin_unlock_irqrestore(&lp->spinlock, flags);
4325
4326
4327 if(!aborted)
4328 {
4329
4330#ifdef DEBUG_INTERRUPT_ERROR
4331 printk(KERN_INFO "%s: wavelan_watchdog: abort failed, trying reset\n",
4332 dev->name);
4333#endif
4334 wv_hw_reset(dev);
4335 }
4336
4337#ifdef DEBUG_PSA_SHOW
4338 {
4339 psa_t psa;
4340 psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa));
4341 wv_psa_show(&psa);
4342 }
4343#endif
4344#ifdef DEBUG_MMC_SHOW
4345 wv_mmc_show(dev);
4346#endif
4347#ifdef DEBUG_I82593_SHOW
4348 wv_ru_show(dev);
4349#endif
4350
4351
4352 netif_wake_queue(dev);
4353
4354#ifdef DEBUG_INTERRUPT_TRACE
4355 printk(KERN_DEBUG "%s: <-wavelan_watchdog()\n", dev->name);
4356#endif
4357}
4358
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371static int
4372wavelan_open(struct net_device * dev)
4373{
4374 net_local * lp = netdev_priv(dev);
4375 struct pcmcia_device * link = lp->link;
4376 unsigned int base = dev->base_addr;
4377
4378#ifdef DEBUG_CALLBACK_TRACE
4379 printk(KERN_DEBUG "%s: ->wavelan_open(dev=0x%x)\n", dev->name,
4380 (unsigned int) dev);
4381#endif
4382
4383
4384 if(hasr_read(base) & HASR_NO_CLK)
4385 {
4386
4387 hacr_write(base, HACR_DEFAULT);
4388
4389
4390 if(hasr_read(base) & HASR_NO_CLK)
4391 {
4392#ifdef DEBUG_CONFIG_ERRORS
4393 printk(KERN_WARNING "%s: wavelan_open(): modem not connected\n",
4394 dev->name);
4395#endif
4396 return FALSE;
4397 }
4398 }
4399
4400
4401 if(!lp->configured)
4402 return FALSE;
4403 if(!wv_ru_start(dev))
4404 wv_hw_reset(dev);
4405 netif_start_queue(dev);
4406
4407
4408 link->open++;
4409
4410#ifdef WAVELAN_ROAMING
4411 if(do_roaming)
4412 wv_roam_init(dev);
4413#endif
4414
4415#ifdef DEBUG_CALLBACK_TRACE
4416 printk(KERN_DEBUG "%s: <-wavelan_open()\n", dev->name);
4417#endif
4418 return 0;
4419}
4420
4421
4422
4423
4424
4425
4426static int
4427wavelan_close(struct net_device * dev)
4428{
4429 struct pcmcia_device * link = ((net_local *)netdev_priv(dev))->link;
4430 unsigned int base = dev->base_addr;
4431
4432#ifdef DEBUG_CALLBACK_TRACE
4433 printk(KERN_DEBUG "%s: ->wavelan_close(dev=0x%x)\n", dev->name,
4434 (unsigned int) dev);
4435#endif
4436
4437
4438 if(!link->open)
4439 {
4440#ifdef DEBUG_CONFIG_INFO
4441 printk(KERN_DEBUG "%s: wavelan_close(): device not open\n", dev->name);
4442#endif
4443 return 0;
4444 }
4445
4446#ifdef WAVELAN_ROAMING
4447
4448 if(do_roaming)
4449 wv_roam_cleanup(dev);
4450#endif
4451
4452 link->open--;
4453
4454
4455 if(netif_running(dev))
4456 {
4457 netif_stop_queue(dev);
4458
4459
4460 wv_ru_stop(dev);
4461
4462
4463 hacr_write(base, HACR_DEFAULT & (~HACR_PWR_STAT));
4464 }
4465
4466#ifdef DEBUG_CALLBACK_TRACE
4467 printk(KERN_DEBUG "%s: <-wavelan_close()\n", dev->name);
4468#endif
4469 return 0;
4470}
4471
4472
4473
4474
4475
4476
4477
4478
4479
4480
4481
4482static int
4483wavelan_probe(struct pcmcia_device *p_dev)
4484{
4485 struct net_device * dev;
4486 net_local * lp;
4487 int ret;
4488
4489#ifdef DEBUG_CALLBACK_TRACE
4490 printk(KERN_DEBUG "-> wavelan_attach()\n");
4491#endif
4492
4493
4494 p_dev->io.NumPorts1 = 8;
4495 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
4496 p_dev->io.IOAddrLines = 3;
4497
4498
4499 p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
4500 p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
4501 p_dev->irq.Handler = wavelan_interrupt;
4502
4503
4504 p_dev->conf.Attributes = CONF_ENABLE_IRQ;
4505 p_dev->conf.IntType = INT_MEMORY_AND_IO;
4506
4507
4508 dev = alloc_etherdev(sizeof(net_local));
4509 if (!dev)
4510 return -ENOMEM;
4511
4512 p_dev->priv = p_dev->irq.Instance = dev;
4513
4514 lp = netdev_priv(dev);
4515
4516
4517 lp->configured = 0;
4518 lp->reconfig_82593 = FALSE;
4519 lp->nresets = 0;
4520
4521 lp->promiscuous = 0;
4522 lp->allmulticast = 0;
4523 lp->mc_count = 0;
4524
4525
4526 spin_lock_init(&lp->spinlock);
4527
4528
4529 lp->dev = dev;
4530
4531
4532 dev->open = &wavelan_open;
4533 dev->stop = &wavelan_close;
4534 dev->hard_start_xmit = &wavelan_packet_xmit;
4535 dev->get_stats = &wavelan_get_stats;
4536 dev->set_multicast_list = &wavelan_set_multicast_list;
4537#ifdef SET_MAC_ADDRESS
4538 dev->set_mac_address = &wavelan_set_mac_address;
4539#endif
4540
4541
4542 dev->tx_timeout = &wavelan_watchdog;
4543 dev->watchdog_timeo = WATCHDOG_JIFFIES;
4544 SET_ETHTOOL_OPS(dev, &ops);
4545
4546 dev->wireless_handlers = &wavelan_handler_def;
4547 lp->wireless_data.spy_data = &lp->spy_data;
4548 dev->wireless_data = &lp->wireless_data;
4549
4550
4551 dev->mtu = WAVELAN_MTU;
4552
4553 ret = wv_pcmcia_config(p_dev);
4554 if (ret)
4555 return ret;
4556
4557 ret = wv_hw_config(dev);
4558 if (ret) {
4559 dev->irq = 0;
4560 pcmcia_disable_device(p_dev);
4561 return ret;
4562 }
4563
4564 wv_init_info(dev);
4565
4566#ifdef DEBUG_CALLBACK_TRACE
4567 printk(KERN_DEBUG "<- wavelan_attach()\n");
4568#endif
4569
4570 return 0;
4571}
4572
4573
4574
4575
4576
4577
4578
4579
4580static void
4581wavelan_detach(struct pcmcia_device *link)
4582{
4583#ifdef DEBUG_CALLBACK_TRACE
4584 printk(KERN_DEBUG "-> wavelan_detach(0x%p)\n", link);
4585#endif
4586
4587
4588 wv_pcmcia_release(link);
4589
4590
4591 if(link->priv)
4592 {
4593 struct net_device * dev = (struct net_device *) link->priv;
4594
4595
4596
4597 if (link->dev_node)
4598 unregister_netdev(dev);
4599 link->dev_node = NULL;
4600 ((net_local *)netdev_priv(dev))->link = NULL;
4601 ((net_local *)netdev_priv(dev))->dev = NULL;
4602 free_netdev(dev);
4603 }
4604
4605#ifdef DEBUG_CALLBACK_TRACE
4606 printk(KERN_DEBUG "<- wavelan_detach()\n");
4607#endif
4608}
4609
4610static int wavelan_suspend(struct pcmcia_device *link)
4611{
4612 struct net_device * dev = (struct net_device *) link->priv;
4613
4614
4615
4616
4617
4618
4619
4620
4621 wv_ru_stop(dev);
4622
4623 if (link->open)
4624 netif_device_detach(dev);
4625
4626
4627 hacr_write(dev->base_addr, HACR_DEFAULT & (~HACR_PWR_STAT));
4628
4629 return 0;
4630}
4631
4632static int wavelan_resume(struct pcmcia_device *link)
4633{
4634 struct net_device * dev = (struct net_device *) link->priv;
4635
4636 if (link->open) {
4637 wv_hw_reset(dev);
4638 netif_device_attach(dev);
4639 }
4640
4641 return 0;
4642}
4643
4644
4645static struct pcmcia_device_id wavelan_ids[] = {
4646 PCMCIA_DEVICE_PROD_ID12("AT&T","WaveLAN/PCMCIA", 0xe7c5affd, 0x1bc50975),
4647 PCMCIA_DEVICE_PROD_ID12("Digital", "RoamAbout/DS", 0x9999ab35, 0x00d05e06),
4648 PCMCIA_DEVICE_PROD_ID12("Lucent Technologies", "WaveLAN/PCMCIA", 0x23eb9949, 0x1bc50975),
4649 PCMCIA_DEVICE_PROD_ID12("NCR", "WaveLAN/PCMCIA", 0x24358cd4, 0x1bc50975),
4650 PCMCIA_DEVICE_NULL,
4651};
4652MODULE_DEVICE_TABLE(pcmcia, wavelan_ids);
4653
4654static struct pcmcia_driver wavelan_driver = {
4655 .owner = THIS_MODULE,
4656 .drv = {
4657 .name = "wavelan_cs",
4658 },
4659 .probe = wavelan_probe,
4660 .remove = wavelan_detach,
4661 .id_table = wavelan_ids,
4662 .suspend = wavelan_suspend,
4663 .resume = wavelan_resume,
4664};
4665
4666static int __init
4667init_wavelan_cs(void)
4668{
4669 return pcmcia_register_driver(&wavelan_driver);
4670}
4671
4672static void __exit
4673exit_wavelan_cs(void)
4674{
4675 pcmcia_unregister_driver(&wavelan_driver);
4676}
4677
4678module_init(init_wavelan_cs);
4679module_exit(exit_wavelan_cs);