3 * Driver core for the "Hermes" wireless MAC controller, as used in
4 * the Lucent Orinoco and Cabletron RoamAbout cards. It should also
5 * work on the hfa3841 and hfa3842 MAC controller chips used in the
8 * This is not a complete driver, just low-level access routines for
9 * the MAC controller itself.
11 * Based on the prism2 driver from Absolute Value Systems' linux-wlan
12 * project, the Linux wvlan_cs driver, Lucent's HCF-Light
13 * (wvlan_hcf.c) library, and the NetBSD wireless driver (in no
16 * Copyright (C) 2000, David Gibson, Linuxcare Australia.
17 * (C) Copyright David Gibson, IBM Corp. 2001-2003.
19 * The contents of this file are subject to the Mozilla Public License
20 * Version 1.1 (the "License"); you may not use this file except in
21 * compliance with the License. You may obtain a copy of the License
22 * at http://www.mozilla.org/MPL/
24 * Software distributed under the License is distributed on an "AS IS"
25 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
26 * the License for the specific language governing rights and
27 * limitations under the License.
29 * Alternatively, the contents of this file may be used under the
30 * terms of the GNU General Public License version 2 (the "GPL"), in
31 * which case the provisions of the GPL are applicable instead of the
32 * above. If you wish to allow the use of your version of this file
33 * only under the terms of the GPL and not to allow others to use your
34 * version of this file under the MPL, indicate your decision by
35 * deleting the provisions above and replace them with the notice and
36 * other provisions required by the GPL. If you do not delete the
37 * provisions above, a recipient may use your version of this file
38 * under either the MPL or the GPL.
41 #include <linux/module.h>
42 #include <linux/kernel.h>
43 #include <linux/init.h>
44 #include <linux/delay.h>
48 MODULE_DESCRIPTION("Low-level driver helper for Lucent Hermes chipset and Prism II HFA384x wireless MAC controller");
49 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>"
50 " & David Gibson <hermes@gibson.dropbear.id.au>");
51 MODULE_LICENSE("Dual MPL/GPL");
53 /* These are maximum timeouts. Most often, card wil react much faster */
54 #define CMD_BUSY_TIMEOUT (100) /* In iterations of ~1us */
55 #define CMD_INIT_TIMEOUT (50000) /* in iterations of ~10us */
56 #define CMD_COMPL_TIMEOUT (20000) /* in iterations of ~10us */
57 #define ALLOC_COMPL_TIMEOUT (1000) /* in iterations of ~10us */
63 #define DMSG(stuff...) do {printk(KERN_DEBUG "hermes @ %p: " , hw->iobase); \
64 printk(stuff);} while (0)
70 #define DEBUG(lvl, stuff...) if ( (lvl) <= HERMES_DEBUG) DMSG(stuff)
72 #else /* ! HERMES_DEBUG */
74 #define DEBUG(lvl, stuff...) do { } while (0)
76 #endif /* ! HERMES_DEBUG */
83 /* Issue a command to the chip. Waiting for it to complete is the caller's
86 Returns -EBUSY if the command register is busy, 0 on success.
88 Callable from any context.
90 static int hermes_issue_cmd(hermes_t
*hw
, u16 cmd
, u16 param0
,
91 u16 param1
, u16 param2
)
93 int k
= CMD_BUSY_TIMEOUT
;
96 /* First wait for the command register to unbusy */
97 reg
= hermes_read_regn(hw
, CMD
);
98 while ( (reg
& HERMES_CMD_BUSY
) && k
) {
101 reg
= hermes_read_regn(hw
, CMD
);
103 if (reg
& HERMES_CMD_BUSY
) {
107 hermes_write_regn(hw
, PARAM2
, param2
);
108 hermes_write_regn(hw
, PARAM1
, param1
);
109 hermes_write_regn(hw
, PARAM0
, param0
);
110 hermes_write_regn(hw
, CMD
, cmd
);
116 * Function definitions
119 void hermes_struct_init(hermes_t
*hw
, void __iomem
*address
, int reg_spacing
)
121 hw
->iobase
= address
;
122 hw
->reg_spacing
= reg_spacing
;
126 int hermes_init(hermes_t
*hw
)
132 /* We don't want to be interrupted while resetting the chipset */
134 hermes_write_regn(hw
, INTEN
, 0);
135 hermes_write_regn(hw
, EVACK
, 0xffff);
137 /* Normally it's a "can't happen" for the command register to
138 be busy when we go to issue a command because we are
139 serializing all commands. However we want to have some
140 chance of resetting the card even if it gets into a stupid
141 state, so we actually wait to see if the command register
142 will unbusy itself here. */
143 k
= CMD_BUSY_TIMEOUT
;
144 reg
= hermes_read_regn(hw
, CMD
);
145 while (k
&& (reg
& HERMES_CMD_BUSY
)) {
146 if (reg
== 0xffff) /* Special case - the card has probably been removed,
147 so don't wait for the timeout */
152 reg
= hermes_read_regn(hw
, CMD
);
155 /* No need to explicitly handle the timeout - if we've timed
156 out hermes_issue_cmd() will probably return -EBUSY below */
158 /* According to the documentation, EVSTAT may contain
159 obsolete event occurrence information. We have to acknowledge
160 it by writing EVACK. */
161 reg
= hermes_read_regn(hw
, EVSTAT
);
162 hermes_write_regn(hw
, EVACK
, reg
);
164 /* We don't use hermes_docmd_wait here, because the reset wipes
165 the magic constant in SWSUPPORT0 away, and it gets confused */
166 err
= hermes_issue_cmd(hw
, HERMES_CMD_INIT
, 0, 0, 0);
170 reg
= hermes_read_regn(hw
, EVSTAT
);
171 k
= CMD_INIT_TIMEOUT
;
172 while ( (! (reg
& HERMES_EV_CMD
)) && k
) {
175 reg
= hermes_read_regn(hw
, EVSTAT
);
178 hermes_write_regn(hw
, SWSUPPORT0
, HERMES_MAGIC
);
180 if (! hermes_present(hw
)) {
181 DEBUG(0, "hermes @ 0x%x: Card removed during reset.\n",
187 if (! (reg
& HERMES_EV_CMD
)) {
188 printk(KERN_ERR
"hermes @ %p: "
189 "Timeout waiting for card to reset (reg=0x%04x)!\n",
195 status
= hermes_read_regn(hw
, STATUS
);
197 hermes_write_regn(hw
, EVACK
, HERMES_EV_CMD
);
199 if (status
& HERMES_STATUS_RESULT
)
206 /* Issue a command to the chip, and (busy!) wait for it to
209 * Returns: < 0 on internal error, 0 on success, > 0 on error returned by the firmware
211 * Callable from any context, but locking is your problem. */
212 int hermes_docmd_wait(hermes_t
*hw
, u16 cmd
, u16 parm0
,
213 struct hermes_response
*resp
)
220 err
= hermes_issue_cmd(hw
, cmd
, parm0
, 0, 0);
222 if (! hermes_present(hw
)) {
224 printk(KERN_WARNING
"hermes @ %p: "
225 "Card removed while issuing command "
226 "0x%04x.\n", hw
->iobase
, cmd
);
230 printk(KERN_ERR
"hermes @ %p: "
231 "Error %d issuing command 0x%04x.\n",
232 hw
->iobase
, err
, cmd
);
236 reg
= hermes_read_regn(hw
, EVSTAT
);
237 k
= CMD_COMPL_TIMEOUT
;
238 while ( (! (reg
& HERMES_EV_CMD
)) && k
) {
241 reg
= hermes_read_regn(hw
, EVSTAT
);
244 if (! hermes_present(hw
)) {
245 printk(KERN_WARNING
"hermes @ %p: Card removed "
246 "while waiting for command 0x%04x completion.\n",
252 if (! (reg
& HERMES_EV_CMD
)) {
253 printk(KERN_ERR
"hermes @ %p: Timeout waiting for "
254 "command 0x%04x completion.\n", hw
->iobase
, cmd
);
259 status
= hermes_read_regn(hw
, STATUS
);
261 resp
->status
= status
;
262 resp
->resp0
= hermes_read_regn(hw
, RESP0
);
263 resp
->resp1
= hermes_read_regn(hw
, RESP1
);
264 resp
->resp2
= hermes_read_regn(hw
, RESP2
);
267 hermes_write_regn(hw
, EVACK
, HERMES_EV_CMD
);
269 if (status
& HERMES_STATUS_RESULT
)
276 int hermes_allocate(hermes_t
*hw
, u16 size
, u16
*fid
)
282 if ( (size
< HERMES_ALLOC_LEN_MIN
) || (size
> HERMES_ALLOC_LEN_MAX
) )
285 err
= hermes_docmd_wait(hw
, HERMES_CMD_ALLOC
, size
, NULL
);
290 reg
= hermes_read_regn(hw
, EVSTAT
);
291 k
= ALLOC_COMPL_TIMEOUT
;
292 while ( (! (reg
& HERMES_EV_ALLOC
)) && k
) {
295 reg
= hermes_read_regn(hw
, EVSTAT
);
298 if (! hermes_present(hw
)) {
299 printk(KERN_WARNING
"hermes @ %p: "
300 "Card removed waiting for frame allocation.\n",
305 if (! (reg
& HERMES_EV_ALLOC
)) {
306 printk(KERN_ERR
"hermes @ %p: "
307 "Timeout waiting for frame allocation\n",
312 *fid
= hermes_read_regn(hw
, ALLOCFID
);
313 hermes_write_regn(hw
, EVACK
, HERMES_EV_ALLOC
);
319 /* Set up a BAP to read a particular chunk of data from card's internal buffer.
321 * Returns: < 0 on internal failure (errno), 0 on success, >0 on error
324 * Callable from any context */
325 static int hermes_bap_seek(hermes_t
*hw
, int bap
, u16 id
, u16 offset
)
327 int sreg
= bap
? HERMES_SELECT1
: HERMES_SELECT0
;
328 int oreg
= bap
? HERMES_OFFSET1
: HERMES_OFFSET0
;
333 if ( (offset
> HERMES_BAP_OFFSET_MAX
) || (offset
% 2) )
336 k
= HERMES_BAP_BUSY_TIMEOUT
;
337 reg
= hermes_read_reg(hw
, oreg
);
338 while ((reg
& HERMES_OFFSET_BUSY
) && k
) {
341 reg
= hermes_read_reg(hw
, oreg
);
344 if (reg
& HERMES_OFFSET_BUSY
)
347 /* Now we actually set up the transfer */
348 hermes_write_reg(hw
, sreg
, id
);
349 hermes_write_reg(hw
, oreg
, offset
);
351 /* Wait for the BAP to be ready */
352 k
= HERMES_BAP_BUSY_TIMEOUT
;
353 reg
= hermes_read_reg(hw
, oreg
);
354 while ( (reg
& (HERMES_OFFSET_BUSY
| HERMES_OFFSET_ERR
)) && k
) {
357 reg
= hermes_read_reg(hw
, oreg
);
361 printk(KERN_ERR
"hermes @ %p: BAP%d offset %s: "
362 "reg=0x%x id=0x%x offset=0x%x\n", hw
->iobase
, bap
,
363 (reg
& HERMES_OFFSET_BUSY
) ? "timeout" : "error",
366 if (reg
& HERMES_OFFSET_BUSY
) {
370 return -EIO
; /* error or wrong offset */
376 /* Read a block of data from the chip's buffer, via the
377 * BAP. Synchronization/serialization is the caller's problem. len
380 * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
382 int hermes_bap_pread(hermes_t
*hw
, int bap
, void *buf
, int len
,
385 int dreg
= bap
? HERMES_DATA1
: HERMES_DATA0
;
388 if ( (len
< 0) || (len
% 2) )
391 err
= hermes_bap_seek(hw
, bap
, id
, offset
);
395 /* Actually do the transfer */
396 hermes_read_words(hw
, dreg
, buf
, len
/2);
402 /* Write a block of data to the chip's buffer, via the
403 * BAP. Synchronization/serialization is the caller's problem.
405 * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
407 int hermes_bap_pwrite(hermes_t
*hw
, int bap
, const void *buf
, int len
,
410 int dreg
= bap
? HERMES_DATA1
: HERMES_DATA0
;
416 err
= hermes_bap_seek(hw
, bap
, id
, offset
);
420 /* Actually do the transfer */
421 hermes_write_bytes(hw
, dreg
, buf
, len
);
427 /* Read a Length-Type-Value record from the card.
429 * If length is NULL, we ignore the length read from the card, and
430 * read the entire buffer regardless. This is useful because some of
431 * the configuration records appear to have incorrect lengths in
434 * Callable from user or bh context. */
435 int hermes_read_ltv(hermes_t
*hw
, int bap
, u16 rid
, unsigned bufsize
,
436 u16
*length
, void *buf
)
439 int dreg
= bap
? HERMES_DATA1
: HERMES_DATA0
;
443 if ( (bufsize
< 0) || (bufsize
% 2) )
446 err
= hermes_docmd_wait(hw
, HERMES_CMD_ACCESS
, rid
, NULL
);
450 err
= hermes_bap_seek(hw
, bap
, rid
, 0);
454 rlength
= hermes_read_reg(hw
, dreg
);
459 rtype
= hermes_read_reg(hw
, dreg
);
465 printk(KERN_WARNING
"hermes @ %p: %s(): "
466 "rid (0x%04x) does not match type (0x%04x)\n",
467 hw
->iobase
, __func__
, rid
, rtype
);
468 if (HERMES_RECLEN_TO_BYTES(rlength
) > bufsize
)
469 printk(KERN_WARNING
"hermes @ %p: "
470 "Truncating LTV record from %d to %d bytes. "
471 "(rid=0x%04x, len=0x%04x)\n", hw
->iobase
,
472 HERMES_RECLEN_TO_BYTES(rlength
), bufsize
, rid
, rlength
);
474 nwords
= min((unsigned)rlength
- 1, bufsize
/ 2);
475 hermes_read_words(hw
, dreg
, buf
, nwords
);
480 int hermes_write_ltv(hermes_t
*hw
, int bap
, u16 rid
,
481 u16 length
, const void *value
)
483 int dreg
= bap
? HERMES_DATA1
: HERMES_DATA0
;
490 err
= hermes_bap_seek(hw
, bap
, rid
, 0);
494 hermes_write_reg(hw
, dreg
, length
);
495 hermes_write_reg(hw
, dreg
, rid
);
499 hermes_write_bytes(hw
, dreg
, value
, count
<< 1);
501 err
= hermes_docmd_wait(hw
, HERMES_CMD_ACCESS
| HERMES_CMD_WRITE
,
507 EXPORT_SYMBOL(hermes_struct_init
);
508 EXPORT_SYMBOL(hermes_init
);
509 EXPORT_SYMBOL(hermes_docmd_wait
);
510 EXPORT_SYMBOL(hermes_allocate
);
512 EXPORT_SYMBOL(hermes_bap_pread
);
513 EXPORT_SYMBOL(hermes_bap_pwrite
);
514 EXPORT_SYMBOL(hermes_read_ltv
);
515 EXPORT_SYMBOL(hermes_write_ltv
);
517 static int __init
init_hermes(void)
522 static void __exit
exit_hermes(void)
526 module_init(init_hermes
);
527 module_exit(exit_hermes
);
This page took 0.04133 seconds and 5 git commands to generate.