![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wavelan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to wavelan.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 ! root 1: /* ! 2: * WaveLAN ISA driver ! 3: * ! 4: * Jean II - HPLB '96 ! 5: * ! 6: * Reorganisation and extension of the driver. ! 7: * Original copyright follows (also see the end of this file). ! 8: * See wavelan.p.h for details. ! 9: */ ! 10: ! 11: /* ! 12: * AT&T GIS (nee NCR) WaveLAN card: ! 13: * An Ethernet-like radio transceiver ! 14: * controlled by an Intel 82586 coprocessor. ! 15: */ ! 16: ! 17: #include "wavelan.p.h" /* Private header */ ! 18: ! 19: /************************* MISC SUBROUTINES **************************/ ! 20: /* ! 21: * Subroutines which won't fit in one of the following category ! 22: * (WaveLAN modem or i82586) ! 23: */ ! 24: ! 25: /*------------------------------------------------------------------*/ ! 26: /* ! 27: * Wrapper for disabling interrupts. ! 28: */ ! 29: static inline unsigned long ! 30: wv_splhi(void) ! 31: { ! 32: unsigned long flags; ! 33: ! 34: save_flags(flags); ! 35: cli(); ! 36: ! 37: return(flags); ! 38: } ! 39: ! 40: /*------------------------------------------------------------------*/ ! 41: /* ! 42: * Wrapper for re-enabling interrupts. ! 43: */ ! 44: static inline void ! 45: wv_splx(unsigned long flags) ! 46: { ! 47: restore_flags(flags); ! 48: } ! 49: ! 50: /*------------------------------------------------------------------*/ ! 51: /* ! 52: * Translate irq number to PSA irq parameter ! 53: */ ! 54: static u_char ! 55: wv_irq_to_psa(int irq) ! 56: { ! 57: if(irq < 0 || irq >= NELS(irqvals)) ! 58: return 0; ! 59: ! 60: return irqvals[irq]; ! 61: } ! 62: ! 63: /*------------------------------------------------------------------*/ ! 64: /* ! 65: * Translate PSA irq parameter to irq number ! 66: */ ! 67: static int ! 68: wv_psa_to_irq(u_char irqval) ! 69: { ! 70: int irq; ! 71: ! 72: for(irq = 0; irq < NELS(irqvals); irq++) ! 73: if(irqvals[irq] == irqval) ! 74: return irq; ! 75: ! 76: return -1; ! 77: } ! 78: ! 79: #ifdef STRUCT_CHECK ! 80: /*------------------------------------------------------------------*/ ! 81: /* ! 82: * Sanity routine to verify the sizes of the various WaveLAN interface ! 83: * structures. ! 84: */ ! 85: static char * ! 86: wv_struct_check(void) ! 87: { ! 88: #define SC(t,s,n) if (sizeof(t) != s) return(n); ! 89: ! 90: SC(psa_t, PSA_SIZE, "psa_t"); ! 91: SC(mmw_t, MMW_SIZE, "mmw_t"); ! 92: SC(mmr_t, MMR_SIZE, "mmr_t"); ! 93: SC(ha_t, HA_SIZE, "ha_t"); ! 94: ! 95: #undef SC ! 96: ! 97: return((char *) NULL); ! 98: } /* wv_struct_check */ ! 99: #endif /* STRUCT_CHECK */ ! 100: ! 101: /********************* HOST ADAPTER SUBROUTINES *********************/ ! 102: /* ! 103: * Useful subroutines to manage the WaveLAN ISA interface ! 104: * ! 105: * One major difference with the PCMCIA hardware (except the port mapping) ! 106: * is that we have to keep the state of the Host Control Register ! 107: * because of the interrupt enable & bus size flags. ! 108: */ ! 109: ! 110: /*------------------------------------------------------------------*/ ! 111: /* ! 112: * Read from card's Host Adaptor Status Register. ! 113: */ ! 114: static inline u_short ! 115: hasr_read(u_long ioaddr) ! 116: { ! 117: return(inw(HASR(ioaddr))); ! 118: } /* hasr_read */ ! 119: ! 120: /*------------------------------------------------------------------*/ ! 121: /* ! 122: * Write to card's Host Adapter Command Register. ! 123: */ ! 124: static inline void ! 125: hacr_write(u_long ioaddr, ! 126: u_short hacr) ! 127: { ! 128: outw(hacr, HACR(ioaddr)); ! 129: } /* hacr_write */ ! 130: ! 131: /*------------------------------------------------------------------*/ ! 132: /* ! 133: * Write to card's Host Adapter Command Register. Include a delay for ! 134: * those times when it is needed. ! 135: */ ! 136: static inline void ! 137: hacr_write_slow(u_long ioaddr, ! 138: u_short hacr) ! 139: { ! 140: hacr_write(ioaddr, hacr); ! 141: /* delay might only be needed sometimes */ ! 142: udelay(1000L); ! 143: } /* hacr_write_slow */ ! 144: ! 145: /*------------------------------------------------------------------*/ ! 146: /* ! 147: * Set the channel attention bit. ! 148: */ ! 149: static inline void ! 150: set_chan_attn(u_long ioaddr, ! 151: u_short hacr) ! 152: { ! 153: hacr_write(ioaddr, hacr | HACR_CA); ! 154: } /* set_chan_attn */ ! 155: ! 156: /*------------------------------------------------------------------*/ ! 157: /* ! 158: * Reset, and then set host adaptor into default mode. ! 159: */ ! 160: static inline void ! 161: wv_hacr_reset(u_long ioaddr) ! 162: { ! 163: hacr_write_slow(ioaddr, HACR_RESET); ! 164: hacr_write(ioaddr, HACR_DEFAULT); ! 165: } /* wv_hacr_reset */ ! 166: ! 167: /*------------------------------------------------------------------*/ ! 168: /* ! 169: * Set the i/o transfer over the ISA bus to 8 bits mode ! 170: */ ! 171: static inline void ! 172: wv_16_off(u_long ioaddr, ! 173: u_short hacr) ! 174: { ! 175: hacr &= ~HACR_16BITS; ! 176: hacr_write(ioaddr, hacr); ! 177: } /* wv_16_off */ ! 178: ! 179: /*------------------------------------------------------------------*/ ! 180: /* ! 181: * Set the i/o transfer over the ISA bus to 8 bits mode ! 182: */ ! 183: static inline void ! 184: wv_16_on(u_long ioaddr, ! 185: u_short hacr) ! 186: { ! 187: hacr |= HACR_16BITS; ! 188: hacr_write(ioaddr, hacr); ! 189: } /* wv_16_on */ ! 190: ! 191: /*------------------------------------------------------------------*/ ! 192: /* ! 193: * Disable interrupts on the WaveLAN hardware ! 194: */ ! 195: static inline void ! 196: wv_ints_off(device * dev) ! 197: { ! 198: net_local * lp = (net_local *)dev->priv; ! 199: u_long ioaddr = dev->base_addr; ! 200: u_long x; ! 201: ! 202: x = wv_splhi(); ! 203: ! 204: lp->hacr &= ~HACR_INTRON; ! 205: hacr_write(ioaddr, lp->hacr); ! 206: ! 207: wv_splx(x); ! 208: } /* wv_ints_off */ ! 209: ! 210: /*------------------------------------------------------------------*/ ! 211: /* ! 212: * Enable interrupts on the WaveLAN hardware ! 213: */ ! 214: static inline void ! 215: wv_ints_on(device * dev) ! 216: { ! 217: net_local * lp = (net_local *)dev->priv; ! 218: u_long ioaddr = dev->base_addr; ! 219: u_long x; ! 220: ! 221: x = wv_splhi(); ! 222: ! 223: lp->hacr |= HACR_INTRON; ! 224: hacr_write(ioaddr, lp->hacr); ! 225: ! 226: wv_splx(x); ! 227: } /* wv_ints_on */ ! 228: ! 229: /******************* MODEM MANAGEMENT SUBROUTINES *******************/ ! 230: /* ! 231: * Useful subroutines to manage the modem of the WaveLAN ! 232: */ ! 233: ! 234: /*------------------------------------------------------------------*/ ! 235: /* ! 236: * Read the Parameter Storage Area from the WaveLAN card's memory ! 237: */ ! 238: /* ! 239: * Read bytes from the PSA. ! 240: */ ! 241: static void ! 242: psa_read(u_long ioaddr, ! 243: u_short hacr, ! 244: int o, /* offset in PSA */ ! 245: u_char * b, /* buffer to fill */ ! 246: int n) /* size to read */ ! 247: { ! 248: wv_16_off(ioaddr, hacr); ! 249: ! 250: while(n-- > 0) ! 251: { ! 252: outw(o, PIOR2(ioaddr)); ! 253: o++; ! 254: *b++ = inb(PIOP2(ioaddr)); ! 255: } ! 256: ! 257: wv_16_on(ioaddr, hacr); ! 258: } /* psa_read */ ! 259: ! 260: /*------------------------------------------------------------------*/ ! 261: /* ! 262: * Write the Paramter Storage Area to the WaveLAN card's memory ! 263: */ ! 264: static void ! 265: psa_write(u_long ioaddr, ! 266: u_short hacr, ! 267: int o, /* Offset in psa */ ! 268: u_char * b, /* Buffer in memory */ ! 269: int n) /* Length of buffer */ ! 270: { ! 271: int count = 0; ! 272: ! 273: wv_16_off(ioaddr, hacr); ! 274: ! 275: while(n-- > 0) ! 276: { ! 277: outw(o, PIOR2(ioaddr)); ! 278: o++; ! 279: ! 280: outb(*b, PIOP2(ioaddr)); ! 281: b++; ! 282: ! 283: /* Wait for the memory to finish its write cycle */ ! 284: count = 0; ! 285: while((count++ < 100) && ! 286: (hasr_read(ioaddr) & HASR_PSA_BUSY)) ! 287: udelay(1000); ! 288: } ! 289: ! 290: wv_16_on(ioaddr, hacr); ! 291: } /* psa_write */ ! 292: ! 293: #ifdef PSA_CRC ! 294: /*------------------------------------------------------------------*/ ! 295: /* ! 296: * Calculate the PSA CRC (not tested yet) ! 297: * As the WaveLAN drivers don't use the CRC, I won't use it either. ! 298: * Thanks to Valster, Nico <[email protected]> for the code ! 299: * NOTE: By specifying a length including the CRC position the ! 300: * returned value should be zero. (i.e. a correct checksum in the PSA) ! 301: */ ! 302: static u_short ! 303: psa_crc(u_short * psa, /* The PSA */ ! 304: int size) /* Number of short for CRC */ ! 305: { ! 306: int byte_cnt; /* Loop on the PSA */ ! 307: u_short crc_bytes = 0; /* Data in the PSA */ ! 308: int bit_cnt; /* Loop on the bits of the short */ ! 309: ! 310: for(byte_cnt = 0; byte_cnt <= size; byte_cnt++ ) ! 311: { ! 312: crc_bytes ^= psa[byte_cnt]; /* Its an xor */ ! 313: ! 314: for(bit_cnt = 1; bit_cnt < 9; bit_cnt++ ) ! 315: { ! 316: if(crc_bytes & 0x0001) ! 317: crc_bytes = (crc_bytes >> 1) ^ 0xA001; ! 318: else ! 319: crc_bytes >>= 1 ; ! 320: } ! 321: } ! 322: ! 323: return crc_bytes; ! 324: } /* psa_crc */ ! 325: #endif /* PSA_CRC */ ! 326: ! 327: /*------------------------------------------------------------------*/ ! 328: /* ! 329: * Write 1 byte to the MMC. ! 330: */ ! 331: static inline void ! 332: mmc_out(u_long ioaddr, ! 333: u_short o, ! 334: u_char d) ! 335: { ! 336: /* Wait for MMC to go idle */ ! 337: while(inw(HASR(ioaddr)) & HASR_MMC_BUSY) ! 338: ; ! 339: ! 340: outw((u_short) (((u_short) d << 8) | (o << 1) | 1), ! 341: MMCR(ioaddr)); ! 342: } ! 343: ! 344: /*------------------------------------------------------------------*/ ! 345: /* ! 346: * Routine to write bytes to the Modem Management Controller. ! 347: * We start by the end because it is the way it should be ! ! 348: */ ! 349: static inline void ! 350: mmc_write(u_long ioaddr, ! 351: u_char o, ! 352: u_char * b, ! 353: int n) ! 354: { ! 355: o += n; ! 356: b += n; ! 357: ! 358: while(n-- > 0 ) ! 359: mmc_out(ioaddr, --o, *(--b)); ! 360: } /* mmc_write */ ! 361: ! 362: /*------------------------------------------------------------------*/ ! 363: /* ! 364: * Read 1 byte from the MMC. ! 365: * Optimised version for 1 byte, avoid using memory... ! 366: */ ! 367: static inline u_char ! 368: mmc_in(u_long ioaddr, ! 369: u_short o) ! 370: { ! 371: while(inw(HASR(ioaddr)) & HASR_MMC_BUSY) ! 372: ; ! 373: outw(o << 1, MMCR(ioaddr)); ! 374: ! 375: while(inw(HASR(ioaddr)) & HASR_MMC_BUSY) ! 376: ; ! 377: return (u_char) (inw(MMCR(ioaddr)) >> 8); ! 378: } ! 379: ! 380: /*------------------------------------------------------------------*/ ! 381: /* ! 382: * Routine to read bytes from the Modem Management Controller. ! 383: * The implementation is complicated by a lack of address lines, ! 384: * which prevents decoding of the low-order bit. ! 385: * (code has just been moved in the above function) ! 386: * We start by the end because it is the way it should be ! ! 387: */ ! 388: static inline void ! 389: mmc_read(u_long ioaddr, ! 390: u_char o, ! 391: u_char * b, ! 392: int n) ! 393: { ! 394: o += n; ! 395: b += n; ! 396: ! 397: while(n-- > 0) ! 398: *(--b) = mmc_in(ioaddr, --o); ! 399: } /* mmc_read */ ! 400: ! 401: /*------------------------------------------------------------------*/ ! 402: /* ! 403: * Get the type of encryption available... ! 404: */ ! 405: static inline int ! 406: mmc_encr(u_long ioaddr) /* i/o port of the card */ ! 407: { ! 408: int temp; ! 409: ! 410: temp = mmc_in(ioaddr, mmroff(0, mmr_des_avail)); ! 411: if((temp != MMR_DES_AVAIL_DES) && (temp != MMR_DES_AVAIL_AES)) ! 412: return 0; ! 413: else ! 414: return temp; ! 415: } ! 416: ! 417: /*------------------------------------------------------------------*/ ! 418: /* ! 419: * Wait for the frequency EEPROM to complete a command... ! 420: * I hope this one will be optimally inlined... ! 421: */ ! 422: static inline void ! 423: fee_wait(u_long ioaddr, /* i/o port of the card */ ! 424: int delay, /* Base delay to wait for */ ! 425: int number) /* Number of time to wait */ ! 426: { ! 427: int count = 0; /* Wait only a limited time */ ! 428: ! 429: while((count++ < number) && ! 430: (mmc_in(ioaddr, mmroff(0, mmr_fee_status)) & MMR_FEE_STATUS_BUSY)) ! 431: udelay(delay); ! 432: } ! 433: ! 434: /*------------------------------------------------------------------*/ ! 435: /* ! 436: * Read bytes from the frequency EEPROM (frequency select cards). ! 437: */ ! 438: static void ! 439: fee_read(u_long ioaddr, /* i/o port of the card */ ! 440: u_short o, /* destination offset */ ! 441: u_short * b, /* data buffer */ ! 442: int n) /* number of registers */ ! 443: { ! 444: b += n; /* Position at the end of the area */ ! 445: ! 446: /* Write the address */ ! 447: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n - 1); ! 448: ! 449: /* Loop on all buffer */ ! 450: while(n-- > 0) ! 451: { ! 452: /* Write the read command */ ! 453: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_READ); ! 454: ! 455: /* Wait until EEPROM is ready (should be quick!) */ ! 456: fee_wait(ioaddr, 10, 100); ! 457: ! 458: /* Read the value */ ! 459: *--b = ((mmc_in(ioaddr, mmroff(0, mmr_fee_data_h)) << 8) | ! 460: mmc_in(ioaddr, mmroff(0, mmr_fee_data_l))); ! 461: } ! 462: } ! 463: ! 464: #ifdef WIRELESS_EXT /* If wireless extension exist in the kernel */ ! 465: ! 466: /*------------------------------------------------------------------*/ ! 467: /* ! 468: * Write bytes from the Frequency EEPROM (frequency select cards). ! 469: * This is a bit complicated, because the frequency EEPROM has to ! 470: * be unprotected and the write enabled. ! 471: * Jean II ! 472: */ ! 473: static void ! 474: fee_write(u_long ioaddr, /* i/o port of the card */ ! 475: u_short o, /* destination offset */ ! 476: u_short * b, /* data buffer */ ! 477: int n) /* number of registers */ ! 478: { ! 479: b += n; /* Position at the end of the area */ ! 480: ! 481: #ifdef EEPROM_IS_PROTECTED /* disabled */ ! 482: #ifdef DOESNT_SEEM_TO_WORK /* disabled */ ! 483: /* Ask to read the protected register */ ! 484: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRREAD); ! 485: ! 486: fee_wait(ioaddr, 10, 100); ! 487: ! 488: /* Read the protected register */ ! 489: printk("Protected 2 : %02X-%02X\n", ! 490: mmc_in(ioaddr, mmroff(0, mmr_fee_data_h)), ! 491: mmc_in(ioaddr, mmroff(0, mmr_fee_data_l))); ! 492: #endif /* DOESNT_SEEM_TO_WORK */ ! 493: ! 494: /* Enable protected register */ ! 495: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN); ! 496: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PREN); ! 497: ! 498: fee_wait(ioaddr, 10, 100); ! 499: ! 500: /* Unprotect area */ ! 501: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n); ! 502: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE); ! 503: #ifdef DOESNT_SEEM_TO_WORK /* disabled */ ! 504: /* Or use : */ ! 505: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRCLEAR); ! 506: #endif /* DOESNT_SEEM_TO_WORK */ ! 507: ! 508: fee_wait(ioaddr, 10, 100); ! 509: #endif /* EEPROM_IS_PROTECTED */ ! 510: ! 511: /* Write enable */ ! 512: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_EN); ! 513: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WREN); ! 514: ! 515: fee_wait(ioaddr, 10, 100); ! 516: ! 517: /* Write the EEPROM address */ ! 518: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), o + n - 1); ! 519: ! 520: /* Loop on all buffer */ ! 521: while(n-- > 0) ! 522: { ! 523: /* Write the value */ ! 524: mmc_out(ioaddr, mmwoff(0, mmw_fee_data_h), (*--b) >> 8); ! 525: mmc_out(ioaddr, mmwoff(0, mmw_fee_data_l), *b & 0xFF); ! 526: ! 527: /* Write the write command */ ! 528: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WRITE); ! 529: ! 530: /* Wavelan doc says : wait at least 10 ms for EEBUSY = 0 */ ! 531: udelay(10000); ! 532: fee_wait(ioaddr, 10, 100); ! 533: } ! 534: ! 535: /* Write disable */ ! 536: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), MMW_FEE_ADDR_DS); ! 537: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_WDS); ! 538: ! 539: fee_wait(ioaddr, 10, 100); ! 540: ! 541: #ifdef EEPROM_IS_PROTECTED /* disabled */ ! 542: /* Reprotect EEPROM */ ! 543: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x00); ! 544: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), MMW_FEE_CTRL_PRWRITE); ! 545: ! 546: fee_wait(ioaddr, 10, 100); ! 547: #endif /* EEPROM_IS_PROTECTED */ ! 548: } ! 549: #endif /* WIRELESS_EXT */ ! 550: ! 551: /************************ I82586 SUBROUTINES *************************/ ! 552: /* ! 553: * Usefull subroutines to manage the Ethernet controler ! 554: */ ! 555: ! 556: /*------------------------------------------------------------------*/ ! 557: /* ! 558: * Read bytes from the on-board RAM. ! 559: * Why inlining this function make it fail ??? ! 560: */ ! 561: static /*inline*/ void ! 562: obram_read(u_long ioaddr, ! 563: u_short o, ! 564: u_char * b, ! 565: int n) ! 566: { ! 567: outw(o, PIOR1(ioaddr)); ! 568: insw(PIOP1(ioaddr), (unsigned short *) b, (n + 1) >> 1); ! 569: } ! 570: ! 571: /*------------------------------------------------------------------*/ ! 572: /* ! 573: * Write bytes to the on-board RAM. ! 574: */ ! 575: static inline void ! 576: obram_write(u_long ioaddr, ! 577: u_short o, ! 578: u_char * b, ! 579: int n) ! 580: { ! 581: outw(o, PIOR1(ioaddr)); ! 582: outsw(PIOP1(ioaddr), (unsigned short *) b, (n + 1) >> 1); ! 583: } ! 584: ! 585: /*------------------------------------------------------------------*/ ! 586: /* ! 587: * Acknowledge the reading of the status issued by the i82586 ! 588: */ ! 589: static void ! 590: wv_ack(device * dev) ! 591: { ! 592: net_local * lp = (net_local *)dev->priv; ! 593: u_long ioaddr = dev->base_addr; ! 594: u_short scb_cs; ! 595: int i; ! 596: ! 597: obram_read(ioaddr, scboff(OFFSET_SCB, scb_status), ! 598: (unsigned char *) &scb_cs, sizeof(scb_cs)); ! 599: scb_cs &= SCB_ST_INT; ! 600: ! 601: if(scb_cs == 0) ! 602: return; ! 603: ! 604: obram_write(ioaddr, scboff(OFFSET_SCB, scb_command), ! 605: (unsigned char *) &scb_cs, sizeof(scb_cs)); ! 606: ! 607: set_chan_attn(ioaddr, lp->hacr); ! 608: ! 609: for(i = 1000; i > 0; i--) ! 610: { ! 611: obram_read(ioaddr, scboff(OFFSET_SCB, scb_command), (unsigned char *)&scb_cs, sizeof(scb_cs)); ! 612: if(scb_cs == 0) ! 613: break; ! 614: ! 615: udelay(10); ! 616: } ! 617: udelay(100); ! 618: ! 619: #ifdef DEBUG_CONFIG_ERROR ! 620: if(i <= 0) ! 621: printk(KERN_INFO "%s: wv_ack(): board not accepting command.\n", ! 622: dev->name); ! 623: #endif ! 624: } ! 625: ! 626: /*------------------------------------------------------------------*/ ! 627: /* ! 628: * Set channel attention bit and busy wait until command has ! 629: * completed, then acknowledge the command completion. ! 630: */ ! 631: static inline int ! 632: wv_synchronous_cmd(device * dev, ! 633: const char * str) ! 634: { ! 635: net_local * lp = (net_local *)dev->priv; ! 636: u_long ioaddr = dev->base_addr; ! 637: u_short scb_cmd; ! 638: ach_t cb; ! 639: int i; ! 640: ! 641: scb_cmd = SCB_CMD_CUC & SCB_CMD_CUC_GO; ! 642: obram_write(ioaddr, scboff(OFFSET_SCB, scb_command), ! 643: (unsigned char *) &scb_cmd, sizeof(scb_cmd)); ! 644: ! 645: set_chan_attn(ioaddr, lp->hacr); ! 646: ! 647: for (i = 1000; i > 0; i--) ! 648: { ! 649: obram_read(ioaddr, OFFSET_CU, (unsigned char *)&cb, sizeof(cb)); ! 650: if (cb.ac_status & AC_SFLD_C) ! 651: break; ! 652: ! 653: udelay(10); ! 654: } ! 655: udelay(100); ! 656: ! 657: if(i <= 0 || !(cb.ac_status & AC_SFLD_OK)) ! 658: { ! 659: #ifdef DEBUG_CONFIG_ERROR ! 660: printk(KERN_INFO "%s: %s failed; status = 0x%x\n", ! 661: dev->name, str, cb.ac_status); ! 662: #endif ! 663: #ifdef DEBUG_I82586_SHOW ! 664: wv_scb_show(ioaddr); ! 665: #endif ! 666: return -1; ! 667: } ! 668: ! 669: /* Ack the status */ ! 670: wv_ack(dev); ! 671: ! 672: return 0; ! 673: } ! 674: ! 675: /*------------------------------------------------------------------*/ ! 676: /* ! 677: * Configuration commands completion interrupt. ! 678: * Check if done, and if ok... ! 679: */ ! 680: static inline int ! 681: wv_config_complete(device * dev, ! 682: u_long ioaddr, ! 683: net_local * lp) ! 684: { ! 685: unsigned short mcs_addr; ! 686: unsigned short status; ! 687: int ret; ! 688: ! 689: #ifdef DEBUG_INTERRUPT_TRACE ! 690: printk(KERN_DEBUG "%s: ->wv_config_complete()\n", dev->name); ! 691: #endif ! 692: ! 693: mcs_addr = lp->tx_first_in_use + sizeof(ac_tx_t) + sizeof(ac_nop_t) ! 694: + sizeof(tbd_t) + sizeof(ac_cfg_t) + sizeof(ac_ias_t); ! 695: ! 696: /* Read the status of the last command (set mc list) */ ! 697: obram_read(ioaddr, acoff(mcs_addr, ac_status), (unsigned char *)&status, sizeof(status)); ! 698: ! 699: /* If not completed -> exit */ ! 700: if((status & AC_SFLD_C) == 0) ! 701: ret = 0; /* Not ready to be scrapped */ ! 702: else ! 703: { ! 704: #ifdef DEBUG_CONFIG_ERROR ! 705: unsigned short cfg_addr; ! 706: unsigned short ias_addr; ! 707: ! 708: /* Check mc_config command */ ! 709: if(status & AC_SFLD_OK != 0) ! 710: printk(KERN_INFO "wv_config_complete(): set_multicast_address failed; status = 0x%x\n", ! 711: dev->name, str, status); ! 712: ! 713: /* check ia-config command */ ! 714: ias_addr = mcs_addr - sizeof(ac_ias_t); ! 715: obram_read(ioaddr, acoff(ias_addr, ac_status), (unsigned char *)&status, sizeof(status)); ! 716: if(status & AC_SFLD_OK != 0) ! 717: printk(KERN_INFO "wv_config_complete(): set_MAC_address; status = 0x%x\n", ! 718: dev->name, str, status); ! 719: ! 720: /* Check config command */ ! 721: cfg_addr = ias_addr - sizeof(ac_cfg_t); ! 722: obram_read(ioaddr, acoff(cfg_addr, ac_status), (unsigned char *)&status, sizeof(status)); ! 723: if(status & AC_SFLD_OK != 0) ! 724: printk(KERN_INFO "wv_config_complete(): configure; status = 0x%x\n", ! 725: dev->name, str, status); ! 726: #endif /* DEBUG_CONFIG_ERROR */ ! 727: ! 728: ret = 1; /* Ready to be scrapped */ ! 729: } ! 730: ! 731: #ifdef DEBUG_INTERRUPT_TRACE ! 732: printk(KERN_DEBUG "%s: <-wv_config_complete() - %d\n", dev->name, ret); ! 733: #endif ! 734: return ret; ! 735: } ! 736: ! 737: /*------------------------------------------------------------------*/ ! 738: /* ! 739: * Command completion interrupt. ! 740: * Reclaim as many freed tx buffers as we can. ! 741: */ ! 742: static int ! 743: wv_complete(device * dev, ! 744: u_long ioaddr, ! 745: net_local * lp) ! 746: { ! 747: int nreaped = 0; ! 748: ! 749: #ifdef DEBUG_INTERRUPT_TRACE ! 750: printk(KERN_DEBUG "%s: ->wv_complete()\n", dev->name); ! 751: #endif ! 752: ! 753: /* Loop on all the transmit buffers */ ! 754: while(lp->tx_first_in_use != I82586NULL) ! 755: { ! 756: unsigned short tx_status; ! 757: ! 758: /* Read the first transmit buffer */ ! 759: obram_read(ioaddr, acoff(lp->tx_first_in_use, ac_status), (unsigned char *)&tx_status, sizeof(tx_status)); ! 760: ! 761: /* Hack for reconfiguration... */ ! 762: if(tx_status == 0xFFFF) ! 763: if(!wv_config_complete(dev, ioaddr, lp)) ! 764: break; /* Not completed */ ! 765: ! 766: /* If not completed -> exit */ ! 767: if((tx_status & AC_SFLD_C) == 0) ! 768: break; ! 769: ! 770: /* We now remove this buffer */ ! 771: nreaped++; ! 772: --lp->tx_n_in_use; ! 773: ! 774: /* ! 775: if (lp->tx_n_in_use > 0) ! 776: printk("%c", "0123456789abcdefghijk"[lp->tx_n_in_use]); ! 777: */ ! 778: ! 779: /* Was it the last one ? */ ! 780: if(lp->tx_n_in_use <= 0) ! 781: lp->tx_first_in_use = I82586NULL; ! 782: else ! 783: { ! 784: /* Next one in the chain */ ! 785: lp->tx_first_in_use += TXBLOCKZ; ! 786: if(lp->tx_first_in_use >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ) ! 787: lp->tx_first_in_use -= NTXBLOCKS * TXBLOCKZ; ! 788: } ! 789: ! 790: /* Hack for reconfiguration... */ ! 791: if(tx_status == 0xFFFF) ! 792: continue; ! 793: ! 794: /* Now, check status of the finished command */ ! 795: if(tx_status & AC_SFLD_OK) ! 796: { ! 797: int ncollisions; ! 798: ! 799: lp->stats.tx_packets++; ! 800: ncollisions = tx_status & AC_SFLD_MAXCOL; ! 801: lp->stats.collisions += ncollisions; ! 802: #ifdef DEBUG_INTERRUPT_INFO ! 803: if(ncollisions > 0) ! 804: printk(KERN_DEBUG "%s: wv_complete(): tx completed after %d collisions.\n", ! 805: dev->name, ncollisions); ! 806: #endif ! 807: } ! 808: else ! 809: { ! 810: lp->stats.tx_errors++; ! 811: #ifndef IGNORE_NORMAL_XMIT_ERRS ! 812: if(tx_status & AC_SFLD_S10) ! 813: { ! 814: lp->stats.tx_carrier_errors++; ! 815: #ifdef DEBUG_INTERRUPT_ERROR ! 816: printk(KERN_INFO "%s: wv_complete(): tx error: no CS.\n", ! 817: dev->name); ! 818: #endif ! 819: } ! 820: #endif /* IGNORE_NORMAL_XMIT_ERRS */ ! 821: if(tx_status & AC_SFLD_S9) ! 822: { ! 823: lp->stats.tx_carrier_errors++; ! 824: #ifdef DEBUG_INTERRUPT_ERROR ! 825: printk(KERN_INFO "%s: wv_complete(): tx error: lost CTS.\n", ! 826: dev->name); ! 827: #endif ! 828: } ! 829: if(tx_status & AC_SFLD_S8) ! 830: { ! 831: lp->stats.tx_fifo_errors++; ! 832: #ifdef DEBUG_INTERRUPT_ERROR ! 833: printk(KERN_INFO "%s: wv_complete(): tx error: slow DMA.\n", ! 834: dev->name); ! 835: #endif ! 836: } ! 837: #ifndef IGNORE_NORMAL_XMIT_ERRS ! 838: if(tx_status & AC_SFLD_S6) ! 839: { ! 840: lp->stats.tx_heartbeat_errors++; ! 841: #ifdef DEBUG_INTERRUPT_ERROR ! 842: printk(KERN_INFO "%s: wv_complete(): tx error: heart beat.\n", ! 843: dev->name); ! 844: #endif ! 845: } ! 846: if(tx_status & AC_SFLD_S5) ! 847: { ! 848: lp->stats.tx_aborted_errors++; ! 849: #ifdef DEBUG_INTERRUPT_ERROR ! 850: printk(KERN_INFO "%s: wv_complete(): tx error: too many collisions.\n", ! 851: dev->name); ! 852: #endif ! 853: } ! 854: #endif /* IGNORE_NORMAL_XMIT_ERRS */ ! 855: } ! 856: ! 857: #ifdef DEBUG_INTERRUPT_INFO ! 858: printk(KERN_DEBUG "%s: wv_complete(): tx completed, tx_status 0x%04x\n", ! 859: dev->name, tx_status); ! 860: #endif ! 861: } ! 862: ! 863: #ifdef DEBUG_INTERRUPT_INFO ! 864: if(nreaped > 1) ! 865: printk(KERN_DEBUG "%s: wv_complete(): reaped %d\n", dev->name, nreaped); ! 866: #endif ! 867: ! 868: /* ! 869: * Inform upper layers. ! 870: */ ! 871: if(lp->tx_n_in_use < NTXBLOCKS - 1) ! 872: { ! 873: dev->tbusy = 0; ! 874: mark_bh(NET_BH); ! 875: } ! 876: ! 877: #ifdef DEBUG_INTERRUPT_TRACE ! 878: printk(KERN_DEBUG "%s: <-wv_complete()\n", dev->name); ! 879: #endif ! 880: return nreaped; ! 881: } ! 882: ! 883: /*------------------------------------------------------------------*/ ! 884: /* ! 885: * Reconfigure the i82586, or at least ask for it... ! 886: * Because wv_82586_config use a transmission buffer, we must do it ! 887: * when we are sure that there is one left, so we do it now ! 888: * or in wavelan_packet_xmit() (I can't find any better place, ! 889: * wavelan_interrupt is not an option...), so you may experience ! 890: * some delay sometime... ! 891: */ ! 892: static inline void ! 893: wv_82586_reconfig(device * dev) ! 894: { ! 895: net_local * lp = (net_local *)dev->priv; ! 896: ! 897: /* Check if we can do it now ! */ ! 898: if(!(dev->start) || (set_bit(0, (void *)&dev->tbusy) != 0)) ! 899: { ! 900: lp->reconfig_82586 = 1; ! 901: #ifdef DEBUG_CONFIG_INFO ! 902: printk(KERN_DEBUG "%s: wv_82586_reconfig(): delayed (busy = %ld, start = %d)\n", ! 903: dev->name, dev->tbusy, dev->start); ! 904: #endif ! 905: } ! 906: else ! 907: wv_82586_config(dev); ! 908: } ! 909: ! 910: /********************* DEBUG & INFO SUBROUTINES *********************/ ! 911: /* ! 912: * This routines are used in the code to show debug informations. ! 913: * Most of the time, it dump the content of hardware structures... ! 914: */ ! 915: ! 916: #ifdef DEBUG_PSA_SHOW ! 917: /*------------------------------------------------------------------*/ ! 918: /* ! 919: * Print the formatted contents of the Parameter Storage Area. ! 920: */ ! 921: static void ! 922: wv_psa_show(psa_t * p) ! 923: { ! 924: printk(KERN_DEBUG "##### WaveLAN psa contents: #####\n"); ! 925: printk(KERN_DEBUG "psa_io_base_addr_1: 0x%02X %02X %02X %02X\n", ! 926: p->psa_io_base_addr_1, ! 927: p->psa_io_base_addr_2, ! 928: p->psa_io_base_addr_3, ! 929: p->psa_io_base_addr_4); ! 930: printk(KERN_DEBUG "psa_rem_boot_addr_1: 0x%02X %02X %02X\n", ! 931: p->psa_rem_boot_addr_1, ! 932: p->psa_rem_boot_addr_2, ! 933: p->psa_rem_boot_addr_3); ! 934: printk(KERN_DEBUG "psa_holi_params: 0x%02x, ", p->psa_holi_params); ! 935: printk("psa_int_req_no: %d\n", p->psa_int_req_no); ! 936: #ifdef DEBUG_SHOW_UNUSED ! 937: printk(KERN_DEBUG "psa_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X\n", ! 938: p->psa_unused0[0], ! 939: p->psa_unused0[1], ! 940: p->psa_unused0[2], ! 941: p->psa_unused0[3], ! 942: p->psa_unused0[4], ! 943: p->psa_unused0[5], ! 944: p->psa_unused0[6]); ! 945: #endif /* DEBUG_SHOW_UNUSED */ ! 946: printk(KERN_DEBUG "psa_univ_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n", ! 947: p->psa_univ_mac_addr[0], ! 948: p->psa_univ_mac_addr[1], ! 949: p->psa_univ_mac_addr[2], ! 950: p->psa_univ_mac_addr[3], ! 951: p->psa_univ_mac_addr[4], ! 952: p->psa_univ_mac_addr[5]); ! 953: printk(KERN_DEBUG "psa_local_mac_addr[]: %02x:%02x:%02x:%02x:%02x:%02x\n", ! 954: p->psa_local_mac_addr[0], ! 955: p->psa_local_mac_addr[1], ! 956: p->psa_local_mac_addr[2], ! 957: p->psa_local_mac_addr[3], ! 958: p->psa_local_mac_addr[4], ! 959: p->psa_local_mac_addr[5]); ! 960: printk(KERN_DEBUG "psa_univ_local_sel: %d, ", p->psa_univ_local_sel); ! 961: printk("psa_comp_number: %d, ", p->psa_comp_number); ! 962: printk("psa_thr_pre_set: 0x%02x\n", p->psa_thr_pre_set); ! 963: printk(KERN_DEBUG "psa_feature_select/decay_prm: 0x%02x, ", ! 964: p->psa_feature_select); ! 965: printk("psa_subband/decay_update_prm: %d\n", p->psa_subband); ! 966: printk(KERN_DEBUG "psa_quality_thr: 0x%02x, ", p->psa_quality_thr); ! 967: printk("psa_mod_delay: 0x%02x\n", p->psa_mod_delay); ! 968: printk(KERN_DEBUG "psa_nwid: 0x%02x%02x, ", p->psa_nwid[0], p->psa_nwid[1]); ! 969: printk("psa_nwid_select: %d\n", p->psa_nwid_select); ! 970: printk(KERN_DEBUG "psa_encryption_select: %d, ", p->psa_encryption_select); ! 971: printk("psa_encryption_key[]: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", ! 972: p->psa_encryption_key[0], ! 973: p->psa_encryption_key[1], ! 974: p->psa_encryption_key[2], ! 975: p->psa_encryption_key[3], ! 976: p->psa_encryption_key[4], ! 977: p->psa_encryption_key[5], ! 978: p->psa_encryption_key[6], ! 979: p->psa_encryption_key[7]); ! 980: printk(KERN_DEBUG "psa_databus_width: %d\n", p->psa_databus_width); ! 981: printk(KERN_DEBUG "psa_call_code/auto_squelch: 0x%02x, ", ! 982: p->psa_call_code[0]); ! 983: printk("psa_call_code[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n", ! 984: p->psa_call_code[0], ! 985: p->psa_call_code[1], ! 986: p->psa_call_code[2], ! 987: p->psa_call_code[3], ! 988: p->psa_call_code[4], ! 989: p->psa_call_code[5], ! 990: p->psa_call_code[6], ! 991: p->psa_call_code[7]); ! 992: #ifdef DEBUG_SHOW_UNUSED ! 993: printk(KERN_DEBUG "psa_reserved[]: %02X:%02X:%02X:%02X\n", ! 994: p->psa_reserved[0], ! 995: p->psa_reserved[1], ! 996: p->psa_reserved[2], ! 997: p->psa_reserved[3]); ! 998: #endif /* DEBUG_SHOW_UNUSED */ ! 999: printk(KERN_DEBUG "psa_conf_status: %d, ", p->psa_conf_status); ! 1000: printk("psa_crc: 0x%02x%02x, ", p->psa_crc[0], p->psa_crc[1]); ! 1001: printk("psa_crc_status: 0x%02x\n", p->psa_crc_status); ! 1002: } /* wv_psa_show */ ! 1003: #endif /* DEBUG_PSA_SHOW */ ! 1004: ! 1005: #ifdef DEBUG_MMC_SHOW ! 1006: /*------------------------------------------------------------------*/ ! 1007: /* ! 1008: * Print the formatted status of the Modem Management Controller. ! 1009: * This function need to be completed... ! 1010: */ ! 1011: static void ! 1012: wv_mmc_show(device * dev) ! 1013: { ! 1014: u_long ioaddr = dev->base_addr; ! 1015: net_local * lp = (net_local *)dev->priv; ! 1016: mmr_t m; ! 1017: ! 1018: /* Basic check */ ! 1019: if(hasr_read(ioaddr) & HASR_NO_CLK) ! 1020: { ! 1021: printk(KERN_WARNING "%s: wv_mmc_show: modem not connected\n", ! 1022: dev->name); ! 1023: return; ! 1024: } ! 1025: ! 1026: /* Read the mmc */ ! 1027: mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1); ! 1028: mmc_read(ioaddr, 0, (u_char *)&m, sizeof(m)); ! 1029: mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0); ! 1030: ! 1031: #ifdef WIRELESS_EXT /* If wireless extension exist in the kernel */ ! 1032: /* Don't forget to update statistics */ ! 1033: lp->wstats.discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l; ! 1034: #endif /* WIRELESS_EXT */ ! 1035: ! 1036: printk(KERN_DEBUG "##### WaveLAN modem status registers: #####\n"); ! 1037: #ifdef DEBUG_SHOW_UNUSED ! 1038: printk(KERN_DEBUG "mmc_unused0[]: %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n", ! 1039: m.mmr_unused0[0], ! 1040: m.mmr_unused0[1], ! 1041: m.mmr_unused0[2], ! 1042: m.mmr_unused0[3], ! 1043: m.mmr_unused0[4], ! 1044: m.mmr_unused0[5], ! 1045: m.mmr_unused0[6], ! 1046: m.mmr_unused0[7]); ! 1047: #endif /* DEBUG_SHOW_UNUSED */ ! 1048: printk(KERN_DEBUG "Encryption algorythm: %02X - Status: %02X\n", ! 1049: m.mmr_des_avail, m.mmr_des_status); ! 1050: #ifdef DEBUG_SHOW_UNUSED ! 1051: printk(KERN_DEBUG "mmc_unused1[]: %02X:%02X:%02X:%02X:%02X\n", ! 1052: m.mmr_unused1[0], ! 1053: m.mmr_unused1[1], ! 1054: m.mmr_unused1[2], ! 1055: m.mmr_unused1[3], ! 1056: m.mmr_unused1[4]); ! 1057: #endif /* DEBUG_SHOW_UNUSED */ ! 1058: printk(KERN_DEBUG "dce_status: 0x%x [%s%s%s%s]\n", ! 1059: m.mmr_dce_status, ! 1060: (m.mmr_dce_status & MMR_DCE_STATUS_RX_BUSY) ? "energy detected,":"", ! 1061: (m.mmr_dce_status & MMR_DCE_STATUS_LOOPT_IND) ? ! 1062: "loop test indicated," : "", ! 1063: (m.mmr_dce_status & MMR_DCE_STATUS_TX_BUSY) ? "transmitter on," : "", ! 1064: (m.mmr_dce_status & MMR_DCE_STATUS_JBR_EXPIRED) ? ! 1065: "jabber timer expired," : ""); ! 1066: printk(KERN_DEBUG "Dsp ID: %02X\n", ! 1067: m.mmr_dsp_id); ! 1068: #ifdef DEBUG_SHOW_UNUSED ! 1069: printk(KERN_DEBUG "mmc_unused2[]: %02X:%02X\n", ! 1070: m.mmr_unused2[0], ! 1071: m.mmr_unused2[1]); ! 1072: #endif /* DEBUG_SHOW_UNUSED */ ! 1073: printk(KERN_DEBUG "# correct_nwid: %d, # wrong_nwid: %d\n", ! 1074: (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l, ! 1075: (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l); ! 1076: printk(KERN_DEBUG "thr_pre_set: 0x%x [current signal %s]\n", ! 1077: m.mmr_thr_pre_set & MMR_THR_PRE_SET, ! 1078: (m.mmr_thr_pre_set & MMR_THR_PRE_SET_CUR) ? "above" : "below"); ! 1079: printk(KERN_DEBUG "signal_lvl: %d [%s], ", ! 1080: m.mmr_signal_lvl & MMR_SIGNAL_LVL, ! 1081: (m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) ? "new msg" : "no new msg"); ! 1082: printk("silence_lvl: %d [%s], ", m.mmr_silence_lvl & MMR_SILENCE_LVL, ! 1083: (m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) ? "update done" : "no new update"); ! 1084: printk("sgnl_qual: 0x%x [%s]\n", ! 1085: m.mmr_sgnl_qual & MMR_SGNL_QUAL, ! 1086: (m.mmr_sgnl_qual & MMR_SGNL_QUAL_ANT) ? "Antenna 1" : "Antenna 0"); ! 1087: #ifdef DEBUG_SHOW_UNUSED ! 1088: printk(KERN_DEBUG "netw_id_l: %x\n", m.mmr_netw_id_l); ! 1089: #endif /* DEBUG_SHOW_UNUSED */ ! 1090: } /* wv_mmc_show */ ! 1091: #endif /* DEBUG_MMC_SHOW */ ! 1092: ! 1093: #ifdef DEBUG_I82586_SHOW ! 1094: /*------------------------------------------------------------------*/ ! 1095: /* ! 1096: * Print the last block of the i82586 memory ! 1097: */ ! 1098: static void ! 1099: wv_scb_show(u_long ioaddr) ! 1100: { ! 1101: scb_t scb; ! 1102: ! 1103: obram_read(ioaddr, OFFSET_SCB, (unsigned char *)&scb, sizeof(scb)); ! 1104: ! 1105: printk(KERN_DEBUG "##### WaveLAN system control block: #####\n"); ! 1106: ! 1107: printk(KERN_DEBUG "status: "); ! 1108: printk("stat 0x%x[%s%s%s%s] ", ! 1109: (scb.scb_status & (SCB_ST_CX | SCB_ST_FR | SCB_ST_CNA | SCB_ST_RNR)) >> 12, ! 1110: (scb.scb_status & SCB_ST_CX) ? "cmd completion interrupt," : "", ! 1111: (scb.scb_status & SCB_ST_FR) ? "frame received," : "", ! 1112: (scb.scb_status & SCB_ST_CNA) ? "cmd unit not active," : "", ! 1113: (scb.scb_status & SCB_ST_RNR) ? "rcv unit not ready," : ""); ! 1114: printk("cus 0x%x[%s%s%s] ", ! 1115: (scb.scb_status & SCB_ST_CUS) >> 8, ! 1116: ((scb.scb_status & SCB_ST_CUS) == SCB_ST_CUS_IDLE) ? "idle" : "", ! 1117: ((scb.scb_status & SCB_ST_CUS) == SCB_ST_CUS_SUSP) ? "suspended" : "", ! 1118: ((scb.scb_status & SCB_ST_CUS) == SCB_ST_CUS_ACTV) ? "active" : ""); ! 1119: printk("rus 0x%x[%s%s%s%s]\n", ! 1120: (scb.scb_status & SCB_ST_RUS) >> 4, ! 1121: ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_IDLE) ? "idle" : "", ! 1122: ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_SUSP) ? "suspended" : "", ! 1123: ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_NRES) ? "no resources" : "", ! 1124: ((scb.scb_status & SCB_ST_RUS) == SCB_ST_RUS_RDY) ? "ready" : ""); ! 1125: ! 1126: printk(KERN_DEBUG "command: "); ! 1127: printk("ack 0x%x[%s%s%s%s] ", ! 1128: (scb.scb_command & (SCB_CMD_ACK_CX | SCB_CMD_ACK_FR | SCB_CMD_ACK_CNA | SCB_CMD_ACK_RNR)) >> 12, ! 1129: (scb.scb_command & SCB_CMD_ACK_CX) ? "ack cmd completion," : "", ! 1130: (scb.scb_command & SCB_CMD_ACK_FR) ? "ack frame received," : "", ! 1131: (scb.scb_command & SCB_CMD_ACK_CNA) ? "ack CU not active," : "", ! 1132: (scb.scb_command & SCB_CMD_ACK_RNR) ? "ack RU not ready," : ""); ! 1133: printk("cuc 0x%x[%s%s%s%s%s] ", ! 1134: (scb.scb_command & SCB_CMD_CUC) >> 8, ! 1135: ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_NOP) ? "nop" : "", ! 1136: ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_GO) ? "start cbl_offset" : "", ! 1137: ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_RES) ? "resume execution" : "", ! 1138: ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_SUS) ? "suspend execution" : "", ! 1139: ((scb.scb_command & SCB_CMD_CUC) == SCB_CMD_CUC_ABT) ? "abort execution" : ""); ! 1140: printk("ruc 0x%x[%s%s%s%s%s]\n", ! 1141: (scb.scb_command & SCB_CMD_RUC) >> 4, ! 1142: ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_NOP) ? "nop" : "", ! 1143: ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_GO) ? "start rfa_offset" : "", ! 1144: ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_RES) ? "resume reception" : "", ! 1145: ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_SUS) ? "suspend reception" : "", ! 1146: ((scb.scb_command & SCB_CMD_RUC) == SCB_CMD_RUC_ABT) ? "abort reception" : ""); ! 1147: ! 1148: printk(KERN_DEBUG "cbl_offset 0x%x ", scb.scb_cbl_offset); ! 1149: printk("rfa_offset 0x%x\n", scb.scb_rfa_offset); ! 1150: ! 1151: printk(KERN_DEBUG "crcerrs %d ", scb.scb_crcerrs); ! 1152: printk("alnerrs %d ", scb.scb_alnerrs); ! 1153: printk("rscerrs %d ", scb.scb_rscerrs); ! 1154: printk("ovrnerrs %d\n", scb.scb_ovrnerrs); ! 1155: } ! 1156: ! 1157: /*------------------------------------------------------------------*/ ! 1158: /* ! 1159: * Print the formatted status of the i82586's receive unit. ! 1160: */ ! 1161: static void ! 1162: wv_ru_show(device * dev) ! 1163: { ! 1164: /* net_local *lp = (net_local *) dev->priv; */ ! 1165: ! 1166: printk(KERN_DEBUG "##### WaveLAN i82586 receiver unit status: #####\n"); ! 1167: printk(KERN_DEBUG "ru:"); ! 1168: /* ! 1169: * Not implemented yet... ! 1170: */ ! 1171: printk("\n"); ! 1172: } /* wv_ru_show */ ! 1173: ! 1174: /*------------------------------------------------------------------*/ ! 1175: /* ! 1176: * Display info about one control block of the i82586 memory ! 1177: */ ! 1178: static void ! 1179: wv_cu_show_one(device * dev, ! 1180: net_local * lp, ! 1181: int i, ! 1182: u_short p) ! 1183: { ! 1184: u_long ioaddr; ! 1185: ac_tx_t actx; ! 1186: ! 1187: ioaddr = dev->base_addr; ! 1188: ! 1189: printk("%d: 0x%x:", i, p); ! 1190: ! 1191: obram_read(ioaddr, p, (unsigned char *)&actx, sizeof(actx)); ! 1192: printk(" status=0x%x,", actx.tx_h.ac_status); ! 1193: printk(" command=0x%x,", actx.tx_h.ac_command); ! 1194: ! 1195: /* ! 1196: { ! 1197: tbd_t tbd; ! 1198: ! 1199: obram_read(ioaddr, actx.tx_tbd_offset, (unsigned char *)&tbd, sizeof(tbd)); ! 1200: printk(" tbd_status=0x%x,", tbd.tbd_status); ! 1201: } ! 1202: */ ! 1203: ! 1204: printk("|"); ! 1205: } ! 1206: ! 1207: /*------------------------------------------------------------------*/ ! 1208: /* ! 1209: * Print status of the command unit of the i82586 ! 1210: */ ! 1211: static void ! 1212: wv_cu_show(device * dev) ! 1213: { ! 1214: net_local * lp = (net_local *)dev->priv; ! 1215: unsigned int i; ! 1216: u_short p; ! 1217: ! 1218: printk(KERN_DEBUG "##### WaveLAN i82586 command unit status: #####\n"); ! 1219: ! 1220: printk(KERN_DEBUG); ! 1221: for(i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++) ! 1222: { ! 1223: wv_cu_show_one(dev, lp, i, p); ! 1224: ! 1225: p += TXBLOCKZ; ! 1226: if(p >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ) ! 1227: p -= NTXBLOCKS * TXBLOCKZ; ! 1228: } ! 1229: printk("\n"); ! 1230: } ! 1231: #endif /* DEBUG_I82586_SHOW */ ! 1232: ! 1233: #ifdef DEBUG_DEVICE_SHOW ! 1234: /*------------------------------------------------------------------*/ ! 1235: /* ! 1236: * Print the formatted status of the WaveLAN PCMCIA device driver. ! 1237: */ ! 1238: static void ! 1239: wv_dev_show(device * dev) ! 1240: { ! 1241: printk(KERN_DEBUG "dev:"); ! 1242: printk(" start=%d,", dev->start); ! 1243: printk(" tbusy=%ld,", dev->tbusy); ! 1244: printk(" interrupt=%d,", dev->interrupt); ! 1245: printk(" trans_start=%ld,", dev->trans_start); ! 1246: printk(" flags=0x%x,", dev->flags); ! 1247: printk("\n"); ! 1248: } /* wv_dev_show */ ! 1249: ! 1250: /*------------------------------------------------------------------*/ ! 1251: /* ! 1252: * Print the formatted status of the WaveLAN PCMCIA device driver's ! 1253: * private information. ! 1254: */ ! 1255: static void ! 1256: wv_local_show(device * dev) ! 1257: { ! 1258: net_local *lp; ! 1259: ! 1260: lp = (net_local *)dev->priv; ! 1261: ! 1262: printk(KERN_DEBUG "local:"); ! 1263: printk(" tx_n_in_use=%d,", lp->tx_n_in_use); ! 1264: printk(" hacr=0x%x,", lp->hacr); ! 1265: printk(" rx_head=0x%x,", lp->rx_head); ! 1266: printk(" rx_last=0x%x,", lp->rx_last); ! 1267: printk(" tx_first_free=0x%x,", lp->tx_first_free); ! 1268: printk(" tx_first_in_use=0x%x,", lp->tx_first_in_use); ! 1269: printk("\n"); ! 1270: } /* wv_local_show */ ! 1271: #endif /* DEBUG_DEVICE_SHOW */ ! 1272: ! 1273: #if defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO) ! 1274: /*------------------------------------------------------------------*/ ! 1275: /* ! 1276: * Dump packet header (and content if necessary) on the screen ! 1277: */ ! 1278: static inline void ! 1279: wv_packet_info(u_char * p, /* Packet to dump */ ! 1280: int length, /* Length of the packet */ ! 1281: char * msg1, /* Name of the device */ ! 1282: char * msg2) /* Name of the function */ ! 1283: { ! 1284: #ifndef DEBUG_PACKET_DUMP ! 1285: printk(KERN_DEBUG "%s: %s(): dest %02X:%02X:%02X:%02X:%02X:%02X, length %d\n", ! 1286: msg1, msg2, p[0], p[1], p[2], p[3], p[4], p[5], length); ! 1287: printk(KERN_DEBUG "%s: %s(): src %02X:%02X:%02X:%02X:%02X:%02X, type 0x%02X%02X\n", ! 1288: msg1, msg2, p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13]); ! 1289: ! 1290: #else /* DEBUG_PACKET_DUMP */ ! 1291: int i; ! 1292: int maxi; ! 1293: ! 1294: printk(KERN_DEBUG "%s: %s(): len=%d, data=\"", msg1, msg2, length); ! 1295: ! 1296: if((maxi = length) > DEBUG_PACKET_DUMP) ! 1297: maxi = DEBUG_PACKET_DUMP; ! 1298: for(i = 0; i < maxi; i++) ! 1299: if(p[i] >= ' ' && p[i] <= '~') ! 1300: printk(" %c", p[i]); ! 1301: else ! 1302: printk("%02X", p[i]); ! 1303: if(maxi < length) ! 1304: printk(".."); ! 1305: printk("\"\n"); ! 1306: printk(KERN_DEBUG "\n"); ! 1307: #endif /* DEBUG_PACKET_DUMP */ ! 1308: } ! 1309: #endif /* defined(DEBUG_RX_INFO) || defined(DEBUG_TX_INFO) */ ! 1310: ! 1311: /*------------------------------------------------------------------*/ ! 1312: /* ! 1313: * This is the information which is displayed by the driver at startup ! 1314: * There is a lot of flag to configure it at your will... ! 1315: */ ! 1316: static inline void ! 1317: wv_init_info(device * dev) ! 1318: { ! 1319: short ioaddr = dev->base_addr; ! 1320: net_local * lp = (net_local *)dev->priv; ! 1321: psa_t psa; ! 1322: int i; ! 1323: ! 1324: /* Read the parameter storage area */ ! 1325: psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa)); ! 1326: ! 1327: #ifdef DEBUG_PSA_SHOW ! 1328: wv_psa_show(&psa); ! 1329: #endif ! 1330: #ifdef DEBUG_MMC_SHOW ! 1331: wv_mmc_show(dev); ! 1332: #endif ! 1333: #ifdef DEBUG_I82586_SHOW ! 1334: wv_cu_show(dev); ! 1335: #endif ! 1336: ! 1337: #ifdef DEBUG_BASIC_SHOW ! 1338: /* Now, let's go for the basic stuff */ ! 1339: printk(KERN_NOTICE "%s: WaveLAN at %#x,", dev->name, ioaddr); ! 1340: for(i = 0; i < WAVELAN_ADDR_SIZE; i++) ! 1341: printk("%s%02X", (i == 0) ? " " : ":", dev->dev_addr[i]); ! 1342: printk(", IRQ %d", dev->irq); ! 1343: ! 1344: /* Print current network id */ ! 1345: if(psa.psa_nwid_select) ! 1346: printk(", nwid 0x%02X-%02X", psa.psa_nwid[0], psa.psa_nwid[1]); ! 1347: else ! 1348: printk(", nwid off"); ! 1349: ! 1350: /* If 2.00 card */ ! 1351: if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) & ! 1352: (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) ! 1353: { ! 1354: unsigned short freq; ! 1355: ! 1356: /* Ask the EEPROM to read the frequency from the first area */ ! 1357: fee_read(ioaddr, 0x00 /* 1st area - frequency... */, ! 1358: &freq, 1); ! 1359: ! 1360: /* Print frequency */ ! 1361: printk(", 2.00, %ld", (freq >> 6) + 2400L); ! 1362: ! 1363: /* Hack !!! */ ! 1364: if(freq & 0x20) ! 1365: printk(".5"); ! 1366: } ! 1367: else ! 1368: { ! 1369: printk(", PC"); ! 1370: switch(psa.psa_comp_number) ! 1371: { ! 1372: case PSA_COMP_PC_AT_915: ! 1373: case PSA_COMP_PC_AT_2400: ! 1374: printk("-AT"); ! 1375: break; ! 1376: case PSA_COMP_PC_MC_915: ! 1377: case PSA_COMP_PC_MC_2400: ! 1378: printk("-MC"); ! 1379: break; ! 1380: case PSA_COMP_PCMCIA_915: ! 1381: printk("MCIA"); ! 1382: break; ! 1383: default: ! 1384: printk("???"); ! 1385: } ! 1386: printk(", "); ! 1387: switch (psa.psa_subband) ! 1388: { ! 1389: case PSA_SUBBAND_915: ! 1390: printk("915"); ! 1391: break; ! 1392: case PSA_SUBBAND_2425: ! 1393: printk("2425"); ! 1394: break; ! 1395: case PSA_SUBBAND_2460: ! 1396: printk("2460"); ! 1397: break; ! 1398: case PSA_SUBBAND_2484: ! 1399: printk("2484"); ! 1400: break; ! 1401: case PSA_SUBBAND_2430_5: ! 1402: printk("2430.5"); ! 1403: break; ! 1404: default: ! 1405: printk("???"); ! 1406: } ! 1407: } ! 1408: ! 1409: printk(" MHz\n"); ! 1410: #endif /* DEBUG_BASIC_SHOW */ ! 1411: ! 1412: #ifdef DEBUG_VERSION_SHOW ! 1413: /* Print version information */ ! 1414: printk(KERN_NOTICE "%s", version); ! 1415: #endif ! 1416: } /* wv_init_info */ ! 1417: ! 1418: /********************* IOCTL, STATS & RECONFIG *********************/ ! 1419: /* ! 1420: * We found here routines that are called by Linux on differents ! 1421: * occasions after the configuration and not for transmitting data ! 1422: * These may be called when the user use ifconfig, /proc/net/dev ! 1423: * or wireless extensions ! 1424: */ ! 1425: ! 1426: /*------------------------------------------------------------------*/ ! 1427: /* ! 1428: * Get the current ethernet statistics. This may be called with the ! 1429: * card open or closed. ! 1430: * Used when the user read /proc/net/dev ! 1431: */ ! 1432: static en_stats * ! 1433: wavelan_get_stats(device * dev) ! 1434: { ! 1435: #ifdef DEBUG_IOCTL_TRACE ! 1436: printk(KERN_DEBUG "%s: <>wavelan_get_stats()\n", dev->name); ! 1437: #endif ! 1438: ! 1439: return(&((net_local *) dev->priv)->stats); ! 1440: } ! 1441: ! 1442: /*------------------------------------------------------------------*/ ! 1443: /* ! 1444: * Set or clear the multicast filter for this adaptor. ! 1445: * num_addrs == -1 Promiscuous mode, receive all packets ! 1446: * num_addrs == 0 Normal mode, clear multicast list ! 1447: * num_addrs > 0 Multicast mode, receive normal and MC packets, ! 1448: * and do best-effort filtering. ! 1449: */ ! 1450: static void ! 1451: wavelan_set_multicast_list(device * dev) ! 1452: { ! 1453: net_local * lp = (net_local *) dev->priv; ! 1454: ! 1455: #ifdef DEBUG_IOCTL_TRACE ! 1456: printk(KERN_DEBUG "%s: ->wavelan_set_multicast_list()\n", dev->name); ! 1457: #endif ! 1458: ! 1459: #ifdef DEBUG_IOCTL_INFO ! 1460: printk(KERN_DEBUG "%s: wavelan_set_multicast_list(): setting Rx mode %02X to %d addresses.\n", ! 1461: dev->name, dev->flags, dev->mc_count); ! 1462: #endif ! 1463: ! 1464: /* If we ask for promiscuous mode, ! 1465: * or all multicast addresses (we don't have that !) ! 1466: * or too much multicast addresses for the hardware filter */ ! 1467: if((dev->flags & IFF_PROMISC) || ! 1468: (dev->flags & IFF_ALLMULTI) || ! 1469: (dev->mc_count > I82586_MAX_MULTICAST_ADDRESSES)) ! 1470: { ! 1471: /* ! 1472: * Enable promiscuous mode: receive all packets. ! 1473: */ ! 1474: if(!lp->promiscuous) ! 1475: { ! 1476: lp->promiscuous = 1; ! 1477: lp->mc_count = 0; ! 1478: ! 1479: wv_82586_reconfig(dev); ! 1480: ! 1481: /* Tell the kernel that we are doing a really bad job... */ ! 1482: dev->flags |= IFF_PROMISC; ! 1483: } ! 1484: } ! 1485: else ! 1486: /* If there is some multicast addresses to send */ ! 1487: if(dev->mc_list != (struct dev_mc_list *) NULL) ! 1488: { ! 1489: /* ! 1490: * Disable promiscuous mode, but receive all packets ! 1491: * in multicast list ! 1492: */ ! 1493: #ifdef MULTICAST_AVOID ! 1494: if(lp->promiscuous || ! 1495: (dev->mc_count != lp->mc_count)) ! 1496: #endif ! 1497: { ! 1498: lp->promiscuous = 0; ! 1499: lp->mc_count = dev->mc_count; ! 1500: ! 1501: wv_82586_reconfig(dev); ! 1502: } ! 1503: } ! 1504: else ! 1505: { ! 1506: /* ! 1507: * Switch to normal mode: disable promiscuous mode and ! 1508: * clear the multicast list. ! 1509: */ ! 1510: if(lp->promiscuous || lp->mc_count == 0) ! 1511: { ! 1512: lp->promiscuous = 0; ! 1513: lp->mc_count = 0; ! 1514: ! 1515: wv_82586_reconfig(dev); ! 1516: } ! 1517: } ! 1518: #ifdef DEBUG_IOCTL_TRACE ! 1519: printk(KERN_DEBUG "%s: <-wavelan_set_multicast_list()\n", dev->name); ! 1520: #endif ! 1521: } ! 1522: ! 1523: /*------------------------------------------------------------------*/ ! 1524: /* ! 1525: * This function doesn't exist... ! 1526: */ ! 1527: static int ! 1528: wavelan_set_mac_address(device * dev, ! 1529: void * addr) ! 1530: { ! 1531: struct sockaddr * mac = addr; ! 1532: ! 1533: /* Copy the address */ ! 1534: memcpy(dev->dev_addr, mac->sa_data, WAVELAN_ADDR_SIZE); ! 1535: ! 1536: /* Reconfig the beast */ ! 1537: wv_82586_reconfig(dev); ! 1538: ! 1539: return 0; ! 1540: } ! 1541: ! 1542: #ifdef WIRELESS_EXT /* If wireless extension exist in the kernel */ ! 1543: ! 1544: /*------------------------------------------------------------------*/ ! 1545: /* ! 1546: * Frequency setting (for hardware able of it) ! 1547: * It's a bit complicated and you don't really want to look into it... ! 1548: * (called in wavelan_ioctl) ! 1549: */ ! 1550: static inline int ! 1551: wv_set_frequency(u_long ioaddr, /* i/o port of the card */ ! 1552: iw_freq * frequency) ! 1553: { ! 1554: const int BAND_NUM = 10; /* Number of bands */ ! 1555: long freq = 0L; /* offset to 2.4 GHz in .5 MHz */ ! 1556: #ifdef DEBUG_IOCTL_INFO ! 1557: int i; ! 1558: #endif ! 1559: ! 1560: /* Setting by frequency */ ! 1561: /* Theoretically, you may set any frequency between ! 1562: * the two limits with a 0.5 MHz precision. In practice, ! 1563: * I don't want you to have trouble with local ! 1564: * regulations... */ ! 1565: if((frequency->e == 1) && ! 1566: (frequency->m >= (int) 2.412e8) && (frequency->m <= (int) 2.487e8)) ! 1567: { ! 1568: freq = ((frequency->m / 10000) - 24000L) / 5; ! 1569: } ! 1570: ! 1571: /* Setting by channel (same as wfreqsel) */ ! 1572: /* Warning : each channel is 22MHz wide, so some of the channels ! 1573: * will interfere... */ ! 1574: if((frequency->e == 0) && ! 1575: (frequency->m >= 0) && (frequency->m < BAND_NUM)) ! 1576: { ! 1577: /* frequency in 1/4 of MHz (as read in the offset register) */ ! 1578: short bands[] = { 0x30, 0x58, 0x64, 0x7A, 0x80, 0xA8, 0xD0, 0xF0, 0xF8, 0x150 }; ! 1579: ! 1580: /* Get frequency offset */ ! 1581: freq = bands[frequency->m] >> 1; ! 1582: } ! 1583: ! 1584: /* Verify if the frequency is allowed */ ! 1585: if(freq != 0L) ! 1586: { ! 1587: u_short table[10]; /* Authorized frequency table */ ! 1588: ! 1589: /* Read the frequency table */ ! 1590: fee_read(ioaddr, 0x71 /* frequency table */, ! 1591: table, 10); ! 1592: ! 1593: #ifdef DEBUG_IOCTL_INFO ! 1594: printk(KERN_DEBUG "Frequency table :"); ! 1595: for(i = 0; i < 10; i++) ! 1596: { ! 1597: printk(" %04X", ! 1598: table[i]); ! 1599: } ! 1600: printk("\n"); ! 1601: #endif ! 1602: ! 1603: /* Look in the table if the frequency is allowed */ ! 1604: if(!(table[9 - ((freq - 24) / 16)] & ! 1605: (1 << ((freq - 24) % 16)))) ! 1606: return -EINVAL; /* not allowed */ ! 1607: } ! 1608: else ! 1609: return -EINVAL; ! 1610: ! 1611: /* If we get a usable frequency */ ! 1612: if(freq != 0L) ! 1613: { ! 1614: unsigned short area[16]; ! 1615: unsigned short dac[2]; ! 1616: unsigned short area_verify[16]; ! 1617: unsigned short dac_verify[2]; ! 1618: /* Corresponding gain (in the power adjust value table) ! 1619: * see AT&T WaveLAN Data Manual, REF 407-024689/E, page 3-8 ! 1620: * & WCIN062D.DOC, page 6.2.9 */ ! 1621: unsigned short power_limit[] = { 40, 80, 120, 160, 0 }; ! 1622: int power_band = 0; /* Selected band */ ! 1623: unsigned short power_adjust; /* Correct value */ ! 1624: ! 1625: /* Search for the gain */ ! 1626: power_band = 0; ! 1627: while((freq > power_limit[power_band]) && ! 1628: (power_limit[++power_band] != 0)) ! 1629: ; ! 1630: ! 1631: /* Read the first area */ ! 1632: fee_read(ioaddr, 0x00, ! 1633: area, 16); ! 1634: ! 1635: /* Read the DAC */ ! 1636: fee_read(ioaddr, 0x60, ! 1637: dac, 2); ! 1638: ! 1639: /* Read the new power adjust value */ ! 1640: fee_read(ioaddr, 0x6B - (power_band >> 1), ! 1641: &power_adjust, 1); ! 1642: if(power_band & 0x1) ! 1643: power_adjust >>= 8; ! 1644: else ! 1645: power_adjust &= 0xFF; ! 1646: ! 1647: #ifdef DEBUG_IOCTL_INFO ! 1648: printk(KERN_DEBUG "WaveLAN EEPROM Area 1:"); ! 1649: for(i = 0; i < 16; i++) ! 1650: { ! 1651: printk(" %04X", ! 1652: area[i]); ! 1653: } ! 1654: printk("\n"); ! 1655: ! 1656: printk(KERN_DEBUG "WaveLAN EEPROM DAC: %04X %04X\n", ! 1657: dac[0], dac[1]); ! 1658: #endif ! 1659: ! 1660: /* Frequency offset (for info only) */ ! 1661: area[0] = ((freq << 5) & 0xFFE0) | (area[0] & 0x1F); ! 1662: ! 1663: /* Receiver Principle main divider coefficient */ ! 1664: area[3] = (freq >> 1) + 2400L - 352L; ! 1665: area[2] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF); ! 1666: ! 1667: /* Transmitter Main divider coefficient */ ! 1668: area[13] = (freq >> 1) + 2400L; ! 1669: area[12] = ((freq & 0x1) << 4) | (area[2] & 0xFFEF); ! 1670: ! 1671: /* Others part of the area are flags, bit streams or unused... */ ! 1672: ! 1673: /* Set the value in the DAC. */ ! 1674: dac[1] = ((power_adjust >> 1) & 0x7F) | (dac[1] & 0xFF80); ! 1675: dac[0] = ((power_adjust & 0x1) << 4) | (dac[0] & 0xFFEF); ! 1676: ! 1677: /* Write the first area. */ ! 1678: fee_write(ioaddr, 0x00, ! 1679: area, 16); ! 1680: ! 1681: /* Write the DAC. */ ! 1682: fee_write(ioaddr, 0x60, ! 1683: dac, 2); ! 1684: ! 1685: /* We now should verify here that the EEPROM writing was OK. */ ! 1686: ! 1687: /* Reread the first area. */ ! 1688: fee_read(ioaddr, 0x00, ! 1689: area_verify, 16); ! 1690: ! 1691: /* ReRead the DAC */ ! 1692: fee_read(ioaddr, 0x60, ! 1693: dac_verify, 2); ! 1694: ! 1695: /* Compare */ ! 1696: if(memcmp(area, area_verify, 16 * 2) || ! 1697: memcmp(dac, dac_verify, 2 * 2)) ! 1698: { ! 1699: #ifdef DEBUG_IOCTL_ERROR ! 1700: printk(KERN_INFO "WaveLAN: wv_set_frequency: unable to write new frequency to EEPROM(?).\n"); ! 1701: #endif ! 1702: return -EOPNOTSUPP; ! 1703: } ! 1704: ! 1705: /* We must download the frequency parameters to the ! 1706: * synthesizers (from the EEPROM - area 1) ! 1707: * Note: as the EEPROM is automatically decremented, we set the end ! 1708: * if the area... */ ! 1709: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x0F); ! 1710: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), ! 1711: MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD); ! 1712: ! 1713: /* Wait until the download is finished */ ! 1714: fee_wait(ioaddr, 100, 100); ! 1715: ! 1716: /* We must now download the power adjust value (gain) to ! 1717: * the synthesizers (from the EEPROM - area 7 - DAC) */ ! 1718: mmc_out(ioaddr, mmwoff(0, mmw_fee_addr), 0x61); ! 1719: mmc_out(ioaddr, mmwoff(0, mmw_fee_ctrl), ! 1720: MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD); ! 1721: ! 1722: /* Wait until the download is finished */ ! 1723: fee_wait(ioaddr, 100, 100); ! 1724: ! 1725: #ifdef DEBUG_IOCTL_INFO ! 1726: /* Verification of what we have done... */ ! 1727: ! 1728: printk(KERN_DEBUG "WaveLAN EEPROM Area 1:"); ! 1729: for(i = 0; i < 16; i++) ! 1730: { ! 1731: printk(" %04X", ! 1732: area_verify[i]); ! 1733: } ! 1734: printk("\n"); ! 1735: ! 1736: printk(KERN_DEBUG "WaveLAN EEPROM DAC: %04X %04X\n", ! 1737: dac_verify[0], dac_verify[1]); ! 1738: #endif ! 1739: ! 1740: return 0; ! 1741: } ! 1742: else ! 1743: return -EINVAL; /* Bah, never get there... */ ! 1744: } ! 1745: ! 1746: /*------------------------------------------------------------------*/ ! 1747: /* ! 1748: * Give the list of available frequencies ! 1749: */ ! 1750: static inline int ! 1751: wv_frequency_list(u_long ioaddr, /* i/o port of the card */ ! 1752: iw_freq * list, /* List of frequency to fill */ ! 1753: int max) /* Maximum number of frequencies */ ! 1754: { ! 1755: u_short table[10]; /* Authorized frequency table */ ! 1756: long freq = 0L; /* offset to 2.4 GHz in .5 MHz + 12 MHz */ ! 1757: int i; /* index in the table */ ! 1758: ! 1759: /* Read the frequency table */ ! 1760: fee_read(ioaddr, 0x71 /* frequency table */, ! 1761: table, 10); ! 1762: ! 1763: /* Look all frequencies */ ! 1764: i = 0; ! 1765: for(freq = 0; freq < 150; freq++) ! 1766: /* Look in the table if the frequency is allowed */ ! 1767: if(table[9 - (freq / 16)] & (1 << (freq % 16))) ! 1768: { ! 1769: /* put in the list */ ! 1770: list[i].m = (((freq + 24) * 5) + 24000L) * 10000; ! 1771: list[i++].e = 1; ! 1772: ! 1773: /* Check number */ ! 1774: if(i >= max) ! 1775: return(i); ! 1776: } ! 1777: ! 1778: return(i); ! 1779: } ! 1780: ! 1781: #ifdef WIRELESS_SPY ! 1782: /*------------------------------------------------------------------*/ ! 1783: /* ! 1784: * Gather wireless spy statistics : for each packet, compare the source ! 1785: * address with out list, and if match, get the stats... ! 1786: * Sorry, but this function really need wireless extensions... ! 1787: */ ! 1788: static inline void ! 1789: wl_spy_gather(device * dev, ! 1790: u_char * mac, /* MAC address */ ! 1791: u_char * stats) /* Statistics to gather */ ! 1792: { ! 1793: net_local * lp = (net_local *) dev->priv; ! 1794: int i; ! 1795: ! 1796: /* Look all addresses */ ! 1797: for(i = 0; i < lp->spy_number; i++) ! 1798: /* If match */ ! 1799: if(!memcmp(mac, lp->spy_address[i], WAVELAN_ADDR_SIZE)) ! 1800: { ! 1801: /* Update statistics */ ! 1802: lp->spy_stat[i].qual = stats[2] & MMR_SGNL_QUAL; ! 1803: lp->spy_stat[i].level = stats[0] & MMR_SIGNAL_LVL; ! 1804: lp->spy_stat[i].noise = stats[1] & MMR_SILENCE_LVL; ! 1805: lp->spy_stat[i].updated = 0x7; ! 1806: } ! 1807: } ! 1808: #endif /* WIRELESS_SPY */ ! 1809: ! 1810: #ifdef HISTOGRAM ! 1811: /*------------------------------------------------------------------*/ ! 1812: /* ! 1813: * This function calculates an histogram on the signal level. ! 1814: * As the noise is quite constant, it's like doing it on the SNR. ! 1815: * We have defined a set of interval (lp->his_range), and each time ! 1816: * the level goes in that interval, we increment the count (lp->his_sum). ! 1817: * With this histogram you may detect if one WaveLAN is really weak, ! 1818: * or you may also calculate the mean and standard deviation of the level. ! 1819: */ ! 1820: static inline void ! 1821: wl_his_gather(device * dev, ! 1822: u_char * stats) /* Statistics to gather */ ! 1823: { ! 1824: net_local * lp = (net_local *) dev->priv; ! 1825: u_char level = stats[0] & MMR_SIGNAL_LVL; ! 1826: int i; ! 1827: ! 1828: /* Find the correct interval */ ! 1829: i = 0; ! 1830: while((i < (lp->his_number - 1)) && (level >= lp->his_range[i++])) ! 1831: ; ! 1832: ! 1833: /* Increment interval counter */ ! 1834: (lp->his_sum[i])++; ! 1835: } ! 1836: #endif /* HISTOGRAM */ ! 1837: ! 1838: /*------------------------------------------------------------------*/ ! 1839: /* ! 1840: * Perform ioctl : config & info stuff ! 1841: * This is here that are treated the wireless extensions (iwconfig) ! 1842: */ ! 1843: static int ! 1844: wavelan_ioctl(struct device * dev, /* device on which the ioctl is applied */ ! 1845: struct ifreq * rq, /* data passed */ ! 1846: int cmd) /* ioctl number */ ! 1847: { ! 1848: u_long ioaddr = dev->base_addr; ! 1849: net_local * lp = (net_local *)dev->priv; /* lp is not unused */ ! 1850: struct iwreq * wrq = (struct iwreq *) rq; ! 1851: psa_t psa; ! 1852: mm_t m; ! 1853: unsigned long x; ! 1854: int ret = 0; ! 1855: ! 1856: #ifdef DEBUG_IOCTL_TRACE ! 1857: printk(KERN_DEBUG "%s: ->wavelan_ioctl(cmd=0x%X)\n", dev->name, cmd); ! 1858: #endif ! 1859: ! 1860: /* Disable interrupts & save flags */ ! 1861: x = wv_splhi(); ! 1862: ! 1863: /* Look what is the request */ ! 1864: switch(cmd) ! 1865: { ! 1866: /* --------------- WIRELESS EXTENSIONS --------------- */ ! 1867: ! 1868: case SIOCGIWNAME: ! 1869: strcpy(wrq->u.name, "Wavelan"); ! 1870: break; ! 1871: ! 1872: case SIOCSIWNWID: ! 1873: /* Set NWID in WaveLAN */ ! 1874: if(wrq->u.nwid.on) ! 1875: { ! 1876: /* Set NWID in psa */ ! 1877: psa.psa_nwid[0] = (wrq->u.nwid.nwid & 0xFF00) >> 8; ! 1878: psa.psa_nwid[1] = wrq->u.nwid.nwid & 0xFF; ! 1879: psa.psa_nwid_select = 0x01; ! 1880: psa_write(ioaddr, lp->hacr, (char *)psa.psa_nwid - (char *)&psa, ! 1881: (unsigned char *)psa.psa_nwid, 3); ! 1882: ! 1883: /* Set NWID in mmc */ ! 1884: m.w.mmw_netw_id_l = wrq->u.nwid.nwid & 0xFF; ! 1885: m.w.mmw_netw_id_h = (wrq->u.nwid.nwid & 0xFF00) >> 8; ! 1886: mmc_write(ioaddr, (char *)&m.w.mmw_netw_id_l - (char *)&m, ! 1887: (unsigned char *)&m.w.mmw_netw_id_l, 2); ! 1888: mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel), 0x00); ! 1889: } ! 1890: else ! 1891: { ! 1892: /* Disable nwid in the psa */ ! 1893: psa.psa_nwid_select = 0x00; ! 1894: psa_write(ioaddr, lp->hacr, ! 1895: (char *)&psa.psa_nwid_select - (char *)&psa, ! 1896: (unsigned char *)&psa.psa_nwid_select, 1); ! 1897: ! 1898: /* Disable nwid in the mmc (no filtering) */ ! 1899: mmc_out(ioaddr, mmwoff(0, mmw_loopt_sel), MMW_LOOPT_SEL_DIS_NWID); ! 1900: } ! 1901: break; ! 1902: ! 1903: case SIOCGIWNWID: ! 1904: /* Read the NWID */ ! 1905: psa_read(ioaddr, lp->hacr, (char *)psa.psa_nwid - (char *)&psa, ! 1906: (unsigned char *)psa.psa_nwid, 3); ! 1907: wrq->u.nwid.nwid = (psa.psa_nwid[0] << 8) + psa.psa_nwid[1]; ! 1908: wrq->u.nwid.on = psa.psa_nwid_select; ! 1909: break; ! 1910: ! 1911: case SIOCSIWFREQ: ! 1912: /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable) */ ! 1913: if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) & ! 1914: (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) ! 1915: ret = wv_set_frequency(ioaddr, &(wrq->u.freq)); ! 1916: else ! 1917: ret = -EOPNOTSUPP; ! 1918: break; ! 1919: ! 1920: case SIOCGIWFREQ: ! 1921: /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable) ! 1922: * (does it work for everybody ??? - especially old cards...) */ ! 1923: if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) & ! 1924: (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) ! 1925: { ! 1926: unsigned short freq; ! 1927: ! 1928: /* Ask the EEPROM to read the frequency from the first area */ ! 1929: fee_read(ioaddr, 0x00 /* 1st area - frequency... */, ! 1930: &freq, 1); ! 1931: wrq->u.freq.m = ((freq >> 5) * 5 + 24000L) * 10000; ! 1932: wrq->u.freq.e = 1; ! 1933: } ! 1934: else ! 1935: { ! 1936: int bands[] = { 915e6, 2.425e8, 2.46e8, 2.484e8, 2.4305e8 }; ! 1937: ! 1938: psa_read(ioaddr, lp->hacr, (char *)&psa.psa_subband - (char *)&psa, ! 1939: (unsigned char *)&psa.psa_subband, 1); ! 1940: ! 1941: if(psa.psa_subband <= 4) ! 1942: { ! 1943: wrq->u.freq.m = bands[psa.psa_subband]; ! 1944: wrq->u.freq.e = (psa.psa_subband != 0); ! 1945: } ! 1946: else ! 1947: ret = -EOPNOTSUPP; ! 1948: } ! 1949: break; ! 1950: ! 1951: case SIOCSIWSENS: ! 1952: /* Set the level threshold */ ! 1953: if(!suser()) ! 1954: return -EPERM; ! 1955: psa.psa_thr_pre_set = wrq->u.sensitivity & 0x3F; ! 1956: psa_write(ioaddr, lp->hacr, (char *)&psa.psa_thr_pre_set - (char *)&psa, ! 1957: (unsigned char *) &psa.psa_thr_pre_set, 1); ! 1958: mmc_out(ioaddr, mmwoff(0, mmw_thr_pre_set), psa.psa_thr_pre_set); ! 1959: break; ! 1960: ! 1961: case SIOCGIWSENS: ! 1962: /* Read the level threshold */ ! 1963: psa_read(ioaddr, lp->hacr, (char *)&psa.psa_thr_pre_set - (char *)&psa, ! 1964: (unsigned char *) &psa.psa_thr_pre_set, 1); ! 1965: wrq->u.sensitivity = psa.psa_thr_pre_set & 0x3F; ! 1966: break; ! 1967: ! 1968: case SIOCSIWENCODE: ! 1969: /* Set encryption key */ ! 1970: if(!mmc_encr(ioaddr)) ! 1971: { ! 1972: ret = -EOPNOTSUPP; ! 1973: break; ! 1974: } ! 1975: ! 1976: if(wrq->u.encoding.method) ! 1977: { /* enable encryption */ ! 1978: int i; ! 1979: long long key = wrq->u.encoding.code; ! 1980: ! 1981: for(i = 7; i >= 0; i--) ! 1982: { ! 1983: psa.psa_encryption_key[i] = key & 0xFF; ! 1984: key >>= 8; ! 1985: } ! 1986: psa.psa_encryption_select = 1; ! 1987: psa_write(ioaddr, lp->hacr, ! 1988: (char *) &psa.psa_encryption_select - (char *) &psa, ! 1989: (unsigned char *) &psa.psa_encryption_select, 8+1); ! 1990: ! 1991: mmc_out(ioaddr, mmwoff(0, mmw_encr_enable), ! 1992: MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE); ! 1993: mmc_write(ioaddr, mmwoff(0, mmw_encr_key), ! 1994: (unsigned char *) &psa.psa_encryption_key, 8); ! 1995: } ! 1996: else ! 1997: { /* disable encryption */ ! 1998: psa.psa_encryption_select = 0; ! 1999: psa_write(ioaddr, lp->hacr, ! 2000: (char *) &psa.psa_encryption_select - (char *) &psa, ! 2001: (unsigned char *) &psa.psa_encryption_select, 1); ! 2002: ! 2003: mmc_out(ioaddr, mmwoff(0, mmw_encr_enable), 0); ! 2004: } ! 2005: break; ! 2006: ! 2007: case SIOCGIWENCODE: ! 2008: /* Read the encryption key */ ! 2009: if(!mmc_encr(ioaddr)) ! 2010: { ! 2011: ret = -EOPNOTSUPP; ! 2012: break; ! 2013: } ! 2014: ! 2015: /* only super-user can see encryption key */ ! 2016: if(!suser()) ! 2017: { ! 2018: ret = -EPERM; ! 2019: break; ! 2020: } ! 2021: else ! 2022: { ! 2023: int i; ! 2024: long long key = 0; ! 2025: ! 2026: psa_read(ioaddr, lp->hacr, ! 2027: (char *) &psa.psa_encryption_select - (char *) &psa, ! 2028: (unsigned char *) &psa.psa_encryption_select, 1+8); ! 2029: for(i = 0; i < 8; i++) ! 2030: { ! 2031: key <<= 8; ! 2032: key += psa.psa_encryption_key[i]; ! 2033: } ! 2034: wrq->u.encoding.code = key; ! 2035: ! 2036: /* encryption is enabled */ ! 2037: if(psa.psa_encryption_select) ! 2038: wrq->u.encoding.method = mmc_encr(ioaddr); ! 2039: else ! 2040: wrq->u.encoding.method = 0; ! 2041: } ! 2042: break; ! 2043: ! 2044: case SIOCGIWRANGE: ! 2045: /* basic checking */ ! 2046: if(wrq->u.data.pointer != (caddr_t) 0) ! 2047: { ! 2048: struct iw_range range; ! 2049: ! 2050: /* Verify the user buffer */ ! 2051: ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer, ! 2052: sizeof(struct iw_range)); ! 2053: if(ret) ! 2054: break; ! 2055: ! 2056: /* Set the length (useless : its constant...) */ ! 2057: wrq->u.data.length = sizeof(struct iw_range); ! 2058: ! 2059: /* Set information in the range struct */ ! 2060: range.throughput = 1.6 * 1024 * 1024; /* don't argue on this ! */ ! 2061: range.min_nwid = 0x0000; ! 2062: range.max_nwid = 0xFFFF; ! 2063: ! 2064: /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable). */ ! 2065: if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) & ! 2066: (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) ! 2067: { ! 2068: range.num_channels = 10; ! 2069: range.num_frequency = wv_frequency_list(ioaddr, range.freq, ! 2070: IW_MAX_FREQUENCIES); ! 2071: } ! 2072: else ! 2073: range.num_channels = range.num_frequency = 0; ! 2074: ! 2075: range.sensitivity = 0x3F; ! 2076: range.max_qual.qual = MMR_SGNL_QUAL; ! 2077: range.max_qual.level = MMR_SIGNAL_LVL; ! 2078: range.max_qual.noise = MMR_SILENCE_LVL; ! 2079: ! 2080: /* Copy structure to the user buffer */ ! 2081: copy_to_user(wrq->u.data.pointer, &range, ! 2082: sizeof(struct iw_range)); ! 2083: } ! 2084: break; ! 2085: ! 2086: case SIOCGIWPRIV: ! 2087: /* Basic checking... */ ! 2088: if(wrq->u.data.pointer != (caddr_t) 0) ! 2089: { ! 2090: struct iw_priv_args priv[] = ! 2091: { /* cmd, set_args, get_args, name */ ! 2092: { SIOCSIPQTHR, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "setqualthr" }, ! 2093: { SIOCGIPQTHR, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "getqualthr" }, ! 2094: ! 2095: { SIOCSIPHISTO, IW_PRIV_TYPE_BYTE | 16, 0, "sethisto" }, ! 2096: { SIOCGIPHISTO, 0, IW_PRIV_TYPE_INT | 16, "gethisto" }, ! 2097: }; ! 2098: ! 2099: /* Verify the user buffer */ ! 2100: ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer, ! 2101: sizeof(priv)); ! 2102: if(ret) ! 2103: break; ! 2104: ! 2105: /* Set the number of ioctl available */ ! 2106: wrq->u.data.length = 4; ! 2107: ! 2108: /* Copy structure to the user buffer */ ! 2109: copy_to_user(wrq->u.data.pointer, (u_char *) priv, ! 2110: sizeof(priv)); ! 2111: } ! 2112: break; ! 2113: ! 2114: #ifdef WIRELESS_SPY ! 2115: case SIOCSIWSPY: ! 2116: /* Set the spy list */ ! 2117: ! 2118: /* Check the number of addresses */ ! 2119: if(wrq->u.data.length > IW_MAX_SPY) ! 2120: { ! 2121: ret = -E2BIG; ! 2122: break; ! 2123: } ! 2124: lp->spy_number = wrq->u.data.length; ! 2125: ! 2126: /* If there is some addresses to copy */ ! 2127: if(lp->spy_number > 0) ! 2128: { ! 2129: struct sockaddr address[IW_MAX_SPY]; ! 2130: int i; ! 2131: ! 2132: /* Verify where the user has set his addresses */ ! 2133: ret = verify_area(VERIFY_READ, wrq->u.data.pointer, ! 2134: sizeof(struct sockaddr) * lp->spy_number); ! 2135: if(ret) ! 2136: break; ! 2137: /* Copy addresses to the driver */ ! 2138: copy_from_user(address, wrq->u.data.pointer, ! 2139: sizeof(struct sockaddr) * lp->spy_number); ! 2140: ! 2141: /* Copy addresses to the lp structure */ ! 2142: for(i = 0; i < lp->spy_number; i++) ! 2143: { ! 2144: memcpy(lp->spy_address[i], address[i].sa_data, ! 2145: WAVELAN_ADDR_SIZE); ! 2146: } ! 2147: ! 2148: /* Reset structure... */ ! 2149: memset(lp->spy_stat, 0x00, sizeof(iw_qual) * IW_MAX_SPY); ! 2150: ! 2151: #ifdef DEBUG_IOCTL_INFO ! 2152: printk(KERN_DEBUG "SetSpy - Set of new addresses is :\n"); ! 2153: for(i = 0; i < wrq->u.data.length; i++) ! 2154: printk(KERN_DEBUG "%02X:%02X:%02X:%02X:%02X:%02X \n", ! 2155: lp->spy_address[i][0], ! 2156: lp->spy_address[i][1], ! 2157: lp->spy_address[i][2], ! 2158: lp->spy_address[i][3], ! 2159: lp->spy_address[i][4], ! 2160: lp->spy_address[i][5]); ! 2161: #endif /* DEBUG_IOCTL_INFO */ ! 2162: } ! 2163: ! 2164: break; ! 2165: ! 2166: case SIOCGIWSPY: ! 2167: /* Get the spy list and spy stats */ ! 2168: ! 2169: /* Set the number of addresses */ ! 2170: wrq->u.data.length = lp->spy_number; ! 2171: ! 2172: /* If the user want to have the addresses back... */ ! 2173: if((lp->spy_number > 0) && (wrq->u.data.pointer != (caddr_t) 0)) ! 2174: { ! 2175: struct sockaddr address[IW_MAX_SPY]; ! 2176: int i; ! 2177: ! 2178: /* Verify the user buffer */ ! 2179: ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer, ! 2180: (sizeof(iw_qual) + sizeof(struct sockaddr)) ! 2181: * IW_MAX_SPY); ! 2182: if(ret) ! 2183: break; ! 2184: ! 2185: /* Copy addresses from the lp structure */ ! 2186: for(i = 0; i < lp->spy_number; i++) ! 2187: { ! 2188: memcpy(address[i].sa_data, lp->spy_address[i], ! 2189: WAVELAN_ADDR_SIZE); ! 2190: address[i].sa_family = AF_UNIX; ! 2191: } ! 2192: ! 2193: /* Copy addresses to the user buffer */ ! 2194: copy_to_user(wrq->u.data.pointer, address, ! 2195: sizeof(struct sockaddr) * lp->spy_number); ! 2196: ! 2197: /* Copy stats to the user buffer (just after) */ ! 2198: copy_to_user(wrq->u.data.pointer + ! 2199: (sizeof(struct sockaddr) * lp->spy_number), ! 2200: lp->spy_stat, sizeof(iw_qual) * lp->spy_number); ! 2201: ! 2202: /* Reset updated flags */ ! 2203: for(i = 0; i < lp->spy_number; i++) ! 2204: lp->spy_stat[i].updated = 0x0; ! 2205: } /* if(pointer != NULL) */ ! 2206: ! 2207: break; ! 2208: #endif /* WIRELESS_SPY */ ! 2209: ! 2210: /* ------------------ PRIVATE IOCTL ------------------ */ ! 2211: ! 2212: case SIOCSIPQTHR: ! 2213: if(!suser()) ! 2214: return -EPERM; ! 2215: psa.psa_quality_thr = *(wrq->u.name) & 0x0F; ! 2216: psa_write(ioaddr, lp->hacr, (char *)&psa.psa_quality_thr - (char *)&psa, ! 2217: (unsigned char *)&psa.psa_quality_thr, 1); ! 2218: mmc_out(ioaddr, mmwoff(0, mmw_quality_thr), psa.psa_quality_thr); ! 2219: break; ! 2220: ! 2221: case SIOCGIPQTHR: ! 2222: psa_read(ioaddr, lp->hacr, (char *)&psa.psa_quality_thr - (char *)&psa, ! 2223: (unsigned char *)&psa.psa_quality_thr, 1); ! 2224: *(wrq->u.name) = psa.psa_quality_thr & 0x0F; ! 2225: break; ! 2226: ! 2227: #ifdef HISTOGRAM ! 2228: case SIOCSIPHISTO: ! 2229: /* Verif if the user is root */ ! 2230: if(!suser()) ! 2231: return -EPERM; ! 2232: ! 2233: /* Check the number of intervals */ ! 2234: if(wrq->u.data.length > 16) ! 2235: { ! 2236: ret = -E2BIG; ! 2237: break; ! 2238: } ! 2239: lp->his_number = wrq->u.data.length; ! 2240: ! 2241: /* If there is some addresses to copy */ ! 2242: if(lp->his_number > 0) ! 2243: { ! 2244: /* Verify where the user has set his addresses */ ! 2245: ret = verify_area(VERIFY_READ, wrq->u.data.pointer, ! 2246: sizeof(char) * lp->his_number); ! 2247: if(ret) ! 2248: break; ! 2249: /* Copy interval ranges to the driver */ ! 2250: copy_from_user(lp->his_range, wrq->u.data.pointer, ! 2251: sizeof(char) * lp->his_number); ! 2252: ! 2253: /* Reset structure... */ ! 2254: memset(lp->his_sum, 0x00, sizeof(long) * 16); ! 2255: } ! 2256: break; ! 2257: ! 2258: case SIOCGIPHISTO: ! 2259: /* Set the number of intervals */ ! 2260: wrq->u.data.length = lp->his_number; ! 2261: ! 2262: /* Give back the distribution statistics */ ! 2263: if((lp->his_number > 0) && (wrq->u.data.pointer != (caddr_t) 0)) ! 2264: { ! 2265: /* Verify the user buffer */ ! 2266: ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer, ! 2267: sizeof(long) * 16); ! 2268: if(ret) ! 2269: break; ! 2270: ! 2271: /* Copy data to the user buffer */ ! 2272: copy_to_user(wrq->u.data.pointer, lp->his_sum, ! 2273: sizeof(long) * lp->his_number); ! 2274: } /* if(pointer != NULL) */ ! 2275: break; ! 2276: #endif /* HISTOGRAM */ ! 2277: ! 2278: /* ------------------- OTHER IOCTL ------------------- */ ! 2279: ! 2280: default: ! 2281: ret = -EOPNOTSUPP; ! 2282: } ! 2283: ! 2284: /* Enable interrupts, restore flags */ ! 2285: wv_splx(x); ! 2286: ! 2287: #ifdef DEBUG_IOCTL_TRACE ! 2288: printk(KERN_DEBUG "%s: <-wavelan_ioctl()\n", dev->name); ! 2289: #endif ! 2290: return ret; ! 2291: } ! 2292: ! 2293: /*------------------------------------------------------------------*/ ! 2294: /* ! 2295: * Get wireless statistics ! 2296: * Called by /proc/net/wireless ! 2297: */ ! 2298: static iw_stats * ! 2299: wavelan_get_wireless_stats(device * dev) ! 2300: { ! 2301: u_long ioaddr = dev->base_addr; ! 2302: net_local * lp = (net_local *) dev->priv; ! 2303: mmr_t m; ! 2304: iw_stats * wstats; ! 2305: unsigned long x; ! 2306: ! 2307: #ifdef DEBUG_IOCTL_TRACE ! 2308: printk(KERN_DEBUG "%s: ->wavelan_get_wireless_stats()\n", dev->name); ! 2309: #endif ! 2310: ! 2311: /* Disable interrupts & save flags */ ! 2312: x = wv_splhi(); ! 2313: ! 2314: if(lp == (net_local *) NULL) ! 2315: return (iw_stats *) NULL; ! 2316: wstats = &lp->wstats; ! 2317: ! 2318: /* Get data from the mmc */ ! 2319: mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1); ! 2320: ! 2321: mmc_read(ioaddr, mmroff(0, mmr_dce_status), &m.mmr_dce_status, 1); ! 2322: mmc_read(ioaddr, mmroff(0, mmr_wrong_nwid_l), &m.mmr_wrong_nwid_l, 2); ! 2323: mmc_read(ioaddr, mmroff(0, mmr_thr_pre_set), &m.mmr_thr_pre_set, 4); ! 2324: ! 2325: mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0); ! 2326: ! 2327: /* Copy data to wireless stuff */ ! 2328: wstats->status = m.mmr_dce_status; ! 2329: wstats->qual.qual = m.mmr_sgnl_qual & MMR_SGNL_QUAL; ! 2330: wstats->qual.level = m.mmr_signal_lvl & MMR_SIGNAL_LVL; ! 2331: wstats->qual.noise = m.mmr_silence_lvl & MMR_SILENCE_LVL; ! 2332: wstats->qual.updated = (((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 7) | ! 2333: ((m.mmr_signal_lvl & MMR_SIGNAL_LVL_VALID) >> 6) | ! 2334: ((m.mmr_silence_lvl & MMR_SILENCE_LVL_VALID) >> 5)); ! 2335: wstats->discard.nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l; ! 2336: wstats->discard.code = 0L; ! 2337: wstats->discard.misc = 0L; ! 2338: ! 2339: /* Enable interrupts & restore flags */ ! 2340: wv_splx(x); ! 2341: ! 2342: #ifdef DEBUG_IOCTL_TRACE ! 2343: printk(KERN_DEBUG "%s: <-wavelan_get_wireless_stats()\n", dev->name); ! 2344: #endif ! 2345: return &lp->wstats; ! 2346: } ! 2347: #endif /* WIRELESS_EXT */ ! 2348: ! 2349: /************************* PACKET RECEPTION *************************/ ! 2350: /* ! 2351: * This part deals with receiving the packets. ! 2352: * The interrupt handler gets an interrupt when a packet has been ! 2353: * successfully received and calls this part. ! 2354: */ ! 2355: ! 2356: /*------------------------------------------------------------------*/ ! 2357: /* ! 2358: * This routine does the actual copying of data (including the Ethernet ! 2359: * header structure) from the WaveLAN card to an sk_buff chain that ! 2360: * will be passed up to the network interface layer. NOTE: we ! 2361: * currently don't handle trailer protocols (neither does the rest of ! 2362: * the network interface), so if that is needed, it will (at least in ! 2363: * part) be added here. The contents of the receive ring buffer are ! 2364: * copied to a message chain that is then passed to the kernel. ! 2365: * ! 2366: * Note: if any errors occur, the packet is "dropped on the floor" ! 2367: * (called by wv_packet_rcv()) ! 2368: */ ! 2369: static inline void ! 2370: wv_packet_read(device * dev, ! 2371: u_short buf_off, ! 2372: int sksize) ! 2373: { ! 2374: net_local * lp = (net_local *) dev->priv; ! 2375: u_long ioaddr = dev->base_addr; ! 2376: struct sk_buff * skb; ! 2377: ! 2378: #ifdef DEBUG_RX_TRACE ! 2379: printk(KERN_DEBUG "%s: ->wv_packet_read(0x%X, %d)\n", ! 2380: dev->name, fd_p, sksize); ! 2381: #endif ! 2382: ! 2383: /* Allocate buffer for the data */ ! 2384: if((skb = dev_alloc_skb(sksize)) == (struct sk_buff *) NULL) ! 2385: { ! 2386: #ifdef DEBUG_RX_ERROR ! 2387: printk(KERN_INFO "%s: wv_packet_read(): could not alloc_skb(%d, GFP_ATOMIC).\n", ! 2388: dev->name, sksize); ! 2389: #endif ! 2390: lp->stats.rx_dropped++; ! 2391: return; ! 2392: } ! 2393: ! 2394: skb->dev = dev; ! 2395: ! 2396: /* Copy the packet to the buffer */ ! 2397: obram_read(ioaddr, buf_off, skb_put(skb, sksize), sksize); ! 2398: skb->protocol=eth_type_trans(skb, dev); ! 2399: ! 2400: #ifdef DEBUG_RX_INFO ! 2401: wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read"); ! 2402: #endif /* DEBUG_RX_INFO */ ! 2403: ! 2404: /* Statistics gathering & stuff associated. ! 2405: * It seem a bit messy with all the define, but it's really simple... */ ! 2406: #if defined(WIRELESS_SPY) || defined(HISTOGRAM) ! 2407: if( ! 2408: #ifdef WIRELESS_SPY ! 2409: (lp->spy_number > 0) || ! 2410: #endif /* WIRELESS_SPY */ ! 2411: #ifdef HISTOGRAM ! 2412: (lp->his_number > 0) || ! 2413: #endif /* HISTOGRAM */ ! 2414: 0) ! 2415: { ! 2416: u_char stats[3]; /* signal level, noise level, signal quality */ ! 2417: ! 2418: /* read signal level, silence level and signal quality bytes */ ! 2419: /* Note: in the PCMCIA hardware, these are part of the frame. It seems ! 2420: * that for the ISA hardware, it's nowhere to be found in the frame, ! 2421: * so I'm obliged to do this (it has a side effect on /proc/net/wireless). ! 2422: * Any ideas? */ ! 2423: mmc_out(ioaddr, mmwoff(0, mmw_freeze), 1); ! 2424: mmc_read(ioaddr, mmroff(0, mmr_signal_lvl), stats, 3); ! 2425: mmc_out(ioaddr, mmwoff(0, mmw_freeze), 0); ! 2426: ! 2427: #ifdef DEBUG_RX_INFO ! 2428: printk(KERN_DEBUG "%s: wv_packet_read(): Signal level %d/63, Silence level %d/63, signal quality %d/16\n", ! 2429: dev->name, stats[0] & 0x3F, stats[1] & 0x3F, stats[2] & 0x0F); ! 2430: #endif ! 2431: ! 2432: /* Spying stuff */ ! 2433: #ifdef WIRELESS_SPY ! 2434: wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE, stats); ! 2435: #endif /* WIRELESS_SPY */ ! 2436: #ifdef HISTOGRAM ! 2437: wl_his_gather(dev, stats); ! 2438: #endif /* HISTOGRAM */ ! 2439: } ! 2440: #endif /* defined(WIRELESS_SPY) || defined(HISTOGRAM) */ ! 2441: ! 2442: /* ! 2443: * Hand the packet to the Network Module ! 2444: */ ! 2445: netif_rx(skb); ! 2446: ! 2447: lp->stats.rx_packets++; ! 2448: ! 2449: #ifdef DEBUG_RX_TRACE ! 2450: printk(KERN_DEBUG "%s: <-wv_packet_read()\n", dev->name); ! 2451: #endif ! 2452: } ! 2453: ! 2454: /*------------------------------------------------------------------*/ ! 2455: /* ! 2456: * Transfer as many packets as we can ! 2457: * from the device RAM. ! 2458: * Called by the interrupt handler. ! 2459: */ ! 2460: static inline void ! 2461: wv_receive(device * dev) ! 2462: { ! 2463: u_long ioaddr = dev->base_addr; ! 2464: net_local * lp = (net_local *)dev->priv; ! 2465: int nreaped = 0; ! 2466: ! 2467: #ifdef DEBUG_RX_TRACE ! 2468: printk(KERN_DEBUG "%s: ->wv_receive()\n", dev->name); ! 2469: #endif ! 2470: ! 2471: /* Loop on each received packet */ ! 2472: for(;;) ! 2473: { ! 2474: fd_t fd; ! 2475: rbd_t rbd; ! 2476: ushort pkt_len; ! 2477: ! 2478: obram_read(ioaddr, lp->rx_head, (unsigned char *) &fd, sizeof(fd)); ! 2479: ! 2480: /* If the current frame is not complete, we have reach the end... */ ! 2481: if((fd.fd_status & FD_STATUS_C) != FD_STATUS_C) ! 2482: break; /* This is how we exit the loop */ ! 2483: ! 2484: nreaped++; ! 2485: ! 2486: /* Check if frame correctly received */ ! 2487: if((fd.fd_status & (FD_STATUS_B | FD_STATUS_OK)) != ! 2488: (FD_STATUS_B | FD_STATUS_OK)) ! 2489: { ! 2490: /* ! 2491: * Not sure about this one -- it does not seem ! 2492: * to be an error so we will keep quiet about it. ! 2493: */ ! 2494: #ifndef IGNORE_NORMAL_XMIT_ERRS ! 2495: #ifdef DEBUG_RX_ERROR ! 2496: if((fd.fd_status & FD_STATUS_B) != FD_STATUS_B) ! 2497: printk(KERN_INFO "%s: wv_receive(): frame not consumed by RU.\n", ! 2498: dev->name); ! 2499: #endif ! 2500: #endif /* IGNORE_NORMAL_XMIT_ERRS */ ! 2501: ! 2502: #ifdef DEBUG_RX_ERROR ! 2503: if((fd.fd_status & FD_STATUS_OK) != FD_STATUS_OK) ! 2504: printk(KERN_INFO "%s: wv_receive(): frame not received successfully.\n", ! 2505: dev->name); ! 2506: #endif ! 2507: } ! 2508: ! 2509: /* Were there problems in processing the frame? Let's check. */ ! 2510: if((fd.fd_status & (FD_STATUS_S6 | FD_STATUS_S7 | FD_STATUS_S8 | ! 2511: FD_STATUS_S9 | FD_STATUS_S10 | FD_STATUS_S11)) ! 2512: != 0) ! 2513: { ! 2514: lp->stats.rx_errors++; ! 2515: ! 2516: #ifdef DEBUG_RX_ERROR ! 2517: if((fd.fd_status & FD_STATUS_S6) != 0) ! 2518: printk(KERN_INFO "%s: wv_receive(): no EOF flag.\n", dev->name); ! 2519: #endif ! 2520: ! 2521: if((fd.fd_status & FD_STATUS_S7) != 0) ! 2522: { ! 2523: lp->stats.rx_length_errors++; ! 2524: #ifdef DEBUG_RX_ERROR ! 2525: printk(KERN_INFO "%s: wv_receive(): frame too short.\n", ! 2526: dev->name); ! 2527: #endif ! 2528: } ! 2529: ! 2530: if((fd.fd_status & FD_STATUS_S8) != 0) ! 2531: { ! 2532: lp->stats.rx_over_errors++; ! 2533: #ifdef DEBUG_RX_ERROR ! 2534: printk(KERN_INFO "%s: wv_receive(): rx DMA overrun.\n", ! 2535: dev->name); ! 2536: #endif ! 2537: } ! 2538: ! 2539: if((fd.fd_status & FD_STATUS_S9) != 0) ! 2540: { ! 2541: lp->stats.rx_fifo_errors++; ! 2542: #ifdef DEBUG_RX_ERROR ! 2543: printk(KERN_INFO "%s: wv_receive(): ran out of resources.\n", ! 2544: dev->name); ! 2545: #endif ! 2546: } ! 2547: ! 2548: if((fd.fd_status & FD_STATUS_S10) != 0) ! 2549: { ! 2550: lp->stats.rx_frame_errors++; ! 2551: #ifdef DEBUG_RX_ERROR ! 2552: printk(KERN_INFO "%s: wv_receive(): alignment error.\n", ! 2553: dev->name); ! 2554: #endif ! 2555: } ! 2556: ! 2557: if((fd.fd_status & FD_STATUS_S11) != 0) ! 2558: { ! 2559: lp->stats.rx_crc_errors++; ! 2560: #ifdef DEBUG_RX_ERROR ! 2561: printk(KERN_INFO "%s: wv_receive(): CRC error.\n", dev->name); ! 2562: #endif ! 2563: } ! 2564: } ! 2565: ! 2566: /* Does the frame contain a pointer to the data? Let's check. */ ! 2567: if(fd.fd_rbd_offset == I82586NULL) ! 2568: #ifdef DEBUG_RX_ERROR ! 2569: printk(KERN_INFO "%s: wv_receive(): frame has no data.\n", dev->name); ! 2570: #endif ! 2571: else ! 2572: { ! 2573: obram_read(ioaddr, fd.fd_rbd_offset, ! 2574: (unsigned char *) &rbd, sizeof(rbd)); ! 2575: ! 2576: #ifdef DEBUG_RX_ERROR ! 2577: if((rbd.rbd_status & RBD_STATUS_EOF) != RBD_STATUS_EOF) ! 2578: printk(KERN_INFO "%s: wv_receive(): missing EOF flag.\n", ! 2579: dev->name); ! 2580: ! 2581: if((rbd.rbd_status & RBD_STATUS_F) != RBD_STATUS_F) ! 2582: printk(KERN_INFO "%s: wv_receive(): missing F flag.\n", ! 2583: dev->name); ! 2584: #endif ! 2585: ! 2586: pkt_len = rbd.rbd_status & RBD_STATUS_ACNT; ! 2587: ! 2588: /* Read the packet and transmit to Linux */ ! 2589: wv_packet_read(dev, rbd.rbd_bufl, pkt_len); ! 2590: } /* if frame has data */ ! 2591: ! 2592: fd.fd_status = 0; ! 2593: obram_write(ioaddr, fdoff(lp->rx_head, fd_status), ! 2594: (unsigned char *) &fd.fd_status, sizeof(fd.fd_status)); ! 2595: ! 2596: fd.fd_command = FD_COMMAND_EL; ! 2597: obram_write(ioaddr, fdoff(lp->rx_head, fd_command), ! 2598: (unsigned char *) &fd.fd_command, sizeof(fd.fd_command)); ! 2599: ! 2600: fd.fd_command = 0; ! 2601: obram_write(ioaddr, fdoff(lp->rx_last, fd_command), ! 2602: (unsigned char *) &fd.fd_command, sizeof(fd.fd_command)); ! 2603: ! 2604: lp->rx_last = lp->rx_head; ! 2605: lp->rx_head = fd.fd_link_offset; ! 2606: } /* for(;;) -> loop on all frames */ ! 2607: ! 2608: #ifdef DEBUG_RX_INFO ! 2609: if(nreaped > 1) ! 2610: printk(KERN_DEBUG "%s: wv_receive(): reaped %d\n", dev->name, nreaped); ! 2611: #endif ! 2612: #ifdef DEBUG_RX_TRACE ! 2613: printk(KERN_DEBUG "%s: <-wv_receive()\n", dev->name); ! 2614: #endif ! 2615: } ! 2616: ! 2617: /*********************** PACKET TRANSMISSION ***********************/ ! 2618: /* ! 2619: * This part deals with sending packet through the WaveLAN ! 2620: * ! 2621: */ ! 2622: ! 2623: /*------------------------------------------------------------------*/ ! 2624: /* ! 2625: * This routine fills in the appropriate registers and memory ! 2626: * locations on the WaveLAN card and starts the card off on ! 2627: * the transmit. ! 2628: * ! 2629: * The principle : ! 2630: * Each block contain a transmit command, a nop command, ! 2631: * a transmit block descriptor and a buffer. ! 2632: * The CU read the transmit block which point to the tbd, ! 2633: * read the tbd and the content of the buffer. ! 2634: * When it has finished with it, it goes to the next command ! 2635: * which in our case is the nop. The nop point on itself, ! 2636: * so the CU stop here. ! 2637: * When we add the next block, we modify the previous nop ! 2638: * to make it point on the new tx command. ! 2639: * Simple, isn't it ? ! 2640: * ! 2641: * (called in wavelan_packet_xmit()) ! 2642: */ ! 2643: static inline void ! 2644: wv_packet_write(device * dev, ! 2645: void * buf, ! 2646: short length) ! 2647: { ! 2648: net_local * lp = (net_local *) dev->priv; ! 2649: u_long ioaddr = dev->base_addr; ! 2650: unsigned short txblock; ! 2651: unsigned short txpred; ! 2652: unsigned short tx_addr; ! 2653: unsigned short nop_addr; ! 2654: unsigned short tbd_addr; ! 2655: unsigned short buf_addr; ! 2656: ac_tx_t tx; ! 2657: ac_nop_t nop; ! 2658: tbd_t tbd; ! 2659: int clen = length; ! 2660: unsigned long x; ! 2661: ! 2662: #ifdef DEBUG_TX_TRACE ! 2663: printk(KERN_DEBUG "%s: ->wv_packet_write(%d)\n", dev->name, length); ! 2664: #endif ! 2665: ! 2666: /* Check if we need some padding */ ! 2667: if(clen < ETH_ZLEN) ! 2668: clen = ETH_ZLEN; ! 2669: ! 2670: x = wv_splhi(); ! 2671: ! 2672: /* Calculate addresses of next block and previous block */ ! 2673: txblock = lp->tx_first_free; ! 2674: txpred = txblock - TXBLOCKZ; ! 2675: if(txpred < OFFSET_CU) ! 2676: txpred += NTXBLOCKS * TXBLOCKZ; ! 2677: lp->tx_first_free += TXBLOCKZ; ! 2678: if(lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ) ! 2679: lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ; ! 2680: ! 2681: /* ! 2682: if (lp->tx_n_in_use > 0) ! 2683: printk("%c", "0123456789abcdefghijk"[lp->tx_n_in_use]); ! 2684: */ ! 2685: ! 2686: lp->tx_n_in_use++; ! 2687: ! 2688: /* Calculate addresses of the differents part of the block */ ! 2689: tx_addr = txblock; ! 2690: nop_addr = tx_addr + sizeof(tx); ! 2691: tbd_addr = nop_addr + sizeof(nop); ! 2692: buf_addr = tbd_addr + sizeof(tbd); ! 2693: ! 2694: /* ! 2695: * Transmit command. ! 2696: */ ! 2697: tx.tx_h.ac_status = 0; ! 2698: obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status), ! 2699: (unsigned char *) &tx.tx_h.ac_status, ! 2700: sizeof(tx.tx_h.ac_status)); ! 2701: ! 2702: /* ! 2703: * NOP command. ! 2704: */ ! 2705: nop.nop_h.ac_status = 0; ! 2706: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status), ! 2707: (unsigned char *) &nop.nop_h.ac_status, ! 2708: sizeof(nop.nop_h.ac_status)); ! 2709: nop.nop_h.ac_link = nop_addr; ! 2710: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link), ! 2711: (unsigned char *) &nop.nop_h.ac_link, ! 2712: sizeof(nop.nop_h.ac_link)); ! 2713: ! 2714: /* ! 2715: * Transmit buffer descriptor ! 2716: */ ! 2717: tbd.tbd_status = TBD_STATUS_EOF | (TBD_STATUS_ACNT & clen); ! 2718: tbd.tbd_next_bd_offset = I82586NULL; ! 2719: tbd.tbd_bufl = buf_addr; ! 2720: tbd.tbd_bufh = 0; ! 2721: obram_write(ioaddr, tbd_addr, (unsigned char *)&tbd, sizeof(tbd)); ! 2722: ! 2723: /* ! 2724: * Data ! 2725: */ ! 2726: obram_write(ioaddr, buf_addr, buf, clen); ! 2727: ! 2728: /* ! 2729: * Overwrite the predecessor NOP link ! 2730: * so that it points to this txblock. ! 2731: */ ! 2732: nop_addr = txpred + sizeof(tx); ! 2733: nop.nop_h.ac_status = 0; ! 2734: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status), ! 2735: (unsigned char *)&nop.nop_h.ac_status, ! 2736: sizeof(nop.nop_h.ac_status)); ! 2737: nop.nop_h.ac_link = txblock; ! 2738: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link), ! 2739: (unsigned char *) &nop.nop_h.ac_link, ! 2740: sizeof(nop.nop_h.ac_link)); ! 2741: ! 2742: /* If watchdog not already active, activate it... */ ! 2743: if(lp->watchdog.prev == (timer_list *) NULL) ! 2744: { ! 2745: /* set timer to expire in WATCHDOG_JIFFIES */ ! 2746: lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES; ! 2747: add_timer(&lp->watchdog); ! 2748: } ! 2749: ! 2750: if(lp->tx_first_in_use == I82586NULL) ! 2751: lp->tx_first_in_use = txblock; ! 2752: ! 2753: if(lp->tx_n_in_use < NTXBLOCKS - 1) ! 2754: dev->tbusy = 0; ! 2755: ! 2756: wv_splx(x); ! 2757: ! 2758: #ifdef DEBUG_TX_INFO ! 2759: wv_packet_info((u_char *) buf, length, dev->name, "wv_packet_write"); ! 2760: #endif /* DEBUG_TX_INFO */ ! 2761: ! 2762: #ifdef DEBUG_TX_TRACE ! 2763: printk(KERN_DEBUG "%s: <-wv_packet_write()\n", dev->name); ! 2764: #endif ! 2765: } ! 2766: ! 2767: /*------------------------------------------------------------------*/ ! 2768: /* ! 2769: * This routine is called when we want to send a packet (NET3 callback) ! 2770: * In this routine, we check if the hardware is ready to accept ! 2771: * the packet. We also prevent reentrance. Then, we call the function ! 2772: * to send the packet... ! 2773: */ ! 2774: static int ! 2775: wavelan_packet_xmit(struct sk_buff * skb, ! 2776: device * dev) ! 2777: { ! 2778: net_local * lp = (net_local *)dev->priv; ! 2779: ! 2780: #ifdef DEBUG_TX_TRACE ! 2781: printk(KERN_DEBUG "%s: ->wavelan_packet_xmit(0x%X)\n", dev->name, ! 2782: (unsigned) skb); ! 2783: #endif ! 2784: ! 2785: /* This flag indicate that the hardware can't perform a transmission. ! 2786: * Theoretically, NET3 checks it before sending a packet to the driver, ! 2787: * but in fact it never does that and pool continuously. ! 2788: * As the watchdog will abort overly long transmissions, we are quite safe. ! 2789: */ ! 2790: if(dev->tbusy) ! 2791: return 1; ! 2792: ! 2793: /* ! 2794: * If some higher layer thinks we've missed ! 2795: * a tx-done interrupt we are passed NULL. ! 2796: * Caution: dev_tint() handles the cli()/sti() itself. ! 2797: */ ! 2798: if(skb == (struct sk_buff *)0) ! 2799: { ! 2800: #ifdef DEBUG_TX_ERROR ! 2801: printk(KERN_INFO "%s: wavelan_packet_xmit(): skb == NULL\n", dev->name); ! 2802: #endif ! 2803: dev_tint(dev); ! 2804: return 0; ! 2805: } ! 2806: ! 2807: /* ! 2808: * Block a timer-based transmit from overlapping. ! 2809: * In other words, prevent reentering this routine. ! 2810: */ ! 2811: if(set_bit(0, (void *)&dev->tbusy) != 0) ! 2812: #ifdef DEBUG_TX_ERROR ! 2813: printk(KERN_INFO "%s: Transmitter access conflict.\n", dev->name); ! 2814: #endif ! 2815: else ! 2816: { ! 2817: /* If somebody has asked to reconfigure the controller, ! 2818: * we can do it now. ! 2819: */ ! 2820: if(lp->reconfig_82586) ! 2821: { ! 2822: wv_82586_config(dev); ! 2823: if(dev->tbusy) ! 2824: return 1; ! 2825: } ! 2826: ! 2827: #ifdef DEBUG_TX_ERROR ! 2828: if(skb->next) ! 2829: printk(KERN_INFO "skb has next\n"); ! 2830: #endif ! 2831: ! 2832: wv_packet_write(dev, skb->data, skb->len); ! 2833: } ! 2834: ! 2835: dev_kfree_skb(skb, FREE_WRITE); ! 2836: ! 2837: #ifdef DEBUG_TX_TRACE ! 2838: printk(KERN_DEBUG "%s: <-wavelan_packet_xmit()\n", dev->name); ! 2839: #endif ! 2840: return 0; ! 2841: } ! 2842: ! 2843: /*********************** HARDWARE CONFIGURATION ***********************/ ! 2844: /* ! 2845: * This part does the real job of starting and configuring the hardware. ! 2846: */ ! 2847: ! 2848: /*--------------------------------------------------------------------*/ ! 2849: /* ! 2850: * Routine to initialize the Modem Management Controller. ! 2851: * (called by wv_hw_reset()) ! 2852: */ ! 2853: static inline int ! 2854: wv_mmc_init(device * dev) ! 2855: { ! 2856: u_long ioaddr = dev->base_addr; ! 2857: net_local * lp = (net_local *)dev->priv; ! 2858: psa_t psa; ! 2859: mmw_t m; ! 2860: int configured; ! 2861: ! 2862: #ifdef DEBUG_CONFIG_TRACE ! 2863: printk(KERN_DEBUG "%s: ->wv_mmc_init()\n", dev->name); ! 2864: #endif ! 2865: ! 2866: /* Read the parameter storage area */ ! 2867: psa_read(ioaddr, lp->hacr, 0, (unsigned char *) &psa, sizeof(psa)); ! 2868: ! 2869: #ifdef USE_PSA_CONFIG ! 2870: configured = psa.psa_conf_status & 1; ! 2871: #else ! 2872: configured = 0; ! 2873: #endif ! 2874: ! 2875: /* Is the PSA is not configured */ ! 2876: if(!configured) ! 2877: { ! 2878: /* User will be able to configure NWID after (with iwconfig) */ ! 2879: psa.psa_nwid[0] = 0; ! 2880: psa.psa_nwid[1] = 0; ! 2881: ! 2882: /* no NWID checking since NWID is not set */ ! 2883: psa.psa_nwid_select = 0; ! 2884: ! 2885: /* Disable encryption */ ! 2886: psa.psa_encryption_select = 0; ! 2887: ! 2888: /* Set to standard values ! 2889: * 0x04 for AT, ! 2890: * 0x01 for MCA, ! 2891: * 0x04 for PCMCIA and 2.00 card (AT&T 407-024689/E document) ! 2892: */ ! 2893: if (psa.psa_comp_number & 1) ! 2894: psa.psa_thr_pre_set = 0x01; ! 2895: else ! 2896: psa.psa_thr_pre_set = 0x04; ! 2897: psa.psa_quality_thr = 0x03; ! 2898: ! 2899: /* It is configured */ ! 2900: psa.psa_conf_status |= 1; ! 2901: ! 2902: #ifdef USE_PSA_CONFIG ! 2903: /* Write the psa */ ! 2904: psa_write(ioaddr, lp->hacr, (char *)psa.psa_nwid - (char *)&psa, ! 2905: (unsigned char *)psa.psa_nwid, 4); ! 2906: psa_write(ioaddr, lp->hacr, (char *)&psa.psa_thr_pre_set - (char *)&psa, ! 2907: (unsigned char *)&psa.psa_thr_pre_set, 1); ! 2908: psa_write(ioaddr, lp->hacr, (char *)&psa.psa_quality_thr - (char *)&psa, ! 2909: (unsigned char *)&psa.psa_quality_thr, 1); ! 2910: psa_write(ioaddr, lp->hacr, (char *)&psa.psa_conf_status - (char *)&psa, ! 2911: (unsigned char *)&psa.psa_conf_status, 1); ! 2912: #endif ! 2913: } ! 2914: ! 2915: /* Zero the mmc structure */ ! 2916: memset(&m, 0x00, sizeof(m)); ! 2917: ! 2918: /* Copy PSA info to the mmc */ ! 2919: m.mmw_netw_id_l = psa.psa_nwid[1]; ! 2920: m.mmw_netw_id_h = psa.psa_nwid[0]; ! 2921: ! 2922: if(psa.psa_nwid_select & 1) ! 2923: m.mmw_loopt_sel = 0x00; ! 2924: else ! 2925: m.mmw_loopt_sel = MMW_LOOPT_SEL_DIS_NWID; ! 2926: ! 2927: memcpy(&m.mmw_encr_key, &psa.psa_encryption_key, ! 2928: sizeof(m.mmw_encr_key)); ! 2929: ! 2930: if(psa.psa_encryption_select) ! 2931: m.mmw_encr_enable = MMW_ENCR_ENABLE_EN | MMW_ENCR_ENABLE_MODE; ! 2932: else ! 2933: m.mmw_encr_enable = 0; ! 2934: ! 2935: m.mmw_thr_pre_set = psa.psa_thr_pre_set & 0x3F; ! 2936: m.mmw_quality_thr = psa.psa_quality_thr & 0x0F; ! 2937: ! 2938: /* Missing: encryption stuff... */ ! 2939: ! 2940: /* ! 2941: * Set default modem control parameters. ! 2942: * See NCR document 407-0024326 Rev. A. ! 2943: */ ! 2944: m.mmw_jabber_enable = 0x01; ! 2945: m.mmw_anten_sel = MMW_ANTEN_SEL_ALG_EN; ! 2946: m.mmw_ifs = 0x20; ! 2947: m.mmw_mod_delay = 0x04; ! 2948: m.mmw_jam_time = 0x38; ! 2949: ! 2950: m.mmw_encr_enable = 0; ! 2951: m.mmw_des_io_invert = 0; ! 2952: m.mmw_freeze = 0; ! 2953: m.mmw_decay_prm = 0; ! 2954: m.mmw_decay_updat_prm = 0; ! 2955: ! 2956: /* Write all info to MMC */ ! 2957: mmc_write(ioaddr, 0, (u_char *)&m, sizeof(m)); ! 2958: ! 2959: /* The following code starts the modem of the 2.00 frequency ! 2960: * selectable cards at power on. It's not strictly needed for the ! 2961: * following boots. ! 2962: * The original patch was by Joe Finney for the PCMCIA driver, but ! 2963: * I've cleaned it up a bit and added documentation. ! 2964: * Thanks to Loeke Brederveld from Lucent for the info. ! 2965: */ ! 2966: ! 2967: /* Attempt to recognise 2.00 cards (2.4 GHz frequency selectable) ! 2968: * (does it work for everybody? -- especially old cards?) */ ! 2969: /* Note: WFREQSEL verifies that it is able to read a sensible ! 2970: * frequency from EEPROM (address 0x00) and that MMR_FEE_STATUS_ID ! 2971: * is 0xA (Xilinx version) or 0xB (Ariadne version). ! 2972: * My test is more crude but does work. */ ! 2973: if(!(mmc_in(ioaddr, mmroff(0, mmr_fee_status)) & ! 2974: (MMR_FEE_STATUS_DWLD | MMR_FEE_STATUS_BUSY))) ! 2975: { ! 2976: /* We must download the frequency parameters to the ! 2977: * synthesizers (from the EEPROM - area 1) ! 2978: * Note : as the EEPROM is auto decremented, we set the end ! 2979: * if the area... */ ! 2980: m.mmw_fee_addr = 0x0F; ! 2981: m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD; ! 2982: mmc_write(ioaddr, (char *)&m.mmw_fee_ctrl - (char *)&m, ! 2983: (unsigned char *)&m.mmw_fee_ctrl, 2); ! 2984: ! 2985: /* Wait until the download is finished */ ! 2986: fee_wait(ioaddr, 100, 100); ! 2987: ! 2988: #ifdef DEBUG_CONFIG_INFO ! 2989: /* The frequency was in the last word downloaded. */ ! 2990: mmc_read(ioaddr, (char *)&m.mmw_fee_data_l - (char *)&m, ! 2991: (unsigned char *)&m.mmw_fee_data_l, 2); ! 2992: ! 2993: /* Print some info for the user. */ ! 2994: printk(KERN_DEBUG "%s: WaveLAN 2.00 recognised (frequency select) : Current frequency = %ld\n", ! 2995: dev->name, ! 2996: ((m.mmw_fee_data_h << 4) | ! 2997: (m.mmw_fee_data_l >> 4)) * 5 / 2 + 24000L); ! 2998: #endif ! 2999: ! 3000: /* We must now download the power adjust value (gain) to ! 3001: * the synthesizers (from the EEPROM - area 7 - DAC) */ ! 3002: m.mmw_fee_addr = 0x61; ! 3003: m.mmw_fee_ctrl = MMW_FEE_CTRL_READ | MMW_FEE_CTRL_DWLD; ! 3004: mmc_write(ioaddr, (char *)&m.mmw_fee_ctrl - (char *)&m, ! 3005: (unsigned char *)&m.mmw_fee_ctrl, 2); ! 3006: ! 3007: /* Wait until the download is finished */ ! 3008: } /* if 2.00 card */ ! 3009: ! 3010: #ifdef DEBUG_CONFIG_TRACE ! 3011: printk(KERN_DEBUG "%s: <-wv_mmc_init()\n", dev->name); ! 3012: #endif ! 3013: return 0; ! 3014: } ! 3015: ! 3016: /*------------------------------------------------------------------*/ ! 3017: /* ! 3018: * Construct the fd and rbd structures. ! 3019: * Start the receive unit. ! 3020: * (called by wv_hw_reset()) ! 3021: */ ! 3022: static inline int ! 3023: wv_ru_start(device * dev) ! 3024: { ! 3025: net_local * lp = (net_local *) dev->priv; ! 3026: u_long ioaddr = dev->base_addr; ! 3027: u_short scb_cs; ! 3028: fd_t fd; ! 3029: rbd_t rbd; ! 3030: u_short rx; ! 3031: u_short rx_next; ! 3032: int i; ! 3033: ! 3034: #ifdef DEBUG_CONFIG_TRACE ! 3035: printk(KERN_DEBUG "%s: ->wv_ru_start()\n", dev->name); ! 3036: #endif ! 3037: ! 3038: obram_read(ioaddr, scboff(OFFSET_SCB, scb_status), (unsigned char *)&scb_cs, sizeof(scb_cs)); ! 3039: if((scb_cs & SCB_ST_RUS) == SCB_ST_RUS_RDY) ! 3040: return 0; ! 3041: ! 3042: lp->rx_head = OFFSET_RU; ! 3043: ! 3044: for(i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next) ! 3045: { ! 3046: rx_next = (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ; ! 3047: ! 3048: fd.fd_status = 0; ! 3049: fd.fd_command = (i == NRXBLOCKS - 1) ? FD_COMMAND_EL : 0; ! 3050: fd.fd_link_offset = rx_next; ! 3051: fd.fd_rbd_offset = rx + sizeof(fd); ! 3052: obram_write(ioaddr, rx, (unsigned char *)&fd, sizeof(fd)); ! 3053: ! 3054: rbd.rbd_status = 0; ! 3055: rbd.rbd_next_rbd_offset = I82586NULL; ! 3056: rbd.rbd_bufl = rx + sizeof(fd) + sizeof(rbd); ! 3057: rbd.rbd_bufh = 0; ! 3058: rbd.rbd_el_size = RBD_EL | (RBD_SIZE & MAXDATAZ); ! 3059: obram_write(ioaddr, rx + sizeof(fd), ! 3060: (unsigned char *) &rbd, sizeof(rbd)); ! 3061: ! 3062: lp->rx_last = rx; ! 3063: } ! 3064: ! 3065: obram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset), ! 3066: (unsigned char *) &lp->rx_head, sizeof(lp->rx_head)); ! 3067: ! 3068: scb_cs = SCB_CMD_RUC_GO; ! 3069: obram_write(ioaddr, scboff(OFFSET_SCB, scb_command), ! 3070: (unsigned char *) &scb_cs, sizeof(scb_cs)); ! 3071: ! 3072: set_chan_attn(ioaddr, lp->hacr); ! 3073: ! 3074: for(i = 1000; i > 0; i--) ! 3075: { ! 3076: obram_read(ioaddr, scboff(OFFSET_SCB, scb_command), ! 3077: (unsigned char *) &scb_cs, sizeof(scb_cs)); ! 3078: if (scb_cs == 0) ! 3079: break; ! 3080: ! 3081: udelay(10); ! 3082: } ! 3083: ! 3084: if(i <= 0) ! 3085: { ! 3086: #ifdef DEBUG_CONFIG_ERRORS ! 3087: printk(KERN_INFO "%s: wavelan_ru_start(): board not accepting command.\n", ! 3088: dev->name); ! 3089: #endif ! 3090: return -1; ! 3091: } ! 3092: ! 3093: #ifdef DEBUG_CONFIG_TRACE ! 3094: printk(KERN_DEBUG "%s: <-wv_ru_start()\n", dev->name); ! 3095: #endif ! 3096: return 0; ! 3097: } ! 3098: ! 3099: /*------------------------------------------------------------------*/ ! 3100: /* ! 3101: * Initialise the transmit blocks. ! 3102: * Start the command unit executing the NOP ! 3103: * self-loop of the first transmit block. ! 3104: * ! 3105: * Here, we create the list of send buffers used to transmit packets ! 3106: * between the PC and the command unit. For each buffer, we create a ! 3107: * buffer descriptor (pointing on the buffer), a transmit command ! 3108: * (pointing to the buffer descriptor) and a NOP command. ! 3109: * The transmit command is linked to the NOP, and the NOP to itself. ! 3110: * When we will have finished executing the transmit command, we will ! 3111: * then loop on the NOP. By releasing the NOP link to a new command, ! 3112: * we may send another buffer. ! 3113: * ! 3114: * (called by wv_hw_reset()) ! 3115: */ ! 3116: static inline int ! 3117: wv_cu_start(device * dev) ! 3118: { ! 3119: net_local * lp = (net_local *) dev->priv; ! 3120: u_long ioaddr = dev->base_addr; ! 3121: int i; ! 3122: u_short txblock; ! 3123: u_short first_nop; ! 3124: u_short scb_cs; ! 3125: ! 3126: #ifdef DEBUG_CONFIG_TRACE ! 3127: printk(KERN_DEBUG "%s: ->wv_cu_start()\n", dev->name); ! 3128: #endif ! 3129: ! 3130: lp->tx_first_free = OFFSET_CU; ! 3131: lp->tx_first_in_use = I82586NULL; ! 3132: ! 3133: for(i = 0, txblock = OFFSET_CU; ! 3134: i < NTXBLOCKS; ! 3135: i++, txblock += TXBLOCKZ) ! 3136: { ! 3137: ac_tx_t tx; ! 3138: ac_nop_t nop; ! 3139: tbd_t tbd; ! 3140: unsigned short tx_addr; ! 3141: unsigned short nop_addr; ! 3142: unsigned short tbd_addr; ! 3143: unsigned short buf_addr; ! 3144: ! 3145: tx_addr = txblock; ! 3146: nop_addr = tx_addr + sizeof(tx); ! 3147: tbd_addr = nop_addr + sizeof(nop); ! 3148: buf_addr = tbd_addr + sizeof(tbd); ! 3149: ! 3150: tx.tx_h.ac_status = 0; ! 3151: tx.tx_h.ac_command = acmd_transmit | AC_CFLD_I; ! 3152: tx.tx_h.ac_link = nop_addr; ! 3153: tx.tx_tbd_offset = tbd_addr; ! 3154: obram_write(ioaddr, tx_addr, (unsigned char *) &tx, sizeof(tx)); ! 3155: ! 3156: nop.nop_h.ac_status = 0; ! 3157: nop.nop_h.ac_command = acmd_nop; ! 3158: nop.nop_h.ac_link = nop_addr; ! 3159: obram_write(ioaddr, nop_addr, (unsigned char *) &nop, sizeof(nop)); ! 3160: ! 3161: tbd.tbd_status = TBD_STATUS_EOF; ! 3162: tbd.tbd_next_bd_offset = I82586NULL; ! 3163: tbd.tbd_bufl = buf_addr; ! 3164: tbd.tbd_bufh = 0; ! 3165: obram_write(ioaddr, tbd_addr, (unsigned char *) &tbd, sizeof(tbd)); ! 3166: } ! 3167: ! 3168: first_nop = OFFSET_CU + (NTXBLOCKS - 1) * TXBLOCKZ + sizeof(ac_tx_t); ! 3169: obram_write(ioaddr, scboff(OFFSET_SCB, scb_cbl_offset), ! 3170: (unsigned char *) &first_nop, sizeof(first_nop)); ! 3171: ! 3172: scb_cs = SCB_CMD_CUC_GO; ! 3173: obram_write(ioaddr, scboff(OFFSET_SCB, scb_command), ! 3174: (unsigned char *) &scb_cs, sizeof(scb_cs)); ! 3175: ! 3176: set_chan_attn(ioaddr, lp->hacr); ! 3177: ! 3178: for(i = 1000; i > 0; i--) ! 3179: { ! 3180: obram_read(ioaddr, scboff(OFFSET_SCB, scb_command), ! 3181: (unsigned char *) &scb_cs, sizeof(scb_cs)); ! 3182: if (scb_cs == 0) ! 3183: break; ! 3184: ! 3185: udelay(10); ! 3186: } ! 3187: ! 3188: if(i <= 0) ! 3189: { ! 3190: #ifdef DEBUG_CONFIG_ERRORS ! 3191: printk(KERN_INFO "%s: wavelan_cu_start(): board not accepting command.\n", ! 3192: dev->name); ! 3193: #endif ! 3194: return -1; ! 3195: } ! 3196: ! 3197: lp->tx_n_in_use = 0; ! 3198: dev->tbusy = 0; ! 3199: ! 3200: #ifdef DEBUG_CONFIG_TRACE ! 3201: printk(KERN_DEBUG "%s: <-wv_cu_start()\n", dev->name); ! 3202: #endif ! 3203: return 0; ! 3204: } ! 3205: ! 3206: /*------------------------------------------------------------------*/ ! 3207: /* ! 3208: * This routine does a standard config of the WaveLAN controler (i82586). ! 3209: * ! 3210: * It initialises the scp, iscp and scb structure ! 3211: * The first two are just pointers to the next. ! 3212: * The last one is used for basic configuration and for basic ! 3213: * communication (interrupt status). ! 3214: * ! 3215: * (called by wv_hw_reset()) ! 3216: */ ! 3217: static inline int ! 3218: wv_82586_start(device * dev) ! 3219: { ! 3220: net_local * lp = (net_local *) dev->priv; ! 3221: u_long ioaddr = dev->base_addr; ! 3222: scp_t scp; /* system configuration pointer */ ! 3223: iscp_t iscp; /* intermediate scp */ ! 3224: scb_t scb; /* system control block */ ! 3225: ach_t cb; /* Action command header */ ! 3226: u_char zeroes[512]; ! 3227: int i; ! 3228: ! 3229: #ifdef DEBUG_CONFIG_TRACE ! 3230: printk(KERN_DEBUG "%s: ->wv_82586_start()\n", dev->name); ! 3231: #endif ! 3232: ! 3233: /* ! 3234: * Clear the onboard RAM. ! 3235: */ ! 3236: memset(&zeroes[0], 0x00, sizeof(zeroes)); ! 3237: for(i = 0; i < I82586_MEMZ; i += sizeof(zeroes)) ! 3238: obram_write(ioaddr, i, &zeroes[0], sizeof(zeroes)); ! 3239: ! 3240: /* ! 3241: * Construct the command unit structures: ! 3242: * scp, iscp, scb, cb. ! 3243: */ ! 3244: memset(&scp, 0x00, sizeof(scp)); ! 3245: scp.scp_sysbus = SCP_SY_16BBUS; ! 3246: scp.scp_iscpl = OFFSET_ISCP; ! 3247: obram_write(ioaddr, OFFSET_SCP, (unsigned char *)&scp, sizeof(scp)); ! 3248: ! 3249: memset(&iscp, 0x00, sizeof(iscp)); ! 3250: iscp.iscp_busy = 1; ! 3251: iscp.iscp_offset = OFFSET_SCB; ! 3252: obram_write(ioaddr, OFFSET_ISCP, (unsigned char *)&iscp, sizeof(iscp)); ! 3253: ! 3254: /* Our first command is to reset the i82586. */ ! 3255: memset(&scb, 0x00, sizeof(scb)); ! 3256: scb.scb_command = SCB_CMD_RESET; ! 3257: scb.scb_cbl_offset = OFFSET_CU; ! 3258: scb.scb_rfa_offset = OFFSET_RU; ! 3259: obram_write(ioaddr, OFFSET_SCB, (unsigned char *)&scb, sizeof(scb)); ! 3260: ! 3261: set_chan_attn(ioaddr, lp->hacr); ! 3262: ! 3263: /* Wait for command to finish. */ ! 3264: for(i = 1000; i > 0; i--) ! 3265: { ! 3266: obram_read(ioaddr, OFFSET_ISCP, (unsigned char *) &iscp, sizeof(iscp)); ! 3267: ! 3268: if(iscp.iscp_busy == (unsigned short) 0) ! 3269: break; ! 3270: ! 3271: udelay(10); ! 3272: } ! 3273: ! 3274: if(i <= 0) ! 3275: { ! 3276: #ifdef DEBUG_CONFIG_ERRORS ! 3277: printk(KERN_INFO "%s: wv_82586_start(): iscp_busy timeout.\n", ! 3278: dev->name); ! 3279: #endif ! 3280: return -1; ! 3281: } ! 3282: ! 3283: /* Check command completion */ ! 3284: for(i = 15; i > 0; i--) ! 3285: { ! 3286: obram_read(ioaddr, OFFSET_SCB, (unsigned char *) &scb, sizeof(scb)); ! 3287: ! 3288: if (scb.scb_status == (SCB_ST_CX | SCB_ST_CNA)) ! 3289: break; ! 3290: ! 3291: udelay(10); ! 3292: } ! 3293: ! 3294: if (i <= 0) ! 3295: { ! 3296: #ifdef DEBUG_CONFIG_ERRORS ! 3297: printk(KERN_INFO "%s: wv_82586_start(): status: expected 0x%02x, got 0x%02x.\n", ! 3298: dev->name, SCB_ST_CX | SCB_ST_CNA, scb.scb_status); ! 3299: #endif ! 3300: return -1; ! 3301: } ! 3302: ! 3303: wv_ack(dev); ! 3304: ! 3305: /* Set the action command header. */ ! 3306: memset(&cb, 0x00, sizeof(cb)); ! 3307: cb.ac_command = AC_CFLD_EL | (AC_CFLD_CMD & acmd_diagnose); ! 3308: cb.ac_link = OFFSET_CU; ! 3309: obram_write(ioaddr, OFFSET_CU, (unsigned char *)&cb, sizeof(cb)); ! 3310: ! 3311: if(wv_synchronous_cmd(dev, "diag()") == -1) ! 3312: return -1; ! 3313: ! 3314: obram_read(ioaddr, OFFSET_CU, (unsigned char *)&cb, sizeof(cb)); ! 3315: if(cb.ac_status & AC_SFLD_FAIL) ! 3316: { ! 3317: #ifdef DEBUG_CONFIG_ERRORS ! 3318: printk(KERN_INFO "%s: wv_82586_start(): i82586 Self Test failed.\n", ! 3319: dev->name); ! 3320: #endif ! 3321: return -1; ! 3322: } ! 3323: ! 3324: #ifdef DEBUG_I82586_SHOW ! 3325: wv_scb_show(ioaddr); ! 3326: #endif ! 3327: ! 3328: #ifdef DEBUG_CONFIG_TRACE ! 3329: printk(KERN_DEBUG "%s: <-wv_82586_start()\n", dev->name); ! 3330: #endif ! 3331: return 0; ! 3332: } ! 3333: ! 3334: /*------------------------------------------------------------------*/ ! 3335: /* ! 3336: * This routine does a standard configuration of the WaveLAN controller ! 3337: * (i82586). ! 3338: * ! 3339: * This routine is a violent hack. We use the first free transmit block ! 3340: * to make our configuration. In the buffer area, we create the three ! 3341: * configuration commands (linked). We make the previous NOP point to ! 3342: * the beginning of the buffer instead of the tx command. After, we go ! 3343: * as usual to the NOP command. ! 3344: * Note that only the last command (mc_set) will generate an interrupt. ! 3345: * ! 3346: * (called by wv_hw_reset(), wv_82586_reconfig()) ! 3347: */ ! 3348: static void ! 3349: wv_82586_config(device * dev) ! 3350: { ! 3351: net_local * lp = (net_local *) dev->priv; ! 3352: u_long ioaddr = dev->base_addr; ! 3353: unsigned short txblock; ! 3354: unsigned short txpred; ! 3355: unsigned short tx_addr; ! 3356: unsigned short nop_addr; ! 3357: unsigned short tbd_addr; ! 3358: unsigned short cfg_addr; ! 3359: unsigned short ias_addr; ! 3360: unsigned short mcs_addr; ! 3361: ac_tx_t tx; ! 3362: ac_nop_t nop; ! 3363: ac_cfg_t cfg; /* Configure action */ ! 3364: ac_ias_t ias; /* IA-setup action */ ! 3365: ac_mcs_t mcs; /* Multicast setup */ ! 3366: struct dev_mc_list * dmi; ! 3367: unsigned long x; ! 3368: ! 3369: #ifdef DEBUG_CONFIG_TRACE ! 3370: printk(KERN_DEBUG "%s: ->wv_82586_config()\n", dev->name); ! 3371: #endif ! 3372: ! 3373: x = wv_splhi(); ! 3374: ! 3375: /* Calculate addresses of next block and previous block */ ! 3376: txblock = lp->tx_first_free; ! 3377: txpred = txblock - TXBLOCKZ; ! 3378: if(txpred < OFFSET_CU) ! 3379: txpred += NTXBLOCKS * TXBLOCKZ; ! 3380: lp->tx_first_free += TXBLOCKZ; ! 3381: if(lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ) ! 3382: lp->tx_first_free -= NTXBLOCKS * TXBLOCKZ; ! 3383: ! 3384: lp->tx_n_in_use++; ! 3385: ! 3386: /* Calculate addresses of the different parts of the block. */ ! 3387: tx_addr = txblock; ! 3388: nop_addr = tx_addr + sizeof(tx); ! 3389: tbd_addr = nop_addr + sizeof(nop); ! 3390: cfg_addr = tbd_addr + sizeof(tbd_t); /* beginning of the buffer */ ! 3391: ias_addr = cfg_addr + sizeof(cfg); ! 3392: mcs_addr = ias_addr + sizeof(ias); ! 3393: ! 3394: /* ! 3395: * Transmit command ! 3396: */ ! 3397: tx.tx_h.ac_status = 0xFFFF; /* Fake completion value */ ! 3398: obram_write(ioaddr, toff(ac_tx_t, tx_addr, tx_h.ac_status), ! 3399: (unsigned char *) &tx.tx_h.ac_status, ! 3400: sizeof(tx.tx_h.ac_status)); ! 3401: ! 3402: /* ! 3403: * NOP command ! 3404: */ ! 3405: nop.nop_h.ac_status = 0; ! 3406: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status), ! 3407: (unsigned char *) &nop.nop_h.ac_status, ! 3408: sizeof(nop.nop_h.ac_status)); ! 3409: nop.nop_h.ac_link = nop_addr; ! 3410: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link), ! 3411: (unsigned char *) &nop.nop_h.ac_link, ! 3412: sizeof(nop.nop_h.ac_link)); ! 3413: ! 3414: /* Create a configure action */ ! 3415: memset(&cfg, 0x00, sizeof(cfg)); ! 3416: ! 3417: #if 0 ! 3418: /* ! 3419: * The default board configuration ! 3420: */ ! 3421: cfg.fifolim_bytecnt = 0x080c; ! 3422: cfg.addrlen_mode = 0x2600; ! 3423: cfg.linprio_interframe = 0x7820; /* IFS=120, ACS=2 */ ! 3424: cfg.slot_time = 0xf00c; /* slottime=12 */ ! 3425: cfg.hardware = 0x0008; /* tx even without CD */ ! 3426: cfg.min_frame_len = 0x0040; ! 3427: #endif /* 0 */ ! 3428: ! 3429: /* ! 3430: * For Linux we invert AC_CFG_ALOC(..) so as to conform ! 3431: * to the way that net packets reach us from above. ! 3432: * (See also ac_tx_t.) ! 3433: */ ! 3434: cfg.cfg_byte_cnt = AC_CFG_BYTE_CNT(sizeof(ac_cfg_t) - sizeof(ach_t)); ! 3435: cfg.cfg_fifolim = AC_CFG_FIFOLIM(8); ! 3436: cfg.cfg_byte8 = AC_CFG_SAV_BF(0) | ! 3437: AC_CFG_SRDY(0); ! 3438: cfg.cfg_byte9 = AC_CFG_ELPBCK(0) | ! 3439: AC_CFG_ILPBCK(0) | ! 3440: AC_CFG_PRELEN(AC_CFG_PLEN_2) | ! 3441: AC_CFG_ALOC(1) | ! 3442: AC_CFG_ADDRLEN(WAVELAN_ADDR_SIZE); ! 3443: cfg.cfg_byte10 = AC_CFG_BOFMET(0) | ! 3444: AC_CFG_ACR(0) | ! 3445: AC_CFG_LINPRIO(0); ! 3446: cfg.cfg_ifs = 32; ! 3447: cfg.cfg_slotl = 0; ! 3448: cfg.cfg_byte13 = AC_CFG_RETRYNUM(15) | ! 3449: AC_CFG_SLTTMHI(2); ! 3450: cfg.cfg_byte14 = AC_CFG_FLGPAD(0) | ! 3451: AC_CFG_BTSTF(0) | ! 3452: AC_CFG_CRC16(0) | ! 3453: AC_CFG_NCRC(0) | ! 3454: AC_CFG_TNCRS(1) | ! 3455: AC_CFG_MANCH(0) | ! 3456: AC_CFG_BCDIS(0) | ! 3457: AC_CFG_PRM(lp->promiscuous); ! 3458: cfg.cfg_byte15 = AC_CFG_ICDS(0) | ! 3459: AC_CFG_CDTF(0) | ! 3460: AC_CFG_ICSS(0) | ! 3461: AC_CFG_CSTF(0); ! 3462: /* ! 3463: cfg.cfg_min_frm_len = AC_CFG_MNFRM(64); ! 3464: */ ! 3465: cfg.cfg_min_frm_len = AC_CFG_MNFRM(8); ! 3466: ! 3467: cfg.cfg_h.ac_command = (AC_CFLD_CMD & acmd_configure); ! 3468: cfg.cfg_h.ac_link = ias_addr; ! 3469: obram_write(ioaddr, cfg_addr, (unsigned char *)&cfg, sizeof(cfg)); ! 3470: ! 3471: /* Setup the MAC address */ ! 3472: memset(&ias, 0x00, sizeof(ias)); ! 3473: ias.ias_h.ac_command = (AC_CFLD_CMD & acmd_ia_setup); ! 3474: ias.ias_h.ac_link = mcs_addr; ! 3475: memcpy(&ias.ias_addr[0], (unsigned char *)&dev->dev_addr[0], sizeof(ias.ias_addr)); ! 3476: obram_write(ioaddr, ias_addr, (unsigned char *)&ias, sizeof(ias)); ! 3477: ! 3478: /* Initialize adapter's ethernet multicast addresses */ ! 3479: memset(&mcs, 0x00, sizeof(mcs)); ! 3480: mcs.mcs_h.ac_command = AC_CFLD_I | (AC_CFLD_CMD & acmd_mc_setup); ! 3481: mcs.mcs_h.ac_link = nop_addr; ! 3482: mcs.mcs_cnt = WAVELAN_ADDR_SIZE * lp->mc_count; ! 3483: obram_write(ioaddr, mcs_addr, (unsigned char *)&mcs, sizeof(mcs)); ! 3484: ! 3485: /* If any address to set */ ! 3486: if(lp->mc_count) ! 3487: { ! 3488: for(dmi=dev->mc_list; dmi; dmi=dmi->next) ! 3489: outsw(PIOP1(ioaddr), (u_short *) dmi->dmi_addr, ! 3490: WAVELAN_ADDR_SIZE >> 1); ! 3491: ! 3492: #ifdef DEBUG_CONFIG_INFO ! 3493: printk(KERN_DEBUG "%s: wv_82586_config(): set %d multicast addresses:\n", ! 3494: dev->name, lp->mc_count); ! 3495: for(dmi=dev->mc_list; dmi; dmi=dmi->next) ! 3496: printk(KERN_DEBUG " %02x:%02x:%02x:%02x:%02x:%02x\n", ! 3497: dmi->dmi_addr[0], dmi->dmi_addr[1], dmi->dmi_addr[2], ! 3498: dmi->dmi_addr[3], dmi->dmi_addr[4], dmi->dmi_addr[5] ); ! 3499: #endif ! 3500: } ! 3501: ! 3502: /* ! 3503: * Overwrite the predecessor NOP link ! 3504: * so that it points to the configure action. ! 3505: */ ! 3506: nop_addr = txpred + sizeof(tx); ! 3507: nop.nop_h.ac_status = 0; ! 3508: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_status), ! 3509: (unsigned char *)&nop.nop_h.ac_status, ! 3510: sizeof(nop.nop_h.ac_status)); ! 3511: nop.nop_h.ac_link = cfg_addr; ! 3512: obram_write(ioaddr, toff(ac_nop_t, nop_addr, nop_h.ac_link), ! 3513: (unsigned char *) &nop.nop_h.ac_link, ! 3514: sizeof(nop.nop_h.ac_link)); ! 3515: ! 3516: /* If watchdog not already active, activate it... */ ! 3517: if(lp->watchdog.prev == (timer_list *) NULL) ! 3518: { ! 3519: /* set timer to expire in WATCHDOG_JIFFIES */ ! 3520: lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES; ! 3521: add_timer(&lp->watchdog); ! 3522: } ! 3523: ! 3524: lp->reconfig_82586 = 0; ! 3525: ! 3526: if(lp->tx_first_in_use == I82586NULL) ! 3527: lp->tx_first_in_use = txblock; ! 3528: ! 3529: if(lp->tx_n_in_use < NTXBLOCKS - 1) ! 3530: dev->tbusy = 0; ! 3531: ! 3532: wv_splx(x); ! 3533: ! 3534: #ifdef DEBUG_CONFIG_TRACE ! 3535: printk(KERN_DEBUG "%s: <-wv_82586_config()\n", dev->name); ! 3536: #endif ! 3537: } ! 3538: ! 3539: /*------------------------------------------------------------------*/ ! 3540: /* ! 3541: * This routine, called by wavelan_close(), gracefully stops the ! 3542: * WaveLAN controller (i82586). ! 3543: */ ! 3544: static inline void ! 3545: wv_82586_stop(device * dev) ! 3546: { ! 3547: net_local * lp = (net_local *) dev->priv; ! 3548: u_long ioaddr = dev->base_addr; ! 3549: u_short scb_cmd; ! 3550: ! 3551: #ifdef DEBUG_CONFIG_TRACE ! 3552: printk(KERN_DEBUG "%s: ->wv_82586_stop()\n", dev->name); ! 3553: #endif ! 3554: ! 3555: /* Suspend both command unit and receive unit. */ ! 3556: scb_cmd = (SCB_CMD_CUC & SCB_CMD_CUC_SUS) | (SCB_CMD_RUC & SCB_CMD_RUC_SUS); ! 3557: obram_write(ioaddr, scboff(OFFSET_SCB, scb_command), ! 3558: (unsigned char *)&scb_cmd, sizeof(scb_cmd)); ! 3559: set_chan_attn(ioaddr, lp->hacr); ! 3560: ! 3561: /* No more interrupts */ ! 3562: wv_ints_off(dev); ! 3563: ! 3564: #ifdef DEBUG_CONFIG_TRACE ! 3565: printk(KERN_DEBUG "%s: <-wv_82586_stop()\n", dev->name); ! 3566: #endif ! 3567: } ! 3568: ! 3569: /*------------------------------------------------------------------*/ ! 3570: /* ! 3571: * Totally reset the WaveLAN and restart it. ! 3572: * Performs the following actions: ! 3573: * 1. A power reset (reset DMA) ! 3574: * 2. Initialize the radio modem (using wv_mmc_init) ! 3575: * 3. Reset & Configure LAN controller (using wv_82586_start) ! 3576: * 4. Start the LAN controller's command unit ! 3577: * 5. Start the LAN controller's receive unit ! 3578: */ ! 3579: static int ! 3580: wv_hw_reset(device * dev) ! 3581: { ! 3582: net_local * lp = (net_local *)dev->priv; ! 3583: u_long ioaddr = dev->base_addr; ! 3584: ! 3585: #ifdef DEBUG_CONFIG_TRACE ! 3586: printk(KERN_DEBUG "%s: ->wv_hw_reset(dev=0x%x)\n", dev->name, ! 3587: (unsigned int)dev); ! 3588: #endif ! 3589: ! 3590: /* If watchdog was activated, kill it! */ ! 3591: if(lp->watchdog.prev != (timer_list *) NULL) ! 3592: del_timer(&lp->watchdog); ! 3593: ! 3594: /* Increase the number of resets done */ ! 3595: lp->nresets++; ! 3596: ! 3597: wv_hacr_reset(ioaddr); ! 3598: lp->hacr = HACR_DEFAULT; ! 3599: ! 3600: if((wv_mmc_init(dev) < 0) || ! 3601: (wv_82586_start(dev) < 0)) ! 3602: return -1; ! 3603: ! 3604: /* Enable the card to send interrupts */ ! 3605: wv_ints_on(dev); ! 3606: ! 3607: /* Start card functions */ ! 3608: if((wv_ru_start(dev) < 0) || ! 3609: (wv_cu_start(dev) < 0)) ! 3610: return -1; ! 3611: ! 3612: /* Finish configuration */ ! 3613: wv_82586_config(dev); ! 3614: ! 3615: #ifdef DEBUG_CONFIG_TRACE ! 3616: printk(KERN_DEBUG "%s: <-wv_hw_reset()\n", dev->name); ! 3617: #endif ! 3618: return 0; ! 3619: } ! 3620: ! 3621: /*------------------------------------------------------------------*/ ! 3622: /* ! 3623: * Check if there is a WaveLAN at the specific base address. ! 3624: * As a side effect, this reads the MAC address. ! 3625: * (called in wavelan_probe() and init_module()) ! 3626: */ ! 3627: static int ! 3628: wv_check_ioaddr(u_long ioaddr, ! 3629: u_char * mac) ! 3630: { ! 3631: int i; /* Loop counter */ ! 3632: ! 3633: /* Check if the base address if available */ ! 3634: if(check_region(ioaddr, sizeof(ha_t))) ! 3635: return EADDRINUSE; /* ioaddr already used... */ ! 3636: ! 3637: /* Reset host interface */ ! 3638: wv_hacr_reset(ioaddr); ! 3639: ! 3640: /* Read the MAC address from the parameter storage area */ ! 3641: psa_read(ioaddr, HACR_DEFAULT, psaoff(0, psa_univ_mac_addr), ! 3642: mac, 6); ! 3643: ! 3644: /* ! 3645: * Check the first three octets of the address for the manufacturer's code. ! 3646: * Note: If this can't find your WaveLAN card, you've got a ! 3647: * non-NCR/AT&T/Lucent ISA card. See wavelan.p.h for details on ! 3648: * how to configure your card. ! 3649: */ ! 3650: for(i = 0; i < (sizeof(MAC_ADDRESSES) / sizeof(char) / 3); i++) ! 3651: if((mac[0] == MAC_ADDRESSES[i][0]) && ! 3652: (mac[1] == MAC_ADDRESSES[i][1]) && ! 3653: (mac[2] == MAC_ADDRESSES[i][2])) ! 3654: return 0; ! 3655: ! 3656: #ifdef DEBUG_CONFIG_INFO ! 3657: printk(KERN_WARNING "WaveLAN (0x%3X): your MAC address might be: %02X:%02X:%02X.\n", ! 3658: ioaddr, mac[0], mac[1], mac[2]); ! 3659: #endif ! 3660: return ENODEV; ! 3661: } ! 3662: ! 3663: /************************ INTERRUPT HANDLING ************************/ ! 3664: ! 3665: /* ! 3666: * This function is the interrupt handler for the WaveLAN card. This ! 3667: * routine will be called whenever: ! 3668: */ ! 3669: static void ! 3670: wavelan_interrupt(int irq, ! 3671: void * dev_id, ! 3672: struct pt_regs * regs) ! 3673: { ! 3674: device * dev; ! 3675: u_long ioaddr; ! 3676: net_local * lp; ! 3677: u_short hasr; ! 3678: u_short status; ! 3679: u_short ack_cmd; ! 3680: ! 3681: if((dev = (device *) (irq2dev_map[irq])) == (device *) NULL) ! 3682: { ! 3683: #ifdef DEBUG_INTERRUPT_ERROR ! 3684: printk(KERN_WARNING "wavelan_interrupt(): irq %d for unknown device.\n", ! 3685: irq); ! 3686: #endif ! 3687: return; ! 3688: } ! 3689: ! 3690: #ifdef DEBUG_INTERRUPT_TRACE ! 3691: printk(KERN_DEBUG "%s: ->wavelan_interrupt()\n", dev->name); ! 3692: #endif ! 3693: ! 3694: lp = (net_local *) dev->priv; ! 3695: ioaddr = dev->base_addr; ! 3696: ! 3697: /* Prevent reentrance. What should we do here? */ ! 3698: #ifdef DEBUG_INTERRUPT_ERROR ! 3699: if(dev->interrupt) ! 3700: printk(KERN_INFO "%s: wavelan_interrupt(): Re-entering the interrupt handler.\n", ! 3701: dev->name); ! 3702: #endif ! 3703: dev->interrupt = 1; ! 3704: ! 3705: if((hasr = hasr_read(ioaddr)) & HASR_MMC_INTR) ! 3706: { ! 3707: u_char dce_status; ! 3708: ! 3709: /* ! 3710: * Interrupt from the modem management controller. ! 3711: * This will clear it -- ignored for now. ! 3712: */ ! 3713: mmc_read(ioaddr, mmroff(0, mmr_dce_status), &dce_status, sizeof(dce_status)); ! 3714: #ifdef DEBUG_INTERRUPT_ERROR ! 3715: printk(KERN_INFO "%s: wavelan_interrupt(): unexpected mmc interrupt: status 0x%04x.\n", ! 3716: dev->name, dce_status); ! 3717: #endif ! 3718: } ! 3719: ! 3720: if((hasr & HASR_82586_INTR) == 0) ! 3721: { ! 3722: dev->interrupt = 0; ! 3723: #ifdef DEBUG_INTERRUPT_ERROR ! 3724: printk(KERN_INFO "%s: wavelan_interrupt(): interrupt not coming from i82586\n", ! 3725: dev->name); ! 3726: #endif ! 3727: return; ! 3728: } ! 3729: ! 3730: /* Read interrupt data. */ ! 3731: obram_read(ioaddr, scboff(OFFSET_SCB, scb_status), ! 3732: (unsigned char *) &status, sizeof(status)); ! 3733: ! 3734: /* ! 3735: * Acknowledge the interrupt(s). ! 3736: */ ! 3737: ack_cmd = status & SCB_ST_INT; ! 3738: obram_write(ioaddr, scboff(OFFSET_SCB, scb_command), ! 3739: (unsigned char *) &ack_cmd, sizeof(ack_cmd)); ! 3740: set_chan_attn(ioaddr, lp->hacr); ! 3741: ! 3742: #ifdef DEBUG_INTERRUPT_INFO ! 3743: printk(KERN_DEBUG "%s: wavelan_interrupt(): status 0x%04x.\n", ! 3744: dev->name, status); ! 3745: #endif ! 3746: ! 3747: /* Command completed. */ ! 3748: if((status & SCB_ST_CX) == SCB_ST_CX) ! 3749: { ! 3750: #ifdef DEBUG_INTERRUPT_INFO ! 3751: printk(KERN_DEBUG "%s: wavelan_interrupt(): command completed.\n", ! 3752: dev->name); ! 3753: #endif ! 3754: wv_complete(dev, ioaddr, lp); ! 3755: ! 3756: /* If watchdog was activated, kill it ! */ ! 3757: if(lp->watchdog.prev != (timer_list *) NULL) ! 3758: del_timer(&lp->watchdog); ! 3759: if(lp->tx_n_in_use > 0) ! 3760: { ! 3761: /* set timer to expire in WATCHDOG_JIFFIES */ ! 3762: lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES; ! 3763: add_timer(&lp->watchdog); ! 3764: } ! 3765: } ! 3766: ! 3767: /* Frame received. */ ! 3768: if((status & SCB_ST_FR) == SCB_ST_FR) ! 3769: { ! 3770: #ifdef DEBUG_INTERRUPT_INFO ! 3771: printk(KERN_DEBUG "%s: wavelan_interrupt(): received packet.\n", ! 3772: dev->name); ! 3773: #endif ! 3774: wv_receive(dev); ! 3775: } ! 3776: ! 3777: /* Check the state of the command unit. */ ! 3778: if(((status & SCB_ST_CNA) == SCB_ST_CNA) || ! 3779: (((status & SCB_ST_CUS) != SCB_ST_CUS_ACTV) && dev->start)) ! 3780: { ! 3781: #ifdef DEBUG_INTERRUPT_ERROR ! 3782: printk(KERN_INFO "%s: wavelan_interrupt(): CU inactive -- restarting\n", ! 3783: dev->name); ! 3784: #endif ! 3785: wv_hw_reset(dev); ! 3786: } ! 3787: ! 3788: /* Check the state of the command unit. */ ! 3789: if(((status & SCB_ST_RNR) == SCB_ST_RNR) || ! 3790: (((status & SCB_ST_RUS) != SCB_ST_RUS_RDY) && dev->start)) ! 3791: { ! 3792: #ifdef DEBUG_INTERRUPT_ERROR ! 3793: printk(KERN_INFO "%s: wavelan_interrupt(): RU not ready -- restarting\n", ! 3794: dev->name); ! 3795: #endif ! 3796: wv_hw_reset(dev); ! 3797: } ! 3798: ! 3799: dev->interrupt = 0; ! 3800: ! 3801: #ifdef DEBUG_INTERRUPT_TRACE ! 3802: printk(KERN_DEBUG "%s: <-wavelan_interrupt()\n", dev->name); ! 3803: #endif ! 3804: } ! 3805: ! 3806: /*------------------------------------------------------------------*/ ! 3807: /* ! 3808: * Watchdog: when we start a transmission, we set a timer in the ! 3809: * kernel. If the transmission completes, this timer is disabled. If ! 3810: * the timer expires, we try to unlock the hardware. ! 3811: * ! 3812: * Note: this watchdog doesn't work on the same principle as the ! 3813: * watchdog in the previous version of the ISA driver. I made it this ! 3814: * way because the overhead of add_timer() and del_timer() is nothing ! 3815: * and because it avoids calling the watchdog, saving some CPU time. ! 3816: */ ! 3817: static void ! 3818: wavelan_watchdog(u_long a) ! 3819: { ! 3820: device * dev; ! 3821: net_local * lp; ! 3822: u_long ioaddr; ! 3823: unsigned long x; ! 3824: unsigned int nreaped; ! 3825: ! 3826: dev = (device *) a; ! 3827: ioaddr = dev->base_addr; ! 3828: lp = (net_local *) dev->priv; ! 3829: ! 3830: #ifdef DEBUG_INTERRUPT_TRACE ! 3831: printk(KERN_DEBUG "%s: ->wavelan_watchdog()\n", dev->name); ! 3832: #endif ! 3833: ! 3834: #ifdef DEBUG_INTERRUPT_ERROR ! 3835: printk(KERN_INFO "%s: wavelan_watchdog: watchdog timer expired\n", ! 3836: dev->name); ! 3837: #endif ! 3838: ! 3839: x = wv_splhi(); ! 3840: ! 3841: dev = (device *) a; ! 3842: ioaddr = dev->base_addr; ! 3843: lp = (net_local *) dev->priv; ! 3844: ! 3845: if(lp->tx_n_in_use <= 0) ! 3846: { ! 3847: wv_splx(x); ! 3848: return; ! 3849: } ! 3850: ! 3851: nreaped = wv_complete(dev, ioaddr, lp); ! 3852: ! 3853: #ifdef DEBUG_INTERRUPT_INFO ! 3854: printk(KERN_DEBUG "%s: wavelan_watchdog(): %d reaped, %d remain.\n", ! 3855: dev->name, nreaped, lp->tx_n_in_use); ! 3856: #endif ! 3857: ! 3858: #ifdef DEBUG_PSA_SHOW ! 3859: { ! 3860: psa_t psa; ! 3861: psa_read(dev, 0, (unsigned char *) &psa, sizeof(psa)); ! 3862: wv_psa_show(&psa); ! 3863: } ! 3864: #endif ! 3865: #ifdef DEBUG_MMC_SHOW ! 3866: wv_mmc_show(dev); ! 3867: #endif ! 3868: #ifdef DEBUG_I82586_SHOW ! 3869: wv_cu_show(dev); ! 3870: #endif ! 3871: ! 3872: /* If no buffer has been freed */ ! 3873: if(nreaped == 0) ! 3874: { ! 3875: #ifdef DEBUG_INTERRUPT_ERROR ! 3876: printk(KERN_INFO "%s: wavelan_watchdog(): cleanup failed, trying reset\n", ! 3877: dev->name); ! 3878: #endif ! 3879: wv_hw_reset(dev); ! 3880: } ! 3881: else ! 3882: /* Reset watchdog for next transmission. */ ! 3883: if(lp->tx_n_in_use > 0) ! 3884: { ! 3885: /* set timer to expire in WATCHDOG_JIFFIES */ ! 3886: lp->watchdog.expires = jiffies + WATCHDOG_JIFFIES; ! 3887: add_timer(&lp->watchdog); ! 3888: } ! 3889: ! 3890: wv_splx(x); ! 3891: ! 3892: #ifdef DEBUG_INTERRUPT_TRACE ! 3893: printk(KERN_DEBUG "%s: <-wavelan_watchdog()\n", dev->name); ! 3894: #endif ! 3895: } ! 3896: ! 3897: /********************* CONFIGURATION CALLBACKS *********************/ ! 3898: /* ! 3899: * Here are the functions called by the Linux networking code (NET3) ! 3900: * for initialization, configuration and deinstallations of the ! 3901: * WaveLAN ISA hardware. ! 3902: */ ! 3903: ! 3904: /*------------------------------------------------------------------*/ ! 3905: /* ! 3906: * Configure and start up the WaveLAN PCMCIA adaptor. ! 3907: * Called by NET3 when it "open" the device. ! 3908: */ ! 3909: static int ! 3910: wavelan_open(device * dev) ! 3911: { ! 3912: u_long x; ! 3913: ! 3914: #ifdef DEBUG_CALLBACK_TRACE ! 3915: printk(KERN_DEBUG "%s: ->wavelan_open(dev=0x%x)\n", dev->name, ! 3916: (unsigned int) dev); ! 3917: #endif ! 3918: ! 3919: /* Check irq */ ! 3920: if(dev->irq == 0) ! 3921: { ! 3922: #ifdef DEBUG_CONFIG_ERRORS ! 3923: printk(KERN_WARNING "%s: wavelan_open(): no IRQ\n", dev->name); ! 3924: #endif ! 3925: return -ENXIO; ! 3926: } ! 3927: ! 3928: if((irq2dev_map[dev->irq] != (device *) NULL) || ! 3929: /* This is always true, but avoid the false IRQ. */ ! 3930: ((irq2dev_map[dev->irq] = dev) == (device *) NULL) || ! 3931: (request_irq(dev->irq, &wavelan_interrupt, 0, "WaveLAN", NULL) != 0)) ! 3932: { ! 3933: irq2dev_map[dev->irq] = (device *) NULL; ! 3934: #ifdef DEBUG_CONFIG_ERRORS ! 3935: printk(KERN_WARNING "%s: wavelan_open(): invalid IRQ\n", dev->name); ! 3936: #endif ! 3937: return -EAGAIN; ! 3938: } ! 3939: ! 3940: x = wv_splhi(); ! 3941: if(wv_hw_reset(dev) != -1) ! 3942: { ! 3943: dev->interrupt = 0; ! 3944: dev->start = 1; ! 3945: } ! 3946: else ! 3947: { ! 3948: free_irq(dev->irq, NULL); ! 3949: irq2dev_map[dev->irq] = (device *) NULL; ! 3950: #ifdef DEBUG_CONFIG_ERRORS ! 3951: printk(KERN_INFO "%s: wavelan_open(): impossible to start the card\n", ! 3952: dev->name); ! 3953: #endif ! 3954: return -EAGAIN; ! 3955: } ! 3956: wv_splx(x); ! 3957: ! 3958: MOD_INC_USE_COUNT; ! 3959: ! 3960: #ifdef DEBUG_CALLBACK_TRACE ! 3961: printk(KERN_DEBUG "%s: <-wavelan_open()\n", dev->name); ! 3962: #endif ! 3963: return 0; ! 3964: } ! 3965: ! 3966: /*------------------------------------------------------------------*/ ! 3967: /* ! 3968: * Shut down the WaveLAN ISA card. ! 3969: * Called by NET3 when it "closes" the device. ! 3970: */ ! 3971: static int ! 3972: wavelan_close(device * dev) ! 3973: { ! 3974: net_local * lp = (net_local *)dev->priv; ! 3975: ! 3976: #ifdef DEBUG_CALLBACK_TRACE ! 3977: printk(KERN_DEBUG "%s: ->wavelan_close(dev=0x%x)\n", dev->name, ! 3978: (unsigned int) dev); ! 3979: #endif ! 3980: ! 3981: /* Not do the job twice. */ ! 3982: if(dev->start == 0) ! 3983: return 0; ! 3984: ! 3985: dev->tbusy = 1; ! 3986: dev->start = 0; ! 3987: ! 3988: /* If watchdog was activated, kill it! */ ! 3989: if(lp->watchdog.prev != (timer_list *) NULL) ! 3990: del_timer(&lp->watchdog); ! 3991: ! 3992: /* ! 3993: * Flush the Tx and disable Rx. ! 3994: */ ! 3995: wv_82586_stop(dev); ! 3996: ! 3997: free_irq(dev->irq, NULL); ! 3998: irq2dev_map[dev->irq] = (device *) NULL; ! 3999: ! 4000: MOD_DEC_USE_COUNT; ! 4001: ! 4002: #ifdef DEBUG_CALLBACK_TRACE ! 4003: printk(KERN_DEBUG "%s: <-wavelan_close()\n", dev->name); ! 4004: #endif ! 4005: return 0; ! 4006: } ! 4007: ! 4008: /*------------------------------------------------------------------*/ ! 4009: /* ! 4010: * Probe an I/O address, and if the WaveLAN is there configure the ! 4011: * device structure ! 4012: * (called by wavelan_probe() & via init_module()) ! 4013: */ ! 4014: static int ! 4015: wavelan_config(device * dev) ! 4016: { ! 4017: u_long ioaddr = dev->base_addr; ! 4018: u_char irq_mask; ! 4019: int irq; ! 4020: net_local * lp; ! 4021: ! 4022: #ifdef DEBUG_CALLBACK_TRACE ! 4023: printk(KERN_DEBUG "%s: ->wavelan_config(dev=0x%x, ioaddr=0x%x)\n", dev->name, ! 4024: (unsigned int)dev, ioaddr); ! 4025: #endif ! 4026: ! 4027: /* Check irq arg on command line */ ! 4028: if(dev->irq != 0) ! 4029: { ! 4030: irq_mask = wv_irq_to_psa(dev->irq); ! 4031: ! 4032: if(irq_mask == 0) ! 4033: { ! 4034: #ifdef DEBUG_CONFIG_ERROR ! 4035: printk(KERN_WARNING "%s: wavelan_config(): invalid irq %d -- ignored.\n", ! 4036: dev->name, dev->irq); ! 4037: #endif ! 4038: dev->irq = 0; ! 4039: } ! 4040: else ! 4041: { ! 4042: #ifdef DEBUG_CONFIG_INFO ! 4043: printk(KERN_DEBUG "%s: wavelan_config(): changing irq to %d\n", ! 4044: dev->name, dev->irq); ! 4045: #endif ! 4046: psa_write(ioaddr, HACR_DEFAULT, ! 4047: psaoff(0, psa_int_req_no), &irq_mask, 1); ! 4048: wv_hacr_reset(ioaddr); ! 4049: } ! 4050: } ! 4051: ! 4052: psa_read(ioaddr, HACR_DEFAULT, psaoff(0, psa_int_req_no), &irq_mask, 1); ! 4053: if((irq = wv_psa_to_irq(irq_mask)) == -1) ! 4054: { ! 4055: #ifdef DEBUG_CONFIG_ERROR ! 4056: printk(KERN_INFO "%s: wavelan_config(): could not wavelan_map_irq(%d).\n", ! 4057: dev->name, irq_mask); ! 4058: #endif ! 4059: return EAGAIN; ! 4060: } ! 4061: ! 4062: dev->irq = irq; ! 4063: ! 4064: request_region(ioaddr, sizeof(ha_t), "wavelan"); ! 4065: ! 4066: dev->mem_start = 0x0000; ! 4067: dev->mem_end = 0x0000; ! 4068: dev->if_port = 0; ! 4069: ! 4070: /* Initialize device structures */ ! 4071: dev->priv = kmalloc(sizeof(net_local), GFP_KERNEL); ! 4072: if(dev->priv == NULL) ! 4073: return -ENOMEM; ! 4074: memset(dev->priv, 0x00, sizeof(net_local)); ! 4075: lp = (net_local *)dev->priv; ! 4076: ! 4077: /* Back link to the device structure. */ ! 4078: lp->dev = dev; ! 4079: /* Add the device at the beginning of the linked list. */ ! 4080: lp->next = wavelan_list; ! 4081: wavelan_list = lp; ! 4082: ! 4083: lp->hacr = HACR_DEFAULT; ! 4084: ! 4085: lp->watchdog.function = wavelan_watchdog; ! 4086: lp->watchdog.data = (unsigned long) dev; ! 4087: lp->promiscuous = 0; ! 4088: lp->mc_count = 0; ! 4089: ! 4090: /* ! 4091: * Fill in the fields of the device structure ! 4092: * with Ethernet-generic values. ! 4093: */ ! 4094: ether_setup(dev); ! 4095: ! 4096: dev->open = wavelan_open; ! 4097: dev->stop = wavelan_close; ! 4098: dev->hard_start_xmit = wavelan_packet_xmit; ! 4099: dev->get_stats = wavelan_get_stats; ! 4100: dev->set_multicast_list = &wavelan_set_multicast_list; ! 4101: dev->set_mac_address = &wavelan_set_mac_address; ! 4102: ! 4103: #ifdef WIRELESS_EXT /* If wireless extension exist in the kernel */ ! 4104: dev->do_ioctl = wavelan_ioctl; ! 4105: dev->get_wireless_stats = wavelan_get_wireless_stats; ! 4106: #endif ! 4107: ! 4108: dev->mtu = WAVELAN_MTU; ! 4109: ! 4110: /* Display nice info */ ! 4111: wv_init_info(dev); ! 4112: ! 4113: #ifdef DEBUG_CALLBACK_TRACE ! 4114: printk(KERN_DEBUG "%s: <-wavelan_config()\n", dev->name); ! 4115: #endif ! 4116: return 0; ! 4117: } ! 4118: ! 4119: /*------------------------------------------------------------------*/ ! 4120: /* ! 4121: * Check for a network adaptor of this type. Return '0' iff one ! 4122: * exists. (There seem to be different interpretations of ! 4123: * the initial value of dev->base_addr. ! 4124: * We follow the example in drivers/net/ne.c.) ! 4125: * (called in "Space.c") ! 4126: * As this function is called outside the wavelan module, it should be ! 4127: * declared extern, but it seem to cause troubles... ! 4128: */ ! 4129: /* extern */ int ! 4130: wavelan_probe(device * dev) ! 4131: { ! 4132: short base_addr; ! 4133: mac_addr mac; /* MAC address (check WaveLAN existence) */ ! 4134: int i; ! 4135: int r; ! 4136: ! 4137: #ifdef DEBUG_CALLBACK_TRACE ! 4138: printk(KERN_DEBUG "%s: ->wavelan_probe(dev=0x%x (base_addr=0x%x))\n", ! 4139: dev->name, (unsigned int)dev, (unsigned int)dev->base_addr); ! 4140: #endif ! 4141: ! 4142: #ifdef STRUCT_CHECK ! 4143: if (wv_struct_check() != (char *) NULL) ! 4144: { ! 4145: printk(KERN_WARNING "%s: wavelan_probe(): structure/compiler botch: \"%s\"\n", ! 4146: dev->name, wv_struct_check()); ! 4147: return ENODEV; ! 4148: } ! 4149: #endif /* STRUCT_CHECK */ ! 4150: ! 4151: /* Check the value of the command line parameter for base address */ ! 4152: base_addr = dev->base_addr; ! 4153: ! 4154: /* Don't probe at all. */ ! 4155: if(base_addr < 0) ! 4156: { ! 4157: #ifdef DEBUG_CONFIG_ERRORS ! 4158: printk(KERN_WARNING "%s: wavelan_probe(): invalid base address\n", ! 4159: dev->name); ! 4160: #endif ! 4161: return ENXIO; ! 4162: } ! 4163: ! 4164: /* Check a single specified location. */ ! 4165: if(base_addr > 0x100) ! 4166: { ! 4167: /* Check if the is something at this base address */ ! 4168: if((r = wv_check_ioaddr(base_addr, mac)) == 0) ! 4169: { ! 4170: memcpy(dev->dev_addr, mac, 6); /* Copy MAC address */ ! 4171: r = wavelan_config(dev); ! 4172: } ! 4173: ! 4174: #ifdef DEBUG_CONFIG_INFO ! 4175: if(r != 0) ! 4176: printk(KERN_DEBUG "%s: wavelan_probe(): no device at specified base address (0x%X) or address already in use\n", ! 4177: dev->name, base_addr); ! 4178: #endif ! 4179: ! 4180: #ifdef DEBUG_CALLBACK_TRACE ! 4181: printk(KERN_DEBUG "%s: <-wavelan_probe()\n", dev->name); ! 4182: #endif ! 4183: return r; ! 4184: } ! 4185: ! 4186: /* Scan all possible addresses of the WaveLAN hardware */ ! 4187: for(i = 0; i < NELS(iobase); i++) ! 4188: { ! 4189: /* Check whether there is something at this base address */ ! 4190: if(wv_check_ioaddr(iobase[i], mac) == 0) ! 4191: { ! 4192: dev->base_addr = iobase[i]; /* Copy base address. */ ! 4193: memcpy(dev->dev_addr, mac, 6); /* Copy MAC address. */ ! 4194: if(wavelan_config(dev) == 0) ! 4195: { ! 4196: #ifdef DEBUG_CALLBACK_TRACE ! 4197: printk(KERN_DEBUG "%s: <-wavelan_probe()\n", dev->name); ! 4198: #endif ! 4199: return 0; ! 4200: } ! 4201: } ! 4202: } ! 4203: ! 4204: /* We may have touch base_addr: another driver may not like it. */ ! 4205: dev->base_addr = base_addr; ! 4206: ! 4207: #ifdef DEBUG_CONFIG_INFO ! 4208: printk(KERN_DEBUG "%s: wavelan_probe(): no device found\n", ! 4209: dev->name); ! 4210: #endif ! 4211: ! 4212: return ENODEV; ! 4213: } ! 4214: ! 4215: /****************************** MODULE ******************************/ ! 4216: /* ! 4217: * Module entry point: insertion & removal ! 4218: */ ! 4219: ! 4220: #ifdef MODULE ! 4221: /*------------------------------------------------------------------*/ ! 4222: /* ! 4223: * Insertion of the module. ! 4224: * I'm now quite proud of the multi-device support. ! 4225: */ ! 4226: int ! 4227: init_module(void) ! 4228: { ! 4229: mac_addr mac; /* MAC address (check WaveLAN existence) */ ! 4230: int ret = 0; ! 4231: int i; ! 4232: ! 4233: #ifdef DEBUG_MODULE_TRACE ! 4234: printk(KERN_DEBUG "-> init_module()\n"); ! 4235: #endif ! 4236: ! 4237: /* If probing is asked */ ! 4238: if(io[0] == 0) ! 4239: { ! 4240: #ifdef DEBUG_CONFIG_ERRORS ! 4241: printk(KERN_WARNING "WaveLAN init_module(): doing device probing (bad !)\n"); ! 4242: printk(KERN_WARNING "Specify base addresses while loading module to correct the problem\n"); ! 4243: #endif ! 4244: ! 4245: /* Copy the basic set of address to be probed. */ ! 4246: for(i = 0; i < NELS(iobase); i++) ! 4247: io[i] = iobase[i]; ! 4248: } ! 4249: ! 4250: ! 4251: /* Loop on all possible base addresses */ ! 4252: i = -1; ! 4253: while((io[++i] != 0) && (i < NELS(io))) ! 4254: { ! 4255: /* Check if there is something at this base address. */ ! 4256: if(wv_check_ioaddr(io[i], mac) == 0) ! 4257: { ! 4258: device * dev; ! 4259: ! 4260: /* Create device and set basics args */ ! 4261: dev = kmalloc(sizeof(struct device), GFP_KERNEL); ! 4262: memset(dev, 0x00, sizeof(struct device)); ! 4263: dev->name = name[i]; ! 4264: dev->base_addr = io[i]; ! 4265: dev->irq = irq[i]; ! 4266: dev->init = &wavelan_config; ! 4267: memcpy(dev->dev_addr, mac, 6); /* Copy MAC address */ ! 4268: ! 4269: /* Try to create the device */ ! 4270: if(register_netdev(dev) != 0) ! 4271: { ! 4272: /* DeAllocate everything */ ! 4273: /* Note : if dev->priv is mallocated, there is no way to fail */ ! 4274: kfree_s(dev, sizeof(struct device)); ! 4275: ret = -EIO; ! 4276: } ! 4277: } /* if there is something at the address */ ! 4278: } /* Loop on all addresses. */ ! 4279: ! 4280: #ifdef DEBUG_CONFIG_ERRORS ! 4281: if(wavelan_list == (net_local *) NULL) ! 4282: printk(KERN_WARNING "WaveLAN init_module(): no device found\n"); ! 4283: #endif ! 4284: ! 4285: #ifdef DEBUG_MODULE_TRACE ! 4286: printk(KERN_DEBUG "<- init_module()\n"); ! 4287: #endif ! 4288: return ret; ! 4289: } ! 4290: ! 4291: /*------------------------------------------------------------------*/ ! 4292: /* ! 4293: * Removal of the module ! 4294: */ ! 4295: void ! 4296: cleanup_module(void) ! 4297: { ! 4298: #ifdef DEBUG_MODULE_TRACE ! 4299: printk(KERN_DEBUG "-> cleanup_module()\n"); ! 4300: #endif ! 4301: ! 4302: /* Loop on all devices and release them. */ ! 4303: while(wavelan_list != (net_local *) NULL) ! 4304: { ! 4305: device * dev = wavelan_list->dev; ! 4306: ! 4307: #ifdef DEBUG_CONFIG_INFO ! 4308: printk(KERN_DEBUG "%s: cleanup_module(): removing device at 0x%x\n", ! 4309: dev->name, (unsigned int) dev); ! 4310: #endif ! 4311: ! 4312: /* Release the ioport-region. */ ! 4313: release_region(dev->base_addr, sizeof(ha_t)); ! 4314: ! 4315: /* Definitely remove the device. */ ! 4316: unregister_netdev(dev); ! 4317: ! 4318: /* Unlink the device. */ ! 4319: wavelan_list = wavelan_list->next; ! 4320: ! 4321: /* Free pieces. */ ! 4322: kfree_s(dev->priv, sizeof(struct net_local)); ! 4323: kfree_s(dev, sizeof(struct device)); ! 4324: } ! 4325: ! 4326: #ifdef DEBUG_MODULE_TRACE ! 4327: printk(KERN_DEBUG "<- cleanup_module()\n"); ! 4328: #endif ! 4329: } ! 4330: #endif /* MODULE */ ! 4331: ! 4332: /* ! 4333: * This software may only be used and distributed ! 4334: * according to the terms of the GNU Public License. ! 4335: * ! 4336: * This software was developed as a component of the ! 4337: * Linux operating system. ! 4338: * It is based on other device drivers and information ! 4339: * either written or supplied by: ! 4340: * Ajay Bakre ([email protected]), ! 4341: * Donald Becker ([email protected]), ! 4342: * Loeke Brederveld ([email protected]), ! 4343: * Anders Klemets ([email protected]), ! 4344: * Vladimir V. Kolpakov ([email protected]), ! 4345: * Marc Meertens ([email protected]), ! 4346: * Pauline Middelink ([email protected]), ! 4347: * Robert Morris ([email protected]), ! 4348: * Jean Tourrilhes ([email protected]), ! 4349: * Girish Welling ([email protected]), ! 4350: * ! 4351: * Thanks go also to: ! 4352: * James Ashton ([email protected]), ! 4353: * Alan Cox ([email protected]), ! 4354: * Allan Creighton ([email protected]), ! 4355: * Matthew Geier ([email protected]), ! 4356: * Remo di Giovanni ([email protected]), ! 4357: * Eckhard Grah ([email protected]), ! 4358: * Vipul Gupta ([email protected]), ! 4359: * Mark Hagan ([email protected]), ! 4360: * Tim Nicholson ([email protected]), ! 4361: * Ian Parkin ([email protected]), ! 4362: * John Rosenberg ([email protected]), ! 4363: * George Rossi ([email protected]), ! 4364: * Arthur Scott ([email protected]), ! 4365: * Peter Storey, ! 4366: * for their assistance and advice. ! 4367: * ! 4368: * Please send bug reports, updates, comments to: ! 4369: * ! 4370: * Bruce Janson Email: [email protected] ! 4371: * Basser Department of Computer Science Phone: +61-2-9351-3423 ! 4372: * University of Sydney, N.S.W., 2006, AUSTRALIA Fax: +61-2-9351-3838 ! 4373: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.