![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prism2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / net|
Return to prism2.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / net |
1.1 root 1: /**************************************************************************
2: Etherboot - BOOTP/TFTP Bootstrap Program
3: Prism2 NIC driver for Etherboot
4:
5: Written by Michael Brown of Fen Systems Ltd
6: $Id$
7: ***************************************************************************/
8:
9: /*
10: * This program is free software; you can redistribute it and/or
11: * modify it under the terms of the GNU General Public License as
12: * published by the Free Software Foundation; either version 2, or (at
13: * your option) any later version.
14: */
15:
16: FILE_LICENCE ( GPL2_OR_LATER );
17:
18: #include <etherboot.h>
19: #include <nic.h>
20: #include <ipxe/pci.h>
21: #include <ipxe/ethernet.h>
22:
23: /*
24: * Hard-coded SSID
25: * Leave blank in order to connect to any available SSID
26: */
27:
28: static const char hardcoded_ssid[] = "";
29:
30: /*
31: * Maximum number of info packets to wait for on a join attempt.
32: * Some APs (including the Linksys WAP11) will send a "you are disconnected" packet
33: * before sending the "you are connected" packet, if the card has previously been
34: * attached to the AP.
35: *
36: * 2 is probably a sensible value, but YMMV.
37: */
38:
39: #define MAX_JOIN_INFO_COUNT 2
40:
41: /*
42: * Type of Prism2 interface to support
43: * If not already defined, select PLX
44: */
45: #ifndef WLAN_HOSTIF
46: #define WLAN_HOSTIF WLAN_PLX
47: #endif
48:
49: /*
50: * Include wlan_compat, p80211 and hfa384x header files from Linux Prism2 driver
51: * We need to hack some defines in order to avoid compiling kernel-specific routines
52: */
53:
54: #define __LINUX_WLAN__
55: #undef __KERNEL__
56: #define __I386__
57: #include "wlan_compat.h"
58: #include "p80211hdr.h"
59: #include "hfa384x.h"
60: #define BAP_TIMEOUT ( 5000 )
61:
62: /*
63: * A few hacks to make the coding environment more Linux-like. This makes it somewhat
64: * quicker to convert code from the Linux Prism2 driver.
65: */
66: #include <errno.h>
67: #define __le16_to_cpu(x) (x)
68: #define __le32_to_cpu(x) (x)
69: #define __cpu_to_le16(x) (x)
70: #define __cpu_to_le32(x) (x)
71:
72: #define hfa384x2host_16(n) (__le16_to_cpu((UINT16)(n)))
73: #define hfa384x2host_32(n) (__le32_to_cpu((UINT32)(n)))
74: #define host2hfa384x_16(n) (__cpu_to_le16((UINT16)(n)))
75: #define host2hfa384x_32(n) (__cpu_to_le32((UINT32)(n)))
76:
77: /*
78: * PLX9052 PCI register offsets
79: * Taken from PLX9052 datasheet available from http://www.plxtech.com/download/9052/databook/9052db-20.pdf
80: */
81:
82: #define PLX_LOCAL_CONFIG_REGISTER_BASE ( PCI_BASE_ADDRESS_1 )
83: #define PLX_LOCAL_ADDRESS_SPACE_0_BASE ( PCI_BASE_ADDRESS_2 )
84: #define PLX_LOCAL_ADDRESS_SPACE_1_BASE ( PCI_BASE_ADDRESS_3 )
85: #define PLX_LOCAL_ADDRESS_SPACE_2_BASE ( PCI_BASE_ADDRESS_4 )
86: #define PLX_LOCAL_ADDRESS_SPACE_3_BASE ( PCI_BASE_ADDRESS_5 )
87:
88: #define PRISM2_PLX_ATTR_MEM_BASE ( PLX_LOCAL_ADDRESS_SPACE_0_BASE )
89: #define PRISM2_PLX_IO_BASE ( PLX_LOCAL_ADDRESS_SPACE_1_BASE )
90:
91: #define PRISM2_PCI_MEM_BASE ( PCI_BASE_ADDRESS_0 )
92:
93: /*
94: * PCMCIA CIS types
95: * Taken from cistpl.h in pcmcia-cs
96: */
97:
98: #define CISTPL_VERS_1 ( 0x15 )
99: #define CISTPL_END ( 0xff )
100:
101: #define CIS_STEP ( 2 )
102: #define CISTPL_HEADER_LEN ( 2 * CIS_STEP )
103: #define CISTPL_LEN_OFF ( 1 * CIS_STEP )
104: #define CISTPL_VERS_1_STR_OFF ( 4 * CIS_STEP )
105:
106: /*
107: * Prism2 constants
108: * Taken from prism2sta.c in linux-wlan-ng
109: */
110:
111: #define COR_OFFSET ( 0x3e0 ) /* COR attribute offset of Prism2 PC card */
112: #define COR_VALUE ( 0x41 ) /* Enable PC card with irq in level trigger (but interrupts disabled) */
113:
114: /* NIC specific static variables */
115:
116: /* The hfa384x_t structure is used extensively in the Linux driver but is ifdef'd out in our include since __KERNEL__ is not defined.
117: * This is a dummy version that contains only the fields we are interested in.
118: */
119:
120: typedef struct hfa384x
121: {
122: UINT32 iobase;
123: void *membase;
124: UINT16 lastcmd;
125: UINT16 status; /* in host order */
126: UINT16 resp0; /* in host order */
127: UINT16 resp1; /* in host order */
128: UINT16 resp2; /* in host order */
129: UINT8 bssid[WLAN_BSSID_LEN];
130: } hfa384x_t;
131:
132: /* The global instance of the hardware (i.e. where we store iobase and membase, in the absence of anywhere better to put them */
133: static hfa384x_t hw_global = {
134: 0, 0, 0, 0, 0, 0, 0, {0,0,0,0,0,0}
135: };
136:
137: /*
138: * 802.11 headers in addition to those in hfa384x_tx_frame_t (LLC and SNAP)
139: * Taken from p80211conv.h
140: */
141:
142: typedef struct wlan_llc
143: {
144: UINT8 dsap;
145: UINT8 ssap;
146: UINT8 ctl;
147: } wlan_llc_t;
148:
149: static const wlan_llc_t wlan_llc_snap = { 0xaa, 0xaa, 0x03 }; /* LLC header indicating SNAP (?) */
150:
151: #define WLAN_IEEE_OUI_LEN 3
152: typedef struct wlan_snap
153: {
154: UINT8 oui[WLAN_IEEE_OUI_LEN];
155: UINT16 type;
156: } wlan_snap_t;
157:
158: typedef struct wlan_80211hdr
159: {
160: wlan_llc_t llc;
161: wlan_snap_t snap;
162: } wlan_80211hdr_t;
163:
164: /*
165: * Function prototypes
166: */
167:
168: /*
169: * Hardware-level hfa384x functions
170: * These are based on the ones in hfa384x.h (which are ifdef'd out since __KERNEL__ is not defined).
171: * Basically, these functions are the result of hand-evaluating all the ifdefs and defines in the hfa384x.h versions.
172: */
173:
174: /* Retrieve the value of one of the MAC registers. */
175: static inline UINT16 hfa384x_getreg( hfa384x_t *hw, UINT reg )
176: {
177: #if (WLAN_HOSTIF == WLAN_PLX)
178: return inw ( hw->iobase + reg );
179: #elif (WLAN_HOSTIF == WLAN_PCI)
180: return readw ( hw->membase + reg );
181: #endif
182: }
183:
184: /* Set the value of one of the MAC registers. */
185: static inline void hfa384x_setreg( hfa384x_t *hw, UINT16 val, UINT reg )
186: {
187: #if (WLAN_HOSTIF == WLAN_PLX)
188: outw ( val, hw->iobase + reg );
189: #elif (WLAN_HOSTIF == WLAN_PCI)
190: writew ( val, hw->membase + reg );
191: #endif
192: return;
193: }
194:
195: /*
196: * Noswap versions
197: * Etherboot is i386 only, so swap and noswap are the same...
198: */
199: static inline UINT16 hfa384x_getreg_noswap( hfa384x_t *hw, UINT reg )
200: {
201: return hfa384x_getreg ( hw, reg );
202: }
203: static inline void hfa384x_setreg_noswap( hfa384x_t *hw, UINT16 val, UINT reg )
204: {
205: hfa384x_setreg ( hw, val, reg );
206: }
207:
208: /*
209: * Low-level hfa384x functions
210: * These are based on the ones in hfa384x.c, modified to work in the Etherboot environment.
211: */
212:
213: /*
214: * hfa384x_docmd_wait
215: *
216: * Waits for availability of the Command register, then
217: * issues the given command. Then polls the Evstat register
218: * waiting for command completion.
219: * Arguments:
220: * hw device structure
221: * cmd Command in host order
222: * parm0 Parameter0 in host order
223: * parm1 Parameter1 in host order
224: * parm2 Parameter2 in host order
225: * Returns:
226: * 0 success
227: * >0 command indicated error, Status and Resp0-2 are
228: * in hw structure.
229: */
230: static int hfa384x_docmd_wait( hfa384x_t *hw, UINT16 cmd, UINT16 parm0, UINT16 parm1, UINT16 parm2)
231: {
232: UINT16 reg = 0;
233: UINT16 counter = 0;
234:
235: /* wait for the busy bit to clear */
236: counter = 0;
237: reg = hfa384x_getreg(hw, HFA384x_CMD);
238: while ( HFA384x_CMD_ISBUSY(reg) && (counter < 10) ) {
239: reg = hfa384x_getreg(hw, HFA384x_CMD);
240: counter++;
241: udelay(10);
242: }
243: if (HFA384x_CMD_ISBUSY(reg)) {
244: printf("hfa384x_cmd timeout(1), reg=0x%0hx.\n", reg);
245: return -ETIMEDOUT;
246: }
247:
248: /* busy bit clear, write command */
249: hfa384x_setreg(hw, parm0, HFA384x_PARAM0);
250: hfa384x_setreg(hw, parm1, HFA384x_PARAM1);
251: hfa384x_setreg(hw, parm2, HFA384x_PARAM2);
252: hw->lastcmd = cmd;
253: hfa384x_setreg(hw, cmd, HFA384x_CMD);
254:
255: /* Now wait for completion */
256: counter = 0;
257: reg = hfa384x_getreg(hw, HFA384x_EVSTAT);
258: /* Initialization is the problem. It takes about
259: 100ms. "normal" commands are typically is about
260: 200-400 us (I've never seen less than 200). Longer
261: is better so that we're not hammering the bus. */
262: while ( !HFA384x_EVSTAT_ISCMD(reg) && (counter < 5000)) {
263: reg = hfa384x_getreg(hw, HFA384x_EVSTAT);
264: counter++;
265: udelay(200);
266: }
267: if ( ! HFA384x_EVSTAT_ISCMD(reg) ) {
268: printf("hfa384x_cmd timeout(2), reg=0x%0hx.\n", reg);
269: return -ETIMEDOUT;
270: }
271:
272: /* Read status and response */
273: hw->status = hfa384x_getreg(hw, HFA384x_STATUS);
274: hw->resp0 = hfa384x_getreg(hw, HFA384x_RESP0);
275: hw->resp1 = hfa384x_getreg(hw, HFA384x_RESP1);
276: hw->resp2 = hfa384x_getreg(hw, HFA384x_RESP2);
277: hfa384x_setreg(hw, HFA384x_EVACK_CMD, HFA384x_EVACK);
278: return HFA384x_STATUS_RESULT_GET(hw->status);
279: }
280:
281: /*
282: * Prepare BAP for access. Assigns FID and RID, sets offset register
283: * and waits for BAP to become available.
284: *
285: * Arguments:
286: * hw device structure
287: * id FID or RID, destined for the select register (host order)
288: * offset An _even_ offset into the buffer for the given FID/RID.
289: * Returns:
290: * 0 success
291: */
292: static int hfa384x_prepare_bap(hfa384x_t *hw, UINT16 id, UINT16 offset)
293: {
294: int result = 0;
295: UINT16 reg;
296: UINT16 i;
297:
298: /* Validate offset, buf, and len */
299: if ( (offset > HFA384x_BAP_OFFSET_MAX) || (offset % 2) ) {
300: result = -EINVAL;
301: } else {
302: /* Write fid/rid and offset */
303: hfa384x_setreg(hw, id, HFA384x_SELECT0);
304: udelay(10);
305: hfa384x_setreg(hw, offset, HFA384x_OFFSET0);
306: /* Wait for offset[busy] to clear (see BAP_TIMEOUT) */
307: i = 0;
308: do {
309: reg = hfa384x_getreg(hw, HFA384x_OFFSET0);
310: if ( i > 0 ) udelay(2);
311: i++;
312: } while ( i < BAP_TIMEOUT && HFA384x_OFFSET_ISBUSY(reg));
313: if ( i >= BAP_TIMEOUT ) {
314: /* failure */
315: result = reg;
316: } else if ( HFA384x_OFFSET_ISERR(reg) ){
317: /* failure */
318: result = reg;
319: }
320: }
321: return result;
322: }
323:
324: /*
325: * Copy data from BAP to memory.
326: *
327: * Arguments:
328: * hw device structure
329: * id FID or RID, destined for the select register (host order)
330: * offset An _even_ offset into the buffer for the given FID/RID.
331: * buf ptr to array of bytes
332: * len length of data to transfer in bytes
333: * Returns:
334: * 0 success
335: */
336: static int hfa384x_copy_from_bap(hfa384x_t *hw, UINT16 id, UINT16 offset,
337: void *buf, UINT len)
338: {
339: int result = 0;
340: UINT8 *d = (UINT8*)buf;
341: UINT16 i;
342: UINT16 reg = 0;
343:
344: /* Prepare BAP */
345: result = hfa384x_prepare_bap ( hw, id, offset );
346: if ( result == 0 ) {
347: /* Read even(len) buf contents from data reg */
348: for ( i = 0; i < (len & 0xfffe); i+=2 ) {
349: *(UINT16*)(&(d[i])) = hfa384x_getreg_noswap(hw, HFA384x_DATA0);
350: }
351: /* If len odd, handle last byte */
352: if ( len % 2 ){
353: reg = hfa384x_getreg_noswap(hw, HFA384x_DATA0);
354: d[len-1] = ((UINT8*)(®))[0];
355: }
356: }
357: if (result) {
358: printf ( "copy_from_bap(%#hx, %#hx, %d) failed, result=%#hx\n", id, offset, len, result);
359: }
360: return result;
361: }
362:
363: /*
364: * Copy data from memory to BAP.
365: *
366: * Arguments:
367: * hw device structure
368: * id FID or RID, destined for the select register (host order)
369: * offset An _even_ offset into the buffer for the given FID/RID.
370: * buf ptr to array of bytes
371: * len length of data to transfer in bytes
372: * Returns:
373: * 0 success
374: */
375: static int hfa384x_copy_to_bap(hfa384x_t *hw, UINT16 id, UINT16 offset,
376: void *buf, UINT len)
377: {
378: int result = 0;
379: UINT8 *d = (UINT8*)buf;
380: UINT16 i;
381: UINT16 savereg;
382:
383: /* Prepare BAP */
384: result = hfa384x_prepare_bap ( hw, id, offset );
385: if ( result == 0 ) {
386: /* Write even(len) buf contents to data reg */
387: for ( i = 0; i < (len & 0xfffe); i+=2 ) {
388: hfa384x_setreg_noswap(hw, *(UINT16*)(&(d[i])), HFA384x_DATA0);
389: }
390: /* If len odd, handle last byte */
391: if ( len % 2 ){
392: savereg = hfa384x_getreg_noswap(hw, HFA384x_DATA0);
393: result = hfa384x_prepare_bap ( hw, id, offset + (len & 0xfffe) );
394: if ( result == 0 ) {
395: ((UINT8*)(&savereg))[0] = d[len-1];
396: hfa384x_setreg_noswap(hw, savereg, HFA384x_DATA0);
397: }
398: }
399: }
400: if (result) {
401: printf ( "copy_to_bap(%#hx, %#hx, %d) failed, result=%#hx\n", id, offset, len, result);
402: }
403: return result;
404: }
405:
406: /*
407: * Request a given record to be copied to/from the record buffer.
408: *
409: * Arguments:
410: * hw device structure
411: * write [0|1] copy the record buffer to the given
412: * configuration record. (host order)
413: * rid RID of the record to read/write. (host order)
414: *
415: * Returns:
416: * 0 success
417: */
418: static inline int hfa384x_cmd_access(hfa384x_t *hw, UINT16 write, UINT16 rid)
419: {
420: return hfa384x_docmd_wait(hw, HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_ACCESS) | HFA384x_CMD_WRITE_SET(write), rid, 0, 0);
421: }
422:
423: /*
424: * Performs the sequence necessary to read a config/info item.
425: *
426: * Arguments:
427: * hw device structure
428: * rid config/info record id (host order)
429: * buf host side record buffer. Upon return it will
430: * contain the body portion of the record (minus the
431: * RID and len).
432: * len buffer length (in bytes, should match record length)
433: *
434: * Returns:
435: * 0 success
436: */
437: static int hfa384x_drvr_getconfig(hfa384x_t *hw, UINT16 rid, void *buf, UINT16 len)
438: {
439: int result = 0;
440: hfa384x_rec_t rec;
441:
442: /* Request read of RID */
443: result = hfa384x_cmd_access( hw, 0, rid);
444: if ( result ) {
445: printf("Call to hfa384x_cmd_access failed\n");
446: return -1;
447: }
448: /* Copy out record length */
449: result = hfa384x_copy_from_bap( hw, rid, 0, &rec, sizeof(rec));
450: if ( result ) {
451: return -1;
452: }
453: /* Validate the record length */
454: if ( ((hfa384x2host_16(rec.reclen)-1)*2) != len ) { /* note body len calculation in bytes */
455: printf ( "RID len mismatch, rid=%#hx hlen=%d fwlen=%d\n", rid, len, (hfa384x2host_16(rec.reclen)-1)*2);
456: return -1;
457: }
458: /* Copy out record data */
459: result = hfa384x_copy_from_bap( hw, rid, sizeof(rec), buf, len);
460: return result;
461: }
462:
463: /*
464: * Performs the sequence necessary to read a 16/32 bit config/info item
465: * and convert it to host order.
466: *
467: * Arguments:
468: * hw device structure
469: * rid config/info record id (in host order)
470: * val ptr to 16/32 bit buffer to receive value (in host order)
471: *
472: * Returns:
473: * 0 success
474: */
475: #if 0 /* Not actually used anywhere */
476: static int hfa384x_drvr_getconfig16(hfa384x_t *hw, UINT16 rid, void *val)
477: {
478: int result = 0;
479: result = hfa384x_drvr_getconfig(hw, rid, val, sizeof(UINT16));
480: if ( result == 0 ) {
481: *((UINT16*)val) = hfa384x2host_16(*((UINT16*)val));
482: }
483: return result;
484: }
485: #endif
486: #if 0 /* Not actually used anywhere */
487: static int hfa384x_drvr_getconfig32(hfa384x_t *hw, UINT16 rid, void *val)
488: {
489: int result = 0;
490: result = hfa384x_drvr_getconfig(hw, rid, val, sizeof(UINT32));
491: if ( result == 0 ) {
492: *((UINT32*)val) = hfa384x2host_32(*((UINT32*)val));
493: }
494: return result;
495: }
496: #endif
497:
498: /*
499: * Performs the sequence necessary to write a config/info item.
500: *
501: * Arguments:
502: * hw device structure
503: * rid config/info record id (in host order)
504: * buf host side record buffer
505: * len buffer length (in bytes)
506: *
507: * Returns:
508: * 0 success
509: */
510: static int hfa384x_drvr_setconfig(hfa384x_t *hw, UINT16 rid, void *buf, UINT16 len)
511: {
512: int result = 0;
513: hfa384x_rec_t rec;
514:
515: rec.rid = host2hfa384x_16(rid);
516: rec.reclen = host2hfa384x_16((len/2) + 1); /* note conversion to words, +1 for rid field */
517: /* write the record header */
518: result = hfa384x_copy_to_bap( hw, rid, 0, &rec, sizeof(rec));
519: if ( result ) {
520: printf("Failure writing record header\n");
521: return -1;
522: }
523: /* write the record data (if there is any) */
524: if ( len > 0 ) {
525: result = hfa384x_copy_to_bap( hw, rid, sizeof(rec), buf, len);
526: if ( result ) {
527: printf("Failure writing record data\n");
528: return -1;
529: }
530: }
531: /* Trigger setting of record */
532: result = hfa384x_cmd_access( hw, 1, rid);
533: return result;
534: }
535:
536: /*
537: * Performs the sequence necessary to write a 16/32 bit config/info item.
538: *
539: * Arguments:
540: * hw device structure
541: * rid config/info record id (in host order)
542: * val 16/32 bit value to store (in host order)
543: *
544: * Returns:
545: * 0 success
546: */
547: static int hfa384x_drvr_setconfig16(hfa384x_t *hw, UINT16 rid, UINT16 *val)
548: {
549: UINT16 value;
550: value = host2hfa384x_16(*val);
551: return hfa384x_drvr_setconfig(hw, rid, &value, sizeof(UINT16));
552: }
553: #if 0 /* Not actually used anywhere */
554: static int hfa384x_drvr_setconfig32(hfa384x_t *hw, UINT16 rid, UINT32 *val)
555: {
556: UINT32 value;
557: value = host2hfa384x_32(*val);
558: return hfa384x_drvr_setconfig(hw, rid, &value, sizeof(UINT32));
559: }
560: #endif
561:
562: /*
563: * Wait for an event, with specified checking interval and timeout.
564: * Automatically acknolwedges events.
565: *
566: * Arguments:
567: * hw device structure
568: * event_mask EVSTAT register mask of events to wait for
569: * event_ack EVACK register set of events to be acknowledged if they happen (can be
570: * used to acknowledge "ignorable" events in addition to the "main" event)
571: * wait Time (in us) to wait between each poll of the register
572: * timeout Maximum number of polls before timing out
573: * descr Descriptive text string of what is being waited for
574: * (will be printed out if a timeout happens)
575: *
576: * Returns:
577: * value of EVSTAT register, or 0 on failure
578: */
579: static int hfa384x_wait_for_event(hfa384x_t *hw, UINT16 event_mask, UINT16 event_ack, int wait, int timeout, const char *descr)
580: {
581: UINT16 reg;
582: int count = 0;
583:
584: do {
585: reg = hfa384x_getreg(hw, HFA384x_EVSTAT);
586: if ( count > 0 ) udelay(wait);
587: count++;
588: } while ( !(reg & event_mask) && count < timeout);
589: if ( count >= timeout ) {
590: printf("hfa384x: Timed out waiting for %s\n", descr);
591: return 0; /* Return failure */
592: }
593: /* Acknowledge all events that we were waiting on */
594: hfa384x_setreg(hw, reg & ( event_mask | event_ack ), HFA384x_EVACK);
595: return reg;
596: }
597:
598: /**************************************************************************
599: POLL - Wait for a frame
600: ***************************************************************************/
601: static int prism2_poll(struct nic *nic, int retrieve)
602: {
603: UINT16 reg;
604: UINT16 rxfid;
605: UINT16 result;
606: hfa384x_rx_frame_t rxdesc;
607: hfa384x_t *hw = &hw_global;
608:
609: /* Check for received packet */
610: reg = hfa384x_getreg(hw, HFA384x_EVSTAT);
611: if ( ! HFA384x_EVSTAT_ISRX(reg) ) {
612: /* No packet received - return 0 */
613: return 0;
614: }
615:
616: if ( ! retrieve ) return 1;
617:
618: /* Acknowledge RX event */
619: hfa384x_setreg(hw, HFA384x_EVACK_RX_SET(1), HFA384x_EVACK);
620: /* Get RX FID */
621: rxfid = hfa384x_getreg(hw, HFA384x_RXFID);
622: /* Get the descriptor (including headers) */
623: result = hfa384x_copy_from_bap(hw, rxfid, 0, &rxdesc, sizeof(rxdesc));
624: if ( result ) {
625: return 0; /* fail */
626: }
627: /* Byte order convert once up front. */
628: rxdesc.status = hfa384x2host_16(rxdesc.status);
629: rxdesc.time = hfa384x2host_32(rxdesc.time);
630: rxdesc.data_len = hfa384x2host_16(rxdesc.data_len);
631:
632: /* Fill in nic->packetlen */
633: nic->packetlen = rxdesc.data_len;
634: if ( nic->packetlen > 0 ) {
635: /* Fill in nic->packet */
636: /*
637: * NOTE: Packets as received have an 8-byte header (LLC+SNAP(?)) terminating with the packet type.
638: * Etherboot expects a 14-byte header terminating with the packet type (it ignores the rest of the
639: * header), so we use a quick hack to achieve this.
640: */
641: result = hfa384x_copy_from_bap(hw, rxfid, HFA384x_RX_DATA_OFF,
642: nic->packet + ETH_HLEN - sizeof(wlan_80211hdr_t), nic->packetlen);
643: if ( result ) {
644: return 0; /* fail */
645: }
646: }
647: return 1; /* Packet successfully received */
648: }
649:
650: /**************************************************************************
651: TRANSMIT - Transmit a frame
652: ***************************************************************************/
653: static void prism2_transmit(
654: struct nic *nic,
655: const char *d, /* Destination */
656: unsigned int t, /* Type */
657: unsigned int s, /* size */
658: const char *p) /* Packet */
659: {
660: hfa384x_t *hw = &hw_global;
661: hfa384x_tx_frame_t txdesc;
662: wlan_80211hdr_t p80211hdr = { wlan_llc_snap, {{0,0,0},0} };
663: UINT16 fid;
664: UINT16 status;
665: int result;
666:
667: // Request FID allocation
668: result = hfa384x_docmd_wait(hw, HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_ALLOC), HFA384x_DRVR_TXBUF_MAX, 0, 0);
669: if (result != 0) {
670: printf("hfa384x: Tx FID allocate command failed: Aborting transmit..\n");
671: return;
672: }
673: if ( !hfa384x_wait_for_event(hw, HFA384x_EVSTAT_ALLOC, HFA384x_EVACK_INFO, 10, 50, "Tx FID to be allocated\n" ) ) return;
674: fid = hfa384x_getreg(hw, HFA384x_ALLOCFID);
675:
676: /* Build Tx frame structure */
677: memset(&txdesc, 0, sizeof(txdesc));
678: txdesc.tx_control = host2hfa384x_16( HFA384x_TX_MACPORT_SET(0) | HFA384x_TX_STRUCTYPE_SET(1) |
679: HFA384x_TX_TXEX_SET(1) | HFA384x_TX_TXOK_SET(1) );
680: txdesc.frame_control = host2ieee16( WLAN_SET_FC_FTYPE(WLAN_FTYPE_DATA) |
681: WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_DATAONLY) |
682: WLAN_SET_FC_TODS(1) );
683: memcpy(txdesc.address1, hw->bssid, WLAN_ADDR_LEN);
684: memcpy(txdesc.address2, nic->node_addr, WLAN_ADDR_LEN);
685: memcpy(txdesc.address3, d, WLAN_ADDR_LEN);
686: txdesc.data_len = host2hfa384x_16( sizeof(txdesc) + sizeof(p80211hdr) + s );
687: /* Set up SNAP header */
688: /* Let OUI default to RFC1042 (0x000000) */
689: p80211hdr.snap.type = htons(t);
690:
691: /* Copy txdesc, p80211hdr and payload parts to FID */
692: result = hfa384x_copy_to_bap(hw, fid, 0, &txdesc, sizeof(txdesc));
693: if ( result ) return; /* fail */
694: result = hfa384x_copy_to_bap( hw, fid, sizeof(txdesc), &p80211hdr, sizeof(p80211hdr) );
695: if ( result ) return; /* fail */
696: result = hfa384x_copy_to_bap( hw, fid, sizeof(txdesc) + sizeof(p80211hdr), (UINT8*)p, s );
697: if ( result ) return; /* fail */
698:
699: /* Issue Tx command */
700: result = hfa384x_docmd_wait(hw, HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_TX), fid, 0, 0);
701: if ( result != 0 ) {
702: printf("hfa384x: Transmit failed with result %#hx.\n", result);
703: return;
704: }
705:
706: /* Wait for transmit completion (or exception) */
707: result = hfa384x_wait_for_event(hw, HFA384x_EVSTAT_TXEXC | HFA384x_EVSTAT_TX, HFA384x_EVACK_INFO,
708: 200, 500, "Tx to complete\n" );
709: if ( !result ) return; /* timeout failure */
710: if ( HFA384x_EVSTAT_ISTXEXC(result) ) {
711: fid = hfa384x_getreg(hw, HFA384x_TXCOMPLFID);
712: printf ( "Tx exception occurred with fid %#hx\n", fid );
713: result = hfa384x_copy_from_bap(hw, fid, 0, &status, sizeof(status));
714: if ( result ) return; /* fail */
715: printf("hfa384x: Tx error occurred (status %#hx):\n", status);
716: if ( HFA384x_TXSTATUS_ISACKERR(status) ) { printf(" ...acknowledgement error\n"); }
717: if ( HFA384x_TXSTATUS_ISFORMERR(status) ) { printf(" ...format error\n"); }
718: if ( HFA384x_TXSTATUS_ISDISCON(status) ) { printf(" ...disconnected error\n"); }
719: if ( HFA384x_TXSTATUS_ISAGEDERR(status) ) { printf(" ...AGED error\n"); }
720: if ( HFA384x_TXSTATUS_ISRETRYERR(status) ) { printf(" ...retry error\n"); }
721: return; /* fail */
722: }
723: }
724:
725: /**************************************************************************
726: DISABLE - Turn off ethernet interface
727: ***************************************************************************/
728: static void prism2_disable ( struct nic *nic __unused ) {
729: /* put the card in its initial state */
730: }
731:
732: /**************************************************************************
733: IRQ - Enable, Disable, or Force interrupts
734: ***************************************************************************/
735: static void prism2_irq(struct nic *nic __unused, irq_action_t action __unused)
736: {
737: switch ( action ) {
738: case DISABLE :
739: break;
740: case ENABLE :
741: break;
742: case FORCE :
743: break;
744: }
745: }
746:
747: /**************************************************************************
748: Operations table
749: ***************************************************************************/
750: static struct nic_operations prism2_operations = {
751: .connect = dummy_connect,
752: .poll = prism2_poll,
753: .transmit = prism2_transmit,
754: .irq = prism2_irq,
755: };
756:
757: /**************************************************************************
758: PROBE - Look for an adapter, this routine's visible to the outside
759: You should omit the last argument struct pci_device * for a non-PCI NIC
760: ***************************************************************************/
761: static int prism2_probe ( struct nic *nic, hfa384x_t *hw ) {
762: int result;
763: UINT16 tmp16 = 0;
764: UINT16 infofid;
765: hfa384x_InfFrame_t inf;
766: char ssid[HFA384x_RID_CNFDESIREDSSID_LEN];
767: int info_count = 0;
768:
769: nic->irqno = 0;
770:
771: /* Initialize card */
772: result = hfa384x_docmd_wait(hw, HFA384x_CMDCODE_INIT, 0,0,0); /* Send initialize command */
773: if ( result ) printf ( "Initialize command returned %#hx\n", result );
774: hfa384x_setreg(hw, 0, HFA384x_INTEN); /* Disable interrupts */
775: hfa384x_setreg(hw, 0xffff, HFA384x_EVACK); /* Acknowledge any spurious events */
776:
777: DBG ( "MAC address %s\n", eth_ntoa ( nic->node_addr ) );
778:
779: /* Retrieve MAC address (and fill out nic->node_addr) */
780: hfa384x_drvr_getconfig ( hw, HFA384x_RID_CNFOWNMACADDR, nic->node_addr, HFA384x_RID_CNFOWNMACADDR_LEN );
781:
782: /* Prepare card for autojoin */
783: /* This procedure is reverse-engineered from a register-level trace of the Linux driver's join process */
784: tmp16 = WLAN_DATA_MAXLEN; /* Set maximum data length */
785: result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFMAXDATALEN, &tmp16);
786: if ( result ) printf ( "Set Max Data Length command returned %#hx\n", result );
787: tmp16 = 0x000f; /* Set transmit rate(?) */
788: result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_TXRATECNTL, &tmp16);
789: if ( result ) printf ( "Set Transmit Rate command returned %#hx\n", result );
790: tmp16 = HFA384x_CNFAUTHENTICATION_OPENSYSTEM; /* Set authentication type to OpenSystem */
791: result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFAUTHENTICATION, &tmp16);
792: if ( result ) printf ( "Set Authentication Type command returned %#hx\n", result );
793: /* Set SSID */
794: memset(ssid, 0, HFA384x_RID_CNFDESIREDSSID_LEN);
795: for ( tmp16=0; tmp16<sizeof(hardcoded_ssid); tmp16++ ) { ssid[2+tmp16] = hardcoded_ssid[tmp16]; }
796: ssid[0] = sizeof(hardcoded_ssid) - 1; /* Ignore terminating zero */
797: result = hfa384x_drvr_setconfig(hw, HFA384x_RID_CNFDESIREDSSID, ssid, HFA384x_RID_CNFDESIREDSSID_LEN); /* Set the SSID */
798: if ( result ) printf ( "Set SSID command returned %#hx\n", result );
799: tmp16 = 1; /* Set port type to ESS port */
800: result = hfa384x_drvr_setconfig16(hw, HFA384x_RID_CNFPORTTYPE, &tmp16);
801: if ( result ) printf ( "Set port type command returned %#hx\n", result );
802: /* Enable card */
803: result = hfa384x_docmd_wait(hw, HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_ENABLE) | HFA384x_CMD_MACPORT_SET(0), 0,0,0);
804: if ( result ) printf ( "Enable command returned %#hx\n", result );
805:
806: do {
807: /* Increment info_count, abort if too many attempts.
808: * See comment next to definition of MAX_JOIN_INFO_COUNT for explanation.
809: */
810: info_count++;
811: if ( info_count > MAX_JOIN_INFO_COUNT ) {
812: printf ( "Too many failed attempts - aborting\n" );
813: return 0;
814: }
815:
816: /* Wait for info frame to indicate link status */
817: if ( sizeof(hardcoded_ssid) == 1 ) {
818: /* Empty SSID => join to any SSID */
819: printf ( "Attempting to autojoin to any available access point (attempt %d)...", info_count );
820: } else {
821: printf ( "Attempting to autojoin to SSID %s (attempt %d)...", &ssid[2], info_count );
822: }
823:
824: if ( !hfa384x_wait_for_event(hw, HFA384x_EVSTAT_INFO, 0, 1000, 2000, "Info event" ) ) return 0;
825: printf("done\n");
826: infofid = hfa384x_getreg(hw, HFA384x_INFOFID);
827: /* Retrieve the length */
828: result = hfa384x_copy_from_bap( hw, infofid, 0, &inf.framelen, sizeof(UINT16));
829: if ( result ) return 0; /* fail */
830: inf.framelen = hfa384x2host_16(inf.framelen);
831: /* Retrieve the rest */
832: result = hfa384x_copy_from_bap( hw, infofid, sizeof(UINT16),
833: &(inf.infotype), inf.framelen * sizeof(UINT16));
834: if ( result ) return 0; /* fail */
835: if ( inf.infotype != HFA384x_IT_LINKSTATUS ) {
836: /* Not a Link Status info frame: die */
837: printf ( "Unexpected info frame type %#hx (not LinkStatus type)\n", inf.infotype );
838: return 0;
839: }
840: inf.info.linkstatus.linkstatus = hfa384x2host_16(inf.info.linkstatus.linkstatus);
841: if ( inf.info.linkstatus.linkstatus != HFA384x_LINK_CONNECTED ) {
842: /* Link not connected - retry */
843: printf ( "Link not connected (status %#hx)\n", inf.info.linkstatus.linkstatus );
844: }
845: } while ( inf.info.linkstatus.linkstatus != HFA384x_LINK_CONNECTED );
846:
847: /* Retrieve BSSID and print Connected message */
848: result = hfa384x_drvr_getconfig(hw, HFA384x_RID_CURRENTBSSID, hw->bssid, WLAN_BSSID_LEN);
849:
850: DBG ( "Link connected (BSSID %s - ", eth_ntoa ( hw->bssid ) );
851: DBG ( " MAC address %s)\n", eth_ntoa (nic->node_addr ) );
852:
853: /* point to NIC specific routines */
854: nic->nic_op = &prism2_operations;
855: return 1;
856: }
857:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.