Merge by Hand
[linux-2.6] / drivers / net / wireless / hermes.c
1 /* hermes.c
2  *
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
6  * Prism II chipsets.
7  *
8  * This is not a complete driver, just low-level access routines for
9  * the MAC controller itself.
10  *
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
14  * particular order).
15  *
16  * Copyright (C) 2000, David Gibson, Linuxcare Australia.
17  * (C) Copyright David Gibson, IBM Corp. 2001-2003.
18  * 
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/
23  *
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.
28  *
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.
39  */
40
41 #include <linux/config.h>
42 #include <linux/module.h>
43 #include <linux/kernel.h>
44 #include <linux/init.h>
45 #include <linux/delay.h>
46
47 #include "hermes.h"
48
49 MODULE_DESCRIPTION("Low-level driver helper for Lucent Hermes chipset and Prism II HFA384x wireless MAC controller");
50 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>"
51         " & David Gibson <hermes@gibson.dropbear.id.au>");
52 MODULE_LICENSE("Dual MPL/GPL");
53
54 /* These are maximum timeouts. Most often, card wil react much faster */
55 #define CMD_BUSY_TIMEOUT (100) /* In iterations of ~1us */
56 #define CMD_INIT_TIMEOUT (50000) /* in iterations of ~10us */
57 #define CMD_COMPL_TIMEOUT (20000) /* in iterations of ~10us */
58 #define ALLOC_COMPL_TIMEOUT (1000) /* in iterations of ~10us */
59
60 /*
61  * Debugging helpers
62  */
63
64 #define DMSG(stuff...) do {printk(KERN_DEBUG "hermes @ %p: " , hw->iobase); \
65                         printk(stuff);} while (0)
66
67 #undef HERMES_DEBUG
68 #ifdef HERMES_DEBUG
69 #include <stdarg.h>
70
71 #define DEBUG(lvl, stuff...) if ( (lvl) <= HERMES_DEBUG) DMSG(stuff)
72
73 #else /* ! HERMES_DEBUG */
74
75 #define DEBUG(lvl, stuff...) do { } while (0)
76
77 #endif /* ! HERMES_DEBUG */
78
79
80 /*
81  * Internal functions
82  */
83
84 /* Issue a command to the chip. Waiting for it to complete is the caller's
85    problem.
86
87    Returns -EBUSY if the command register is busy, 0 on success.
88
89    Callable from any context.
90 */
91 static int hermes_issue_cmd(hermes_t *hw, u16 cmd, u16 param0)
92 {
93         int k = CMD_BUSY_TIMEOUT;
94         u16 reg;
95
96         /* First wait for the command register to unbusy */
97         reg = hermes_read_regn(hw, CMD);
98         while ( (reg & HERMES_CMD_BUSY) && k ) {
99                 k--;
100                 udelay(1);
101                 reg = hermes_read_regn(hw, CMD);
102         }
103         if (reg & HERMES_CMD_BUSY) {
104                 return -EBUSY;
105         }
106
107         hermes_write_regn(hw, PARAM2, 0);
108         hermes_write_regn(hw, PARAM1, 0);
109         hermes_write_regn(hw, PARAM0, param0);
110         hermes_write_regn(hw, CMD, cmd);
111         
112         return 0;
113 }
114
115 /*
116  * Function definitions
117  */
118
119 void hermes_struct_init(hermes_t *hw, void __iomem *address, int reg_spacing)
120 {
121         hw->iobase = address;
122         hw->reg_spacing = reg_spacing;
123         hw->inten = 0x0;
124
125 #ifdef HERMES_DEBUG_BUFFER
126         hw->dbufp = 0;
127         memset(&hw->dbuf, 0xff, sizeof(hw->dbuf));
128         memset(&hw->profile, 0, sizeof(hw->profile));
129 #endif
130 }
131
132 int hermes_init(hermes_t *hw)
133 {
134         u16 status, reg;
135         int err = 0;
136         int k;
137
138         /* We don't want to be interrupted while resetting the chipset */
139         hw->inten = 0x0;
140         hermes_write_regn(hw, INTEN, 0);
141         hermes_write_regn(hw, EVACK, 0xffff);
142
143         /* Normally it's a "can't happen" for the command register to
144            be busy when we go to issue a command because we are
145            serializing all commands.  However we want to have some
146            chance of resetting the card even if it gets into a stupid
147            state, so we actually wait to see if the command register
148            will unbusy itself here. */
149         k = CMD_BUSY_TIMEOUT;
150         reg = hermes_read_regn(hw, CMD);
151         while (k && (reg & HERMES_CMD_BUSY)) {
152                 if (reg == 0xffff) /* Special case - the card has probably been removed,
153                                       so don't wait for the timeout */
154                         return -ENODEV;
155
156                 k--;
157                 udelay(1);
158                 reg = hermes_read_regn(hw, CMD);
159         }
160         
161         /* No need to explicitly handle the timeout - if we've timed
162            out hermes_issue_cmd() will probably return -EBUSY below */
163
164         /* According to the documentation, EVSTAT may contain
165            obsolete event occurrence information.  We have to acknowledge
166            it by writing EVACK. */
167         reg = hermes_read_regn(hw, EVSTAT);
168         hermes_write_regn(hw, EVACK, reg);
169
170         /* We don't use hermes_docmd_wait here, because the reset wipes
171            the magic constant in SWSUPPORT0 away, and it gets confused */
172         err = hermes_issue_cmd(hw, HERMES_CMD_INIT, 0);
173         if (err)
174                 return err;
175
176         reg = hermes_read_regn(hw, EVSTAT);
177         k = CMD_INIT_TIMEOUT;
178         while ( (! (reg & HERMES_EV_CMD)) && k) {
179                 k--;
180                 udelay(10);
181                 reg = hermes_read_regn(hw, EVSTAT);
182         }
183
184         hermes_write_regn(hw, SWSUPPORT0, HERMES_MAGIC);
185
186         if (! hermes_present(hw)) {
187                 DEBUG(0, "hermes @ 0x%x: Card removed during reset.\n",
188                        hw->iobase);
189                 err = -ENODEV;
190                 goto out;
191         }
192                 
193         if (! (reg & HERMES_EV_CMD)) {
194                 printk(KERN_ERR "hermes @ %p: " 
195                        "Timeout waiting for card to reset (reg=0x%04x)!\n",
196                        hw->iobase, reg);
197                 err = -ETIMEDOUT;
198                 goto out;
199         }
200
201         status = hermes_read_regn(hw, STATUS);
202
203         hermes_write_regn(hw, EVACK, HERMES_EV_CMD);
204
205         if (status & HERMES_STATUS_RESULT)
206                 err = -EIO;
207
208  out:
209         return err;
210 }
211
212 /* Issue a command to the chip, and (busy!) wait for it to
213  * complete.
214  *
215  * Returns: < 0 on internal error, 0 on success, > 0 on error returned by the firmware
216  *
217  * Callable from any context, but locking is your problem. */
218 int hermes_docmd_wait(hermes_t *hw, u16 cmd, u16 parm0,
219                       struct hermes_response *resp)
220 {
221         int err;
222         int k;
223         u16 reg;
224         u16 status;
225
226         err = hermes_issue_cmd(hw, cmd, parm0);
227         if (err) {
228                 if (! hermes_present(hw)) {
229                         if (net_ratelimit())
230                                 printk(KERN_WARNING "hermes @ %p: "
231                                        "Card removed while issuing command "
232                                        "0x%04x.\n", hw->iobase, cmd);
233                         err = -ENODEV;
234                 } else 
235                         if (net_ratelimit())
236                                 printk(KERN_ERR "hermes @ %p: "
237                                        "Error %d issuing command 0x%04x.\n",
238                                        hw->iobase, err, cmd);
239                 goto out;
240         }
241
242         reg = hermes_read_regn(hw, EVSTAT);
243         k = CMD_COMPL_TIMEOUT;
244         while ( (! (reg & HERMES_EV_CMD)) && k) {
245                 k--;
246                 udelay(10);
247                 reg = hermes_read_regn(hw, EVSTAT);
248         }
249
250         if (! hermes_present(hw)) {
251                 printk(KERN_WARNING "hermes @ %p: Card removed "
252                        "while waiting for command 0x%04x completion.\n",
253                        hw->iobase, cmd);
254                 err = -ENODEV;
255                 goto out;
256         }
257                 
258         if (! (reg & HERMES_EV_CMD)) {
259                 printk(KERN_ERR "hermes @ %p: Timeout waiting for "
260                        "command 0x%04x completion.\n", hw->iobase, cmd);
261                 err = -ETIMEDOUT;
262                 goto out;
263         }
264
265         status = hermes_read_regn(hw, STATUS);
266         if (resp) {
267                 resp->status = status;
268                 resp->resp0 = hermes_read_regn(hw, RESP0);
269                 resp->resp1 = hermes_read_regn(hw, RESP1);
270                 resp->resp2 = hermes_read_regn(hw, RESP2);
271         }
272
273         hermes_write_regn(hw, EVACK, HERMES_EV_CMD);
274
275         if (status & HERMES_STATUS_RESULT)
276                 err = -EIO;
277
278  out:
279         return err;
280 }
281
282 int hermes_allocate(hermes_t *hw, u16 size, u16 *fid)
283 {
284         int err = 0;
285         int k;
286         u16 reg;
287         
288         if ( (size < HERMES_ALLOC_LEN_MIN) || (size > HERMES_ALLOC_LEN_MAX) )
289                 return -EINVAL;
290
291         err = hermes_docmd_wait(hw, HERMES_CMD_ALLOC, size, NULL);
292         if (err) {
293                 return err;
294         }
295
296         reg = hermes_read_regn(hw, EVSTAT);
297         k = ALLOC_COMPL_TIMEOUT;
298         while ( (! (reg & HERMES_EV_ALLOC)) && k) {
299                 k--;
300                 udelay(10);
301                 reg = hermes_read_regn(hw, EVSTAT);
302         }
303         
304         if (! hermes_present(hw)) {
305                 printk(KERN_WARNING "hermes @ %p: "
306                        "Card removed waiting for frame allocation.\n",
307                        hw->iobase);
308                 return -ENODEV;
309         }
310                 
311         if (! (reg & HERMES_EV_ALLOC)) {
312                 printk(KERN_ERR "hermes @ %p: "
313                        "Timeout waiting for frame allocation\n",
314                        hw->iobase);
315                 return -ETIMEDOUT;
316         }
317
318         *fid = hermes_read_regn(hw, ALLOCFID);
319         hermes_write_regn(hw, EVACK, HERMES_EV_ALLOC);
320         
321         return 0;
322 }
323
324
325 /* Set up a BAP to read a particular chunk of data from card's internal buffer.
326  *
327  * Returns: < 0 on internal failure (errno), 0 on success, >0 on error
328  * from firmware
329  *
330  * Callable from any context */
331 static int hermes_bap_seek(hermes_t *hw, int bap, u16 id, u16 offset)
332 {
333         int sreg = bap ? HERMES_SELECT1 : HERMES_SELECT0;
334         int oreg = bap ? HERMES_OFFSET1 : HERMES_OFFSET0;
335         int k;
336         u16 reg;
337
338         /* Paranoia.. */
339         if ( (offset > HERMES_BAP_OFFSET_MAX) || (offset % 2) )
340                 return -EINVAL;
341
342         k = HERMES_BAP_BUSY_TIMEOUT;
343         reg = hermes_read_reg(hw, oreg);
344         while ((reg & HERMES_OFFSET_BUSY) && k) {
345                 k--;
346                 udelay(1);
347                 reg = hermes_read_reg(hw, oreg);
348         }
349
350 #ifdef HERMES_DEBUG_BUFFER
351         hw->profile[HERMES_BAP_BUSY_TIMEOUT - k]++;
352
353         if (k < HERMES_BAP_BUSY_TIMEOUT) {
354                 struct hermes_debug_entry *e = 
355                         &hw->dbuf[(hw->dbufp++) % HERMES_DEBUG_BUFSIZE];
356                 e->bap = bap;
357                 e->id = id;
358                 e->offset = offset;
359                 e->cycles = HERMES_BAP_BUSY_TIMEOUT - k;
360         }
361 #endif
362
363         if (reg & HERMES_OFFSET_BUSY)
364                 return -ETIMEDOUT;
365
366         /* Now we actually set up the transfer */
367         hermes_write_reg(hw, sreg, id);
368         hermes_write_reg(hw, oreg, offset);
369
370         /* Wait for the BAP to be ready */
371         k = HERMES_BAP_BUSY_TIMEOUT;
372         reg = hermes_read_reg(hw, oreg);
373         while ( (reg & (HERMES_OFFSET_BUSY | HERMES_OFFSET_ERR)) && k) {
374                 k--;
375                 udelay(1);
376                 reg = hermes_read_reg(hw, oreg);
377         }
378
379         if (reg != offset) {
380                 printk(KERN_ERR "hermes @ %p: BAP%d offset %s: "
381                        "reg=0x%x id=0x%x offset=0x%x\n", hw->iobase, bap,
382                        (reg & HERMES_OFFSET_BUSY) ? "timeout" : "error",
383                        reg, id, offset);
384
385                 if (reg & HERMES_OFFSET_BUSY) {
386                         return -ETIMEDOUT;
387                 }
388
389                 return -EIO;            /* error or wrong offset */
390         }
391
392         return 0;
393 }
394
395 /* Read a block of data from the chip's buffer, via the
396  * BAP. Synchronization/serialization is the caller's problem.  len
397  * must be even.
398  *
399  * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
400  */
401 int hermes_bap_pread(hermes_t *hw, int bap, void *buf, unsigned len,
402                      u16 id, u16 offset)
403 {
404         int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
405         int err = 0;
406
407         if ( (len < 0) || (len % 2) )
408                 return -EINVAL;
409
410         err = hermes_bap_seek(hw, bap, id, offset);
411         if (err)
412                 goto out;
413
414         /* Actually do the transfer */
415         hermes_read_words(hw, dreg, buf, len/2);
416
417  out:
418         return err;
419 }
420
421 /* Write a block of data to the chip's buffer, via the
422  * BAP. Synchronization/serialization is the caller's problem. len
423  * must be even.
424  *
425  * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
426  */
427 int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, unsigned len,
428                       u16 id, u16 offset)
429 {
430         int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
431         int err = 0;
432
433         if ( (len < 0) || (len % 2) )
434                 return -EINVAL;
435
436         err = hermes_bap_seek(hw, bap, id, offset);
437         if (err)
438                 goto out;
439         
440         /* Actually do the transfer */
441         hermes_write_words(hw, dreg, buf, len/2);
442
443  out:   
444         return err;
445 }
446
447 /* Write a block of data to the chip's buffer with padding if
448  * neccessary, via the BAP. Synchronization/serialization is the
449  * caller's problem. len must be even.
450  *
451  * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
452  */
453 int hermes_bap_pwrite_pad(hermes_t *hw, int bap, const void *buf, unsigned data_len, unsigned len,
454                       u16 id, u16 offset)
455 {
456         int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
457         int err = 0;
458
459         if (len < 0 || len % 2 || data_len > len)
460                 return -EINVAL;
461
462         err = hermes_bap_seek(hw, bap, id, offset);
463         if (err)
464                 goto out;
465
466         /* Transfer all the complete words of data */
467         hermes_write_words(hw, dreg, buf, data_len/2);
468         /* If there is an odd byte left over pad and transfer it */
469         if (data_len & 1) {
470                 u8 end[2];
471                 end[1] = 0;
472                 end[0] = ((unsigned char *)buf)[data_len - 1];
473                 hermes_write_words(hw, dreg, end, 1);
474                 data_len ++;
475         }
476         /* Now send zeros for the padding */
477         if (data_len < len)
478                 hermes_clear_words(hw, dreg, (len - data_len) / 2);
479         /* Complete */
480  out:
481         return err;
482 }
483
484 /* Read a Length-Type-Value record from the card.
485  *
486  * If length is NULL, we ignore the length read from the card, and
487  * read the entire buffer regardless. This is useful because some of
488  * the configuration records appear to have incorrect lengths in
489  * practice.
490  *
491  * Callable from user or bh context.  */
492 int hermes_read_ltv(hermes_t *hw, int bap, u16 rid, unsigned bufsize,
493                     u16 *length, void *buf)
494 {
495         int err = 0;
496         int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
497         u16 rlength, rtype;
498         unsigned nwords;
499
500         if ( (bufsize < 0) || (bufsize % 2) )
501                 return -EINVAL;
502
503         err = hermes_docmd_wait(hw, HERMES_CMD_ACCESS, rid, NULL);
504         if (err)
505                 return err;
506
507         err = hermes_bap_seek(hw, bap, rid, 0);
508         if (err)
509                 return err;
510
511         rlength = hermes_read_reg(hw, dreg);
512
513         if (! rlength)
514                 return -ENODATA;
515
516         rtype = hermes_read_reg(hw, dreg);
517
518         if (length)
519                 *length = rlength;
520
521         if (rtype != rid)
522                 printk(KERN_WARNING "hermes @ %p: %s(): "
523                        "rid (0x%04x) does not match type (0x%04x)\n",
524                        hw->iobase, __FUNCTION__, rid, rtype);
525         if (HERMES_RECLEN_TO_BYTES(rlength) > bufsize)
526                 printk(KERN_WARNING "hermes @ %p: "
527                        "Truncating LTV record from %d to %d bytes. "
528                        "(rid=0x%04x, len=0x%04x)\n", hw->iobase,
529                        HERMES_RECLEN_TO_BYTES(rlength), bufsize, rid, rlength);
530
531         nwords = min((unsigned)rlength - 1, bufsize / 2);
532         hermes_read_words(hw, dreg, buf, nwords);
533
534         return 0;
535 }
536
537 int hermes_write_ltv(hermes_t *hw, int bap, u16 rid, 
538                      u16 length, const void *value)
539 {
540         int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
541         int err = 0;
542         unsigned count;
543
544         if (length == 0)
545                 return -EINVAL;
546
547         err = hermes_bap_seek(hw, bap, rid, 0);
548         if (err)
549                 return err;
550
551         hermes_write_reg(hw, dreg, length);
552         hermes_write_reg(hw, dreg, rid);
553
554         count = length - 1;
555
556         hermes_write_words(hw, dreg, value, count);
557
558         err = hermes_docmd_wait(hw, HERMES_CMD_ACCESS | HERMES_CMD_WRITE, 
559                                 rid, NULL);
560
561         return err;
562 }
563
564 EXPORT_SYMBOL(hermes_struct_init);
565 EXPORT_SYMBOL(hermes_init);
566 EXPORT_SYMBOL(hermes_docmd_wait);
567 EXPORT_SYMBOL(hermes_allocate);
568
569 EXPORT_SYMBOL(hermes_bap_pread);
570 EXPORT_SYMBOL(hermes_bap_pwrite);
571 EXPORT_SYMBOL(hermes_bap_pwrite_pad);
572 EXPORT_SYMBOL(hermes_read_ltv);
573 EXPORT_SYMBOL(hermes_write_ltv);
574
575 static int __init init_hermes(void)
576 {
577         return 0;
578 }
579
580 static void __exit exit_hermes(void)
581 {
582 }
583
584 module_init(init_hermes);
585 module_exit(exit_hermes);