?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] zd1211rw: Generic HMAC initialization
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / wireless / zd1211rw / zd_chip.c
blobcc5151683fa13c2df238f31fe4274190ad216849
1 /* zd_chip.c
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18 /* This file implements all the hardware specific functions for the ZD1211
19 * and ZD1211B chips. Support for the ZD1211B was possible after Timothy
20 * Legge sent me a ZD1211B device. Thank you Tim. -- Uli
21 */
22
23 #include <linux/kernel.h>
24 #include <linux/errno.h>
25
26 #include "zd_def.h"
27 #include "zd_chip.h"
28 #include "zd_ieee80211.h"
29 #include "zd_mac.h"
30 #include "zd_rf.h"
31 #include "zd_util.h"
32
33 void zd_chip_init(struct zd_chip *chip,
34 struct net_device *netdev,
35 struct usb_interface *intf)
36 {
37 memset(chip, 0, sizeof(*chip));
38 mutex_init(&chip->mutex);
39 zd_usb_init(&chip->usb, netdev, intf);
40 zd_rf_init(&chip->rf);
41 }
42
43 void zd_chip_clear(struct zd_chip *chip)
44 {
45 ZD_ASSERT(!mutex_is_locked(&chip->mutex));
46 zd_usb_clear(&chip->usb);
47 zd_rf_clear(&chip->rf);
48 mutex_destroy(&chip->mutex);
49 ZD_MEMCLEAR(chip, sizeof(*chip));
50 }
51
52 static int scnprint_mac_oui(const u8 *addr, char *buffer, size_t size)
53 {
54 return scnprintf(buffer, size, "%02x-%02x-%02x",
55 addr[0], addr[1], addr[2]);
56 }
57
58 /* Prints an identifier line, which will support debugging. */
59 static int scnprint_id(struct zd_chip *chip, char *buffer, size_t size)
60 {
61 int i = 0;
62
63 i = scnprintf(buffer, size, "zd1211%s chip ",
64 chip->is_zd1211b ? "b" : "");
65 i += zd_usb_scnprint_id(&chip->usb, buffer+i, size-i);
66 i += scnprintf(buffer+i, size-i, " ");
67 i += scnprint_mac_oui(chip->e2p_mac, buffer+i, size-i);
68 i += scnprintf(buffer+i, size-i, " ");
69 i += zd_rf_scnprint_id(&chip->rf, buffer+i, size-i);
70 i += scnprintf(buffer+i, size-i, " pa%1x %c%c%c%c", chip->pa_type,
71 chip->patch_cck_gain ? 'g' : '-',
72 chip->patch_cr157 ? '7' : '-',
73 chip->patch_6m_band_edge ? '6' : '-',
74 chip->new_phy_layout ? 'N' : '-');
75 return i;
76 }
77
78 static void print_id(struct zd_chip *chip)
79 {
80 char buffer[80];
81
82 scnprint_id(chip, buffer, sizeof(buffer));
83 buffer[sizeof(buffer)-1] = 0;
84 dev_info(zd_chip_dev(chip), "%s\n", buffer);
85 }
86
87 /* Read a variable number of 32-bit values. Parameter count is not allowed to
88 * exceed USB_MAX_IOREAD32_COUNT.
89 */
90 int zd_ioread32v_locked(struct zd_chip *chip, u32 *values, const zd_addr_t *addr,
91 unsigned int count)
92 {
93 int r;
94 int i;
95 zd_addr_t *a16 = (zd_addr_t *)NULL;
96 u16 *v16;
97 unsigned int count16;
98
99 if (count > USB_MAX_IOREAD32_COUNT)
100 return -EINVAL;
101
102 /* Allocate a single memory block for values and addresses. */
103 count16 = 2*count;
104 a16 = kmalloc(count16 * (sizeof(zd_addr_t) + sizeof(u16)),
105 GFP_NOFS);
106 if (!a16) {
107 dev_dbg_f(zd_chip_dev(chip),
108 "error ENOMEM in allocation of a16\n");
109 r = -ENOMEM;
110 goto out;
111 }
112 v16 = (u16 *)(a16 + count16);
113
114 for (i = 0; i < count; i++) {
115 int j = 2*i;
116 /* We read the high word always first. */
117 a16[j] = zd_inc_word(addr[i]);
118 a16[j+1] = addr[i];
119 }
120
121 r = zd_ioread16v_locked(chip, v16, a16, count16);
122 if (r) {
123 dev_dbg_f(zd_chip_dev(chip),
124 "error: zd_ioread16v_locked. Error number %d\n", r);
125 goto out;
126 }
127
128 for (i = 0; i < count; i++) {
129 int j = 2*i;
130 values[i] = (v16[j] << 16) | v16[j+1];
131 }
132
133 out:
134 kfree((void *)a16);
135 return r;
136 }
137
138 int _zd_iowrite32v_locked(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
139 unsigned int count)
140 {
141 int i, j, r;
142 struct zd_ioreq16 *ioreqs16;
143 unsigned int count16;
144
145 ZD_ASSERT(mutex_is_locked(&chip->mutex));
146
147 if (count == 0)
148 return 0;
149 if (count > USB_MAX_IOWRITE32_COUNT)
150 return -EINVAL;
151
152 /* Allocate a single memory block for values and addresses. */
153 count16 = 2*count;
154 ioreqs16 = kmalloc(count16 * sizeof(struct zd_ioreq16), GFP_NOFS);
155 if (!ioreqs16) {
156 r = -ENOMEM;
157 dev_dbg_f(zd_chip_dev(chip),
158 "error %d in ioreqs16 allocation\n", r);
159 goto out;
160 }
161
162 for (i = 0; i < count; i++) {
163 j = 2*i;
164 /* We write the high word always first. */
165 ioreqs16[j].value = ioreqs[i].value >> 16;
166 ioreqs16[j].addr = zd_inc_word(ioreqs[i].addr);
167 ioreqs16[j+1].value = ioreqs[i].value;
168 ioreqs16[j+1].addr = ioreqs[i].addr;
169 }
170
171 r = zd_usb_iowrite16v(&chip->usb, ioreqs16, count16);
172 #ifdef DEBUG
173 if (r) {
174 dev_dbg_f(zd_chip_dev(chip),
175 "error %d in zd_usb_write16v\n", r);
176 }
177 #endif /* DEBUG */
178 out:
179 kfree(ioreqs16);
180 return r;
181 }
182
183 int zd_iowrite16a_locked(struct zd_chip *chip,
184 const struct zd_ioreq16 *ioreqs, unsigned int count)
185 {
186 int r;
187 unsigned int i, j, t, max;
188
189 ZD_ASSERT(mutex_is_locked(&chip->mutex));
190 for (i = 0; i < count; i += j + t) {
191 t = 0;
192 max = count-i;
193 if (max > USB_MAX_IOWRITE16_COUNT)
194 max = USB_MAX_IOWRITE16_COUNT;
195 for (j = 0; j < max; j++) {
196 if (!ioreqs[i+j].addr) {
197 t = 1;
198 break;
199 }
200 }
201
202 r = zd_usb_iowrite16v(&chip->usb, &ioreqs[i], j);
203 if (r) {
204 dev_dbg_f(zd_chip_dev(chip),
205 "error zd_usb_iowrite16v. Error number %d\n",
206 r);
207 return r;
208 }
209 }
210
211 return 0;
212 }
213
214 /* Writes a variable number of 32 bit registers. The functions will split
215 * that in several USB requests. A split can be forced by inserting an IO
216 * request with an zero address field.
217 */
218 int zd_iowrite32a_locked(struct zd_chip *chip,
219 const struct zd_ioreq32 *ioreqs, unsigned int count)
220 {
221 int r;
222 unsigned int i, j, t, max;
223
224 for (i = 0; i < count; i += j + t) {
225 t = 0;
226 max = count-i;
227 if (max > USB_MAX_IOWRITE32_COUNT)
228 max = USB_MAX_IOWRITE32_COUNT;
229 for (j = 0; j < max; j++) {
230 if (!ioreqs[i+j].addr) {
231 t = 1;
232 break;
233 }
234 }
235
236 r = _zd_iowrite32v_locked(chip, &ioreqs[i], j);
237 if (r) {
238 dev_dbg_f(zd_chip_dev(chip),
239 "error _zd_iowrite32v_locked."
240 " Error number %d\n", r);
241 return r;
242 }
243 }
244
245 return 0;
246 }
247
248 int zd_ioread16(struct zd_chip *chip, zd_addr_t addr, u16 *value)
249 {
250 int r;
251
252 mutex_lock(&chip->mutex);
253 r = zd_ioread16_locked(chip, value, addr);
254 mutex_unlock(&chip->mutex);
255 return r;
256 }
257
258 int zd_ioread32(struct zd_chip *chip, zd_addr_t addr, u32 *value)
259 {
260 int r;
261
262 mutex_lock(&chip->mutex);
263 r = zd_ioread32_locked(chip, value, addr);
264 mutex_unlock(&chip->mutex);
265 return r;
266 }
267
268 int zd_iowrite16(struct zd_chip *chip, zd_addr_t addr, u16 value)
269 {
270 int r;
271
272 mutex_lock(&chip->mutex);
273 r = zd_iowrite16_locked(chip, value, addr);
274 mutex_unlock(&chip->mutex);
275 return r;
276 }
277
278 int zd_iowrite32(struct zd_chip *chip, zd_addr_t addr, u32 value)
279 {
280 int r;
281
282 mutex_lock(&chip->mutex);
283 r = zd_iowrite32_locked(chip, value, addr);
284 mutex_unlock(&chip->mutex);
285 return r;
286 }
287
288 int zd_ioread32v(struct zd_chip *chip, const zd_addr_t *addresses,
289 u32 *values, unsigned int count)
290 {
291 int r;
292
293 mutex_lock(&chip->mutex);
294 r = zd_ioread32v_locked(chip, values, addresses, count);
295 mutex_unlock(&chip->mutex);
296 return r;
297 }
298
299 int zd_iowrite32a(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
300 unsigned int count)
301 {
302 int r;
303
304 mutex_lock(&chip->mutex);
305 r = zd_iowrite32a_locked(chip, ioreqs, count);
306 mutex_unlock(&chip->mutex);
307 return r;
308 }
309
310 static int read_pod(struct zd_chip *chip, u8 *rf_type)
311 {
312 int r;
313 u32 value;
314
315 ZD_ASSERT(mutex_is_locked(&chip->mutex));
316 r = zd_ioread32_locked(chip, &value, E2P_POD);
317 if (r)
318 goto error;
319 dev_dbg_f(zd_chip_dev(chip), "E2P_POD %#010x\n", value);
320
321 /* FIXME: AL2230 handling (Bit 7 in POD) */
322 *rf_type = value & 0x0f;
323 chip->pa_type = (value >> 16) & 0x0f;
324 chip->patch_cck_gain = (value >> 8) & 0x1;
325 chip->patch_cr157 = (value >> 13) & 0x1;
326 chip->patch_6m_band_edge = (value >> 21) & 0x1;
327 chip->new_phy_layout = (value >> 31) & 0x1;
328 chip->link_led = ((value >> 4) & 1) ? LED1 : LED2;
329 chip->supports_tx_led = 1;
330 if (value & (1 << 24)) { /* LED scenario */
331 if (value & (1 << 29))
332 chip->supports_tx_led = 0;
333 }
334
335 dev_dbg_f(zd_chip_dev(chip),
336 "RF %s %#01x PA type %#01x patch CCK %d patch CR157 %d "
337 "patch 6M %d new PHY %d link LED%d tx led %d\n",
338 zd_rf_name(*rf_type), *rf_type,
339 chip->pa_type, chip->patch_cck_gain,
340 chip->patch_cr157, chip->patch_6m_band_edge,
341 chip->new_phy_layout,
342 chip->link_led == LED1 ? 1 : 2,
343 chip->supports_tx_led);
344 return 0;
345 error:
346 *rf_type = 0;
347 chip->pa_type = 0;
348 chip->patch_cck_gain = 0;
349 chip->patch_cr157 = 0;
350 chip->patch_6m_band_edge = 0;
351 chip->new_phy_layout = 0;
352 return r;
353 }
354
355 static int _read_mac_addr(struct zd_chip *chip, u8 *mac_addr,
356 const zd_addr_t *addr)
357 {
358 int r;
359 u32 parts[2];
360
361 r = zd_ioread32v_locked(chip, parts, (const zd_addr_t *)addr, 2);
362 if (r) {
363 dev_dbg_f(zd_chip_dev(chip),
364 "error: couldn't read e2p macs. Error number %d\n", r);
365 return r;
366 }
367
368 mac_addr[0] = parts[0];
369 mac_addr[1] = parts[0] >> 8;
370 mac_addr[2] = parts[0] >> 16;
371 mac_addr[3] = parts[0] >> 24;
372 mac_addr[4] = parts[1];
373 mac_addr[5] = parts[1] >> 8;
374
375 return 0;
376 }
377
378 static int read_e2p_mac_addr(struct zd_chip *chip)
379 {
380 static const zd_addr_t addr[2] = { E2P_MAC_ADDR_P1, E2P_MAC_ADDR_P2 };
381
382 ZD_ASSERT(mutex_is_locked(&chip->mutex));
383 return _read_mac_addr(chip, chip->e2p_mac, (const zd_addr_t *)addr);
384 }
385
386 /* MAC address: if custom mac addresses are to to be used CR_MAC_ADDR_P1 and
387 * CR_MAC_ADDR_P2 must be overwritten
388 */
389 void zd_get_e2p_mac_addr(struct zd_chip *chip, u8 *mac_addr)
390 {
391 mutex_lock(&chip->mutex);
392 memcpy(mac_addr, chip->e2p_mac, ETH_ALEN);
393 mutex_unlock(&chip->mutex);
394 }
395
396 static int read_mac_addr(struct zd_chip *chip, u8 *mac_addr)
397 {
398 static const zd_addr_t addr[2] = { CR_MAC_ADDR_P1, CR_MAC_ADDR_P2 };
399 return _read_mac_addr(chip, mac_addr, (const zd_addr_t *)addr);
400 }
401
402 int zd_read_mac_addr(struct zd_chip *chip, u8 *mac_addr)
403 {
404 int r;
405
406 dev_dbg_f(zd_chip_dev(chip), "\n");
407 mutex_lock(&chip->mutex);
408 r = read_mac_addr(chip, mac_addr);
409 mutex_unlock(&chip->mutex);
410 return r;
411 }
412
413 int zd_write_mac_addr(struct zd_chip *chip, const u8 *mac_addr)
414 {
415 int r;
416 struct zd_ioreq32 reqs[2] = {
417 [0] = { .addr = CR_MAC_ADDR_P1 },
418 [1] = { .addr = CR_MAC_ADDR_P2 },
419 };
420
421 reqs[0].value = (mac_addr[3] << 24)
422 | (mac_addr[2] << 16)
423 | (mac_addr[1] << 8)
424 | mac_addr[0];
425 reqs[1].value = (mac_addr[5] << 8)
426 | mac_addr[4];
427
428 dev_dbg_f(zd_chip_dev(chip),
429 "mac addr " MAC_FMT "\n", MAC_ARG(mac_addr));
430
431 mutex_lock(&chip->mutex);
432 r = zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
433 #ifdef DEBUG
434 {
435 u8 tmp[ETH_ALEN];
436 read_mac_addr(chip, tmp);
437 }
438 #endif /* DEBUG */
439 mutex_unlock(&chip->mutex);
440 return r;
441 }
442
443 int zd_read_regdomain(struct zd_chip *chip, u8 *regdomain)
444 {
445 int r;
446 u32 value;
447
448 mutex_lock(&chip->mutex);
449 r = zd_ioread32_locked(chip, &value, E2P_SUBID);
450 mutex_unlock(&chip->mutex);
451 if (r)
452 return r;
453
454 *regdomain = value >> 16;
455 dev_dbg_f(zd_chip_dev(chip), "regdomain: %#04x\n", *regdomain);
456
457 return 0;
458 }
459
460 static int read_values(struct zd_chip *chip, u8 *values, size_t count,
461 zd_addr_t e2p_addr, u32 guard)
462 {
463 int r;
464 int i;
465 u32 v;
466
467 ZD_ASSERT(mutex_is_locked(&chip->mutex));
468 for (i = 0;;) {
469 r = zd_ioread32_locked(chip, &v, e2p_addr+i/2);
470 if (r)
471 return r;
472 v -= guard;
473 if (i+4 < count) {
474 values[i++] = v;
475 values[i++] = v >> 8;
476 values[i++] = v >> 16;
477 values[i++] = v >> 24;
478 continue;
479 }
480 for (;i < count; i++)
481 values[i] = v >> (8*(i%3));
482 return 0;
483 }
484 }
485
486 static int read_pwr_cal_values(struct zd_chip *chip)
487 {
488 return read_values(chip, chip->pwr_cal_values,
489 E2P_CHANNEL_COUNT, E2P_PWR_CAL_VALUE1,
490 0);
491 }
492
493 static int read_pwr_int_values(struct zd_chip *chip)
494 {
495 return read_values(chip, chip->pwr_int_values,
496 E2P_CHANNEL_COUNT, E2P_PWR_INT_VALUE1,
497 E2P_PWR_INT_GUARD);
498 }
499
500 static int read_ofdm_cal_values(struct zd_chip *chip)
501 {
502 int r;
503 int i;
504 static const zd_addr_t addresses[] = {
505 E2P_36M_CAL_VALUE1,
506 E2P_48M_CAL_VALUE1,
507 E2P_54M_CAL_VALUE1,
508 };
509
510 for (i = 0; i < 3; i++) {
511 r = read_values(chip, chip->ofdm_cal_values[i],
512 E2P_CHANNEL_COUNT, addresses[i], 0);
513 if (r)
514 return r;
515 }
516 return 0;
517 }
518
519 static int read_cal_int_tables(struct zd_chip *chip)
520 {
521 int r;
522
523 r = read_pwr_cal_values(chip);
524 if (r)
525 return r;
526 r = read_pwr_int_values(chip);
527 if (r)
528 return r;
529 r = read_ofdm_cal_values(chip);
530 if (r)
531 return r;
532 return 0;
533 }
534
535 /* phy means physical registers */
536 int zd_chip_lock_phy_regs(struct zd_chip *chip)
537 {
538 int r;
539 u32 tmp;
540
541 ZD_ASSERT(mutex_is_locked(&chip->mutex));
542 r = zd_ioread32_locked(chip, &tmp, CR_REG1);
543 if (r) {
544 dev_err(zd_chip_dev(chip), "error ioread32(CR_REG1): %d\n", r);
545 return r;
546 }
547
548 dev_dbg_f(zd_chip_dev(chip),
549 "CR_REG1: 0x%02x -> 0x%02x\n", tmp, tmp & ~UNLOCK_PHY_REGS);
550 tmp &= ~UNLOCK_PHY_REGS;
551
552 r = zd_iowrite32_locked(chip, tmp, CR_REG1);
553 if (r)
554 dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
555 return r;
556 }
557
558 int zd_chip_unlock_phy_regs(struct zd_chip *chip)
559 {
560 int r;
561 u32 tmp;
562
563 ZD_ASSERT(mutex_is_locked(&chip->mutex));
564 r = zd_ioread32_locked(chip, &tmp, CR_REG1);
565 if (r) {
566 dev_err(zd_chip_dev(chip),
567 "error ioread32(CR_REG1): %d\n", r);
568 return r;
569 }
570
571 dev_dbg_f(zd_chip_dev(chip),
572 "CR_REG1: 0x%02x -> 0x%02x\n", tmp, tmp | UNLOCK_PHY_REGS);
573 tmp |= UNLOCK_PHY_REGS;
574
575 r = zd_iowrite32_locked(chip, tmp, CR_REG1);
576 if (r)
577 dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
578 return r;
579 }
580
581 /* CR157 can be optionally patched by the EEPROM */
582 static int patch_cr157(struct zd_chip *chip)
583 {
584 int r;
585 u32 value;
586
587 if (!chip->patch_cr157)
588 return 0;
589
590 r = zd_ioread32_locked(chip, &value, E2P_PHY_REG);
591 if (r)
592 return r;
593
594 dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value >> 8);
595 return zd_iowrite32_locked(chip, value >> 8, CR157);
596 }
597
598 /*
599 * 6M band edge can be optionally overwritten for certain RF's
600 * Vendor driver says: for FCC regulation, enabled per HWFeature 6M band edge
601 * bit (for AL2230, AL2230S)
602 */
603 static int patch_6m_band_edge(struct zd_chip *chip, int channel)
604 {
605 struct zd_ioreq16 ioreqs[] = {
606 { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
607 { CR47, 0x1e },
608 };
609
610 if (!chip->patch_6m_band_edge || !chip->rf.patch_6m_band_edge)
611 return 0;
612
613 /* FIXME: Channel 11 is not the edge for all regulatory domains. */
614 if (channel == 1 || channel == 11)
615 ioreqs[0].value = 0x12;
616
617 dev_dbg_f(zd_chip_dev(chip), "patching for channel %d\n", channel);
618 return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
619 }
620
621 static int zd1211_hw_reset_phy(struct zd_chip *chip)
622 {
623 static const struct zd_ioreq16 ioreqs[] = {
624 { CR0, 0x0a }, { CR1, 0x06 }, { CR2, 0x26 },
625 { CR3, 0x38 }, { CR4, 0x80 }, { CR9, 0xa0 },
626 { CR10, 0x81 }, { CR11, 0x00 }, { CR12, 0x7f },
627 { CR13, 0x8c }, { CR14, 0x80 }, { CR15, 0x3d },
628 { CR16, 0x20 }, { CR17, 0x1e }, { CR18, 0x0a },
629 { CR19, 0x48 }, { CR20, 0x0c }, { CR21, 0x0c },
630 { CR22, 0x23 }, { CR23, 0x90 }, { CR24, 0x14 },
631 { CR25, 0x40 }, { CR26, 0x10 }, { CR27, 0x19 },
632 { CR28, 0x7f }, { CR29, 0x80 }, { CR30, 0x4b },
633 { CR31, 0x60 }, { CR32, 0x43 }, { CR33, 0x08 },
634 { CR34, 0x06 }, { CR35, 0x0a }, { CR36, 0x00 },
635 { CR37, 0x00 }, { CR38, 0x38 }, { CR39, 0x0c },
636 { CR40, 0x84 }, { CR41, 0x2a }, { CR42, 0x80 },
637 { CR43, 0x10 }, { CR44, 0x12 }, { CR46, 0xff },
638 { CR47, 0x1E }, { CR48, 0x26 }, { CR49, 0x5b },
639 { CR64, 0xd0 }, { CR65, 0x04 }, { CR66, 0x58 },
640 { CR67, 0xc9 }, { CR68, 0x88 }, { CR69, 0x41 },
641 { CR70, 0x23 }, { CR71, 0x10 }, { CR72, 0xff },
642 { CR73, 0x32 }, { CR74, 0x30 }, { CR75, 0x65 },
643 { CR76, 0x41 }, { CR77, 0x1b }, { CR78, 0x30 },
644 { CR79, 0x68 }, { CR80, 0x64 }, { CR81, 0x64 },
645 { CR82, 0x00 }, { CR83, 0x00 }, { CR84, 0x00 },
646 { CR85, 0x02 }, { CR86, 0x00 }, { CR87, 0x00 },
647 { CR88, 0xff }, { CR89, 0xfc }, { CR90, 0x00 },
648 { CR91, 0x00 }, { CR92, 0x00 }, { CR93, 0x08 },
649 { CR94, 0x00 }, { CR95, 0x00 }, { CR96, 0xff },
650 { CR97, 0xe7 }, { CR98, 0x00 }, { CR99, 0x00 },
651 { CR100, 0x00 }, { CR101, 0xae }, { CR102, 0x02 },
652 { CR103, 0x00 }, { CR104, 0x03 }, { CR105, 0x65 },
653 { CR106, 0x04 }, { CR107, 0x00 }, { CR108, 0x0a },
654 { CR109, 0xaa }, { CR110, 0xaa }, { CR111, 0x25 },
655 { CR112, 0x25 }, { CR113, 0x00 }, { CR119, 0x1e },
656 { CR125, 0x90 }, { CR126, 0x00 }, { CR127, 0x00 },
657 { },
658 { CR5, 0x00 }, { CR6, 0x00 }, { CR7, 0x00 },
659 { CR8, 0x00 }, { CR9, 0x20 }, { CR12, 0xf0 },
660 { CR20, 0x0e }, { CR21, 0x0e }, { CR27, 0x10 },
661 { CR44, 0x33 }, { CR47, 0x1E }, { CR83, 0x24 },
662 { CR84, 0x04 }, { CR85, 0x00 }, { CR86, 0x0C },
663 { CR87, 0x12 }, { CR88, 0x0C }, { CR89, 0x00 },
664 { CR90, 0x10 }, { CR91, 0x08 }, { CR93, 0x00 },
665 { CR94, 0x01 }, { CR95, 0x00 }, { CR96, 0x50 },
666 { CR97, 0x37 }, { CR98, 0x35 }, { CR101, 0x13 },
667 { CR102, 0x27 }, { CR103, 0x27 }, { CR104, 0x18 },
668 { CR105, 0x12 }, { CR109, 0x27 }, { CR110, 0x27 },
669 { CR111, 0x27 }, { CR112, 0x27 }, { CR113, 0x27 },
670 { CR114, 0x27 }, { CR115, 0x26 }, { CR116, 0x24 },
671 { CR117, 0xfc }, { CR118, 0xfa }, { CR120, 0x4f },
672 { CR123, 0x27 }, { CR125, 0xaa }, { CR127, 0x03 },
673 { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
674 { CR131, 0x0C }, { CR136, 0xdf }, { CR137, 0x40 },
675 { CR138, 0xa0 }, { CR139, 0xb0 }, { CR140, 0x99 },
676 { CR141, 0x82 }, { CR142, 0x54 }, { CR143, 0x1c },
677 { CR144, 0x6c }, { CR147, 0x07 }, { CR148, 0x4c },
678 { CR149, 0x50 }, { CR150, 0x0e }, { CR151, 0x18 },
679 { CR160, 0xfe }, { CR161, 0xee }, { CR162, 0xaa },
680 { CR163, 0xfa }, { CR164, 0xfa }, { CR165, 0xea },
681 { CR166, 0xbe }, { CR167, 0xbe }, { CR168, 0x6a },
682 { CR169, 0xba }, { CR170, 0xba }, { CR171, 0xba },
683 /* Note: CR204 must lead the CR203 */
684 { CR204, 0x7d },
685 { },
686 { CR203, 0x30 },
687 };
688
689 int r, t;
690
691 dev_dbg_f(zd_chip_dev(chip), "\n");
692
693 r = zd_chip_lock_phy_regs(chip);
694 if (r)
695 goto out;
696
697 r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
698 if (r)
699 goto unlock;
700
701 r = patch_cr157(chip);
702 unlock:
703 t = zd_chip_unlock_phy_regs(chip);
704 if (t && !r)
705 r = t;
706 out:
707 return r;
708 }
709
710 static int zd1211b_hw_reset_phy(struct zd_chip *chip)
711 {
712 static const struct zd_ioreq16 ioreqs[] = {
713 { CR0, 0x14 }, { CR1, 0x06 }, { CR2, 0x26 },
714 { CR3, 0x38 }, { CR4, 0x80 }, { CR9, 0xe0 },
715 { CR10, 0x81 },
716 /* power control { { CR11, 1 << 6 }, */
717 { CR11, 0x00 },
718 { CR12, 0xf0 }, { CR13, 0x8c }, { CR14, 0x80 },
719 { CR15, 0x3d }, { CR16, 0x20 }, { CR17, 0x1e },
720 { CR18, 0x0a }, { CR19, 0x48 },
721 { CR20, 0x10 }, /* Org:0x0E, ComTrend:RalLink AP */
722 { CR21, 0x0e }, { CR22, 0x23 }, { CR23, 0x90 },
723 { CR24, 0x14 }, { CR25, 0x40 }, { CR26, 0x10 },
724 { CR27, 0x10 }, { CR28, 0x7f }, { CR29, 0x80 },
725 { CR30, 0x4b }, /* ASIC/FWT, no jointly decoder */
726 { CR31, 0x60 }, { CR32, 0x43 }, { CR33, 0x08 },
727 { CR34, 0x06 }, { CR35, 0x0a }, { CR36, 0x00 },
728 { CR37, 0x00 }, { CR38, 0x38 }, { CR39, 0x0c },
729 { CR40, 0x84 }, { CR41, 0x2a }, { CR42, 0x80 },
730 { CR43, 0x10 }, { CR44, 0x33 }, { CR46, 0xff },
731 { CR47, 0x1E }, { CR48, 0x26 }, { CR49, 0x5b },
732 { CR64, 0xd0 }, { CR65, 0x04 }, { CR66, 0x58 },
733 { CR67, 0xc9 }, { CR68, 0x88 }, { CR69, 0x41 },
734 { CR70, 0x23 }, { CR71, 0x10 }, { CR72, 0xff },
735 { CR73, 0x32 }, { CR74, 0x30 }, { CR75, 0x65 },
736 { CR76, 0x41 }, { CR77, 0x1b }, { CR78, 0x30 },
737 { CR79, 0xf0 }, { CR80, 0x64 }, { CR81, 0x64 },
738 { CR82, 0x00 }, { CR83, 0x24 }, { CR84, 0x04 },
739 { CR85, 0x00 }, { CR86, 0x0c }, { CR87, 0x12 },
740 { CR88, 0x0c }, { CR89, 0x00 }, { CR90, 0x58 },
741 { CR91, 0x04 }, { CR92, 0x00 }, { CR93, 0x00 },
742 { CR94, 0x01 },
743 { CR95, 0x20 }, /* ZD1211B */
744 { CR96, 0x50 }, { CR97, 0x37 }, { CR98, 0x35 },
745 { CR99, 0x00 }, { CR100, 0x01 }, { CR101, 0x13 },
746 { CR102, 0x27 }, { CR103, 0x27 }, { CR104, 0x18 },
747 { CR105, 0x12 }, { CR106, 0x04 }, { CR107, 0x00 },
748 { CR108, 0x0a }, { CR109, 0x27 }, { CR110, 0x27 },
749 { CR111, 0x27 }, { CR112, 0x27 }, { CR113, 0x27 },
750 { CR114, 0x27 }, { CR115, 0x26 }, { CR116, 0x24 },
751 { CR117, 0xfc }, { CR118, 0xfa }, { CR119, 0x1e },
752 { CR125, 0x90 }, { CR126, 0x00 }, { CR127, 0x00 },
753 { CR128, 0x14 }, { CR129, 0x12 }, { CR130, 0x10 },
754 { CR131, 0x0c }, { CR136, 0xdf }, { CR137, 0xa0 },
755 { CR138, 0xa8 }, { CR139, 0xb4 }, { CR140, 0x98 },
756 { CR141, 0x82 }, { CR142, 0x53 }, { CR143, 0x1c },
757 { CR144, 0x6c }, { CR147, 0x07 }, { CR148, 0x40 },
758 { CR149, 0x40 }, /* Org:0x50 ComTrend:RalLink AP */
759 { CR150, 0x14 }, /* Org:0x0E ComTrend:RalLink AP */
760 { CR151, 0x18 }, { CR159, 0x70 }, { CR160, 0xfe },
761 { CR161, 0xee }, { CR162, 0xaa }, { CR163, 0xfa },
762 { CR164, 0xfa }, { CR165, 0xea }, { CR166, 0xbe },
763 { CR167, 0xbe }, { CR168, 0x6a }, { CR169, 0xba },
764 { CR170, 0xba }, { CR171, 0xba },
765 /* Note: CR204 must lead the CR203 */
766 { CR204, 0x7d },
767 {},
768 { CR203, 0x30 },
769 };
770
771 int r, t;
772
773 dev_dbg_f(zd_chip_dev(chip), "\n");
774
775 r = zd_chip_lock_phy_regs(chip);
776 if (r)
777 goto out;
778
779 r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
780 if (r)
781 goto unlock;
782
783 r = patch_cr157(chip);
784 unlock:
785 t = zd_chip_unlock_phy_regs(chip);
786 if (t && !r)
787 r = t;
788 out:
789 return r;
790 }
791
792 static int hw_reset_phy(struct zd_chip *chip)
793 {
794 return chip->is_zd1211b ? zd1211b_hw_reset_phy(chip) :
795 zd1211_hw_reset_phy(chip);
796 }
797
798 static int zd1211_hw_init_hmac(struct zd_chip *chip)
799 {
800 static const struct zd_ioreq32 ioreqs[] = {
801 { CR_ZD1211_RETRY_MAX, 0x2 },
802 { CR_RX_THRESHOLD, 0x000c0640 },
803 };
804
805 dev_dbg_f(zd_chip_dev(chip), "\n");
806 ZD_ASSERT(mutex_is_locked(&chip->mutex));
807 return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
808 }
809
810 static int zd1211b_hw_init_hmac(struct zd_chip *chip)
811 {
812 static const struct zd_ioreq32 ioreqs[] = {
813 { CR_ZD1211B_RETRY_MAX, 0x02020202 },
814 { CR_ZD1211B_TX_PWR_CTL4, 0x007f003f },
815 { CR_ZD1211B_TX_PWR_CTL3, 0x007f003f },
816 { CR_ZD1211B_TX_PWR_CTL2, 0x003f001f },
817 { CR_ZD1211B_TX_PWR_CTL1, 0x001f000f },
818 { CR_ZD1211B_AIFS_CTL1, 0x00280028 },
819 { CR_ZD1211B_AIFS_CTL2, 0x008C003C },
820 { CR_ZD1211B_TXOP, 0x01800824 },
821 { CR_RX_THRESHOLD, 0x000c0eff, },
822 };
823
824 dev_dbg_f(zd_chip_dev(chip), "\n");
825 ZD_ASSERT(mutex_is_locked(&chip->mutex));
826 return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
827 }
828
829 static int hw_init_hmac(struct zd_chip *chip)
830 {
831 int r;
832 static const struct zd_ioreq32 ioreqs[] = {
833 { CR_ACK_TIMEOUT_EXT, 0x20 },
834 { CR_ADDA_MBIAS_WARMTIME, 0x30000808 },
835 { CR_SNIFFER_ON, 0 },
836 { CR_RX_FILTER, STA_RX_FILTER },
837 { CR_GROUP_HASH_P1, 0x00 },
838 { CR_GROUP_HASH_P2, 0x80000000 },
839 { CR_REG1, 0xa4 },
840 { CR_ADDA_PWR_DWN, 0x7f },
841 { CR_BCN_PLCP_CFG, 0x00f00401 },
842 { CR_PHY_DELAY, 0x00 },
843 { CR_ACK_TIMEOUT_EXT, 0x80 },
844 { CR_ADDA_PWR_DWN, 0x00 },
845 { CR_ACK_TIME_80211, 0x100 },
846 { CR_RX_PE_DELAY, 0x70 },
847 { CR_PS_CTRL, 0x10000000 },
848 { CR_RTS_CTS_RATE, 0x02030203 },
849 { CR_AFTER_PNP, 0x1 },
850 { CR_WEP_PROTECT, 0x114 },
851 { CR_IFS_VALUE, IFS_VALUE_DEFAULT },
852 };
853
854 ZD_ASSERT(mutex_is_locked(&chip->mutex));
855 r = zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
856 if (r)
857 return r;
858
859 return chip->is_zd1211b ?
860 zd1211b_hw_init_hmac(chip) : zd1211_hw_init_hmac(chip);
861 }
862
863 struct aw_pt_bi {
864 u32 atim_wnd_period;
865 u32 pre_tbtt;
866 u32 beacon_interval;
867 };
868
869 static int get_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
870 {
871 int r;
872 static const zd_addr_t aw_pt_bi_addr[] =
873 { CR_ATIM_WND_PERIOD, CR_PRE_TBTT, CR_BCN_INTERVAL };
874 u32 values[3];
875
876 r = zd_ioread32v_locked(chip, values, (const zd_addr_t *)aw_pt_bi_addr,
877 ARRAY_SIZE(aw_pt_bi_addr));
878 if (r) {
879 memset(s, 0, sizeof(*s));
880 return r;
881 }
882
883 s->atim_wnd_period = values[0];
884 s->pre_tbtt = values[1];
885 s->beacon_interval = values[2];
886 dev_dbg_f(zd_chip_dev(chip), "aw %u pt %u bi %u\n",
887 s->atim_wnd_period, s->pre_tbtt, s->beacon_interval);
888 return 0;
889 }
890
891 static int set_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
892 {
893 struct zd_ioreq32 reqs[3];
894
895 if (s->beacon_interval <= 5)
896 s->beacon_interval = 5;
897 if (s->pre_tbtt < 4 || s->pre_tbtt >= s->beacon_interval)
898 s->pre_tbtt = s->beacon_interval - 1;
899 if (s->atim_wnd_period >= s->pre_tbtt)
900 s->atim_wnd_period = s->pre_tbtt - 1;
901
902 reqs[0].addr = CR_ATIM_WND_PERIOD;
903 reqs[0].value = s->atim_wnd_period;
904 reqs[1].addr = CR_PRE_TBTT;
905 reqs[1].value = s->pre_tbtt;
906 reqs[2].addr = CR_BCN_INTERVAL;
907 reqs[2].value = s->beacon_interval;
908
909 dev_dbg_f(zd_chip_dev(chip),
910 "aw %u pt %u bi %u\n", s->atim_wnd_period, s->pre_tbtt,
911 s->beacon_interval);
912 return zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
913 }
914
915
916 static int set_beacon_interval(struct zd_chip *chip, u32 interval)
917 {
918 int r;
919 struct aw_pt_bi s;
920
921 ZD_ASSERT(mutex_is_locked(&chip->mutex));
922 r = get_aw_pt_bi(chip, &s);
923 if (r)
924 return r;
925 s.beacon_interval = interval;
926 return set_aw_pt_bi(chip, &s);
927 }
928
929 int zd_set_beacon_interval(struct zd_chip *chip, u32 interval)
930 {
931 int r;
932
933 mutex_lock(&chip->mutex);
934 r = set_beacon_interval(chip, interval);
935 mutex_unlock(&chip->mutex);
936 return r;
937 }
938
939 static int hw_init(struct zd_chip *chip)
940 {
941 int r;
942
943 dev_dbg_f(zd_chip_dev(chip), "\n");
944 ZD_ASSERT(mutex_is_locked(&chip->mutex));
945 r = hw_reset_phy(chip);
946 if (r)
947 return r;
948
949 r = hw_init_hmac(chip);
950 if (r)
951 return r;
952
953 return set_beacon_interval(chip, 100);
954 }
955
956 #ifdef DEBUG
957 static int dump_cr(struct zd_chip *chip, const zd_addr_t addr,
958 const char *addr_string)
959 {
960 int r;
961 u32 value;
962
963 r = zd_ioread32_locked(chip, &value, addr);
964 if (r) {
965 dev_dbg_f(zd_chip_dev(chip),
966 "error reading %s. Error number %d\n", addr_string, r);
967 return r;
968 }
969
970 dev_dbg_f(zd_chip_dev(chip), "%s %#010x\n",
971 addr_string, (unsigned int)value);
972 return 0;
973 }
974
975 static int test_init(struct zd_chip *chip)
976 {
977 int r;
978
979 r = dump_cr(chip, CR_AFTER_PNP, "CR_AFTER_PNP");
980 if (r)
981 return r;
982 r = dump_cr(chip, CR_GPI_EN, "CR_GPI_EN");
983 if (r)
984 return r;
985 return dump_cr(chip, CR_INTERRUPT, "CR_INTERRUPT");
986 }
987
988 static void dump_fw_registers(struct zd_chip *chip)
989 {
990 static const zd_addr_t addr[4] = {
991 FW_FIRMWARE_VER, FW_USB_SPEED, FW_FIX_TX_RATE,
992 FW_LINK_STATUS
993 };
994
995 int r;
996 u16 values[4];
997
998 r = zd_ioread16v_locked(chip, values, (const zd_addr_t*)addr,
999 ARRAY_SIZE(addr));
1000 if (r) {
1001 dev_dbg_f(zd_chip_dev(chip), "error %d zd_ioread16v_locked\n",
1002 r);
1003 return;
1004 }
1005
1006 dev_dbg_f(zd_chip_dev(chip), "FW_FIRMWARE_VER %#06hx\n", values[0]);
1007 dev_dbg_f(zd_chip_dev(chip), "FW_USB_SPEED %#06hx\n", values[1]);
1008 dev_dbg_f(zd_chip_dev(chip), "FW_FIX_TX_RATE %#06hx\n", values[2]);
1009 dev_dbg_f(zd_chip_dev(chip), "FW_LINK_STATUS %#06hx\n", values[3]);
1010 }
1011 #endif /* DEBUG */
1012
1013 static int print_fw_version(struct zd_chip *chip)
1014 {
1015 int r;
1016 u16 version;
1017
1018 r = zd_ioread16_locked(chip, &version, FW_FIRMWARE_VER);
1019 if (r)
1020 return r;
1021
1022 dev_info(zd_chip_dev(chip),"firmware version %04hx\n", version);
1023 return 0;
1024 }
1025
1026 static int set_mandatory_rates(struct zd_chip *chip, enum ieee80211_std std)
1027 {
1028 u32 rates;
1029 ZD_ASSERT(mutex_is_locked(&chip->mutex));
1030 /* This sets the mandatory rates, which only depend from the standard
1031 * that the device is supporting. Until further notice we should try
1032 * to support 802.11g also for full speed USB.
1033 */
1034 switch (std) {
1035 case IEEE80211B:
1036 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M;
1037 break;
1038 case IEEE80211G:
1039 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M|
1040 CR_RATE_6M|CR_RATE_12M|CR_RATE_24M;
1041 break;
1042 default:
1043 return -EINVAL;
1044 }
1045 return zd_iowrite32_locked(chip, rates, CR_MANDATORY_RATE_TBL);
1046 }
1047
1048 int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip,
1049 u8 rts_rate, int preamble)
1050 {
1051 int rts_mod = ZD_RX_CCK;
1052 u32 value = 0;
1053
1054 /* Modulation bit */
1055 if (ZD_CS_TYPE(rts_rate) == ZD_CS_OFDM)
1056 rts_mod = ZD_RX_OFDM;
1057
1058 dev_dbg_f(zd_chip_dev(chip), "rts_rate=%x preamble=%x\n",
1059 rts_rate, preamble);
1060
1061 value |= rts_rate << RTSCTS_SH_RTS_RATE;
1062 value |= rts_mod << RTSCTS_SH_RTS_MOD_TYPE;
1063 value |= preamble << RTSCTS_SH_RTS_PMB_TYPE;
1064 value |= preamble << RTSCTS_SH_CTS_PMB_TYPE;
1065
1066 /* We always send 11M self-CTS messages, like the vendor driver. */
1067 value |= ZD_CCK_RATE_11M << RTSCTS_SH_CTS_RATE;
1068 value |= ZD_RX_CCK << RTSCTS_SH_CTS_MOD_TYPE;
1069
1070 return zd_iowrite32_locked(chip, value, CR_RTS_CTS_RATE);
1071 }
1072
1073 int zd_chip_enable_hwint(struct zd_chip *chip)
1074 {
1075 int r;
1076
1077 mutex_lock(&chip->mutex);
1078 r = zd_iowrite32_locked(chip, HWINT_ENABLED, CR_INTERRUPT);
1079 mutex_unlock(&chip->mutex);
1080 return r;
1081 }
1082
1083 static int disable_hwint(struct zd_chip *chip)
1084 {
1085 return zd_iowrite32_locked(chip, HWINT_DISABLED, CR_INTERRUPT);
1086 }
1087
1088 int zd_chip_disable_hwint(struct zd_chip *chip)
1089 {
1090 int r;
1091
1092 mutex_lock(&chip->mutex);
1093 r = disable_hwint(chip);
1094 mutex_unlock(&chip->mutex);
1095 return r;
1096 }
1097
1098 int zd_chip_init_hw(struct zd_chip *chip, u8 device_type)
1099 {
1100 int r;
1101 u8 rf_type;
1102
1103 dev_dbg_f(zd_chip_dev(chip), "\n");
1104
1105 mutex_lock(&chip->mutex);
1106 chip->is_zd1211b = (device_type == DEVICE_ZD1211B) != 0;
1107
1108 #ifdef DEBUG
1109 r = test_init(chip);
1110 if (r)
1111 goto out;
1112 #endif
1113 r = zd_iowrite32_locked(chip, 1, CR_AFTER_PNP);
1114 if (r)
1115 goto out;
1116
1117 r = zd_usb_init_hw(&chip->usb);
1118 if (r)
1119 goto out;
1120
1121 /* GPI is always disabled, also in the other driver.
1122 */
1123 r = zd_iowrite32_locked(chip, 0, CR_GPI_EN);
1124 if (r)
1125 goto out;
1126 r = zd_iowrite32_locked(chip, CWIN_SIZE, CR_CWMIN_CWMAX);
1127 if (r)
1128 goto out;
1129 /* Currently we support IEEE 802.11g for full and high speed USB.
1130 * It might be discussed, whether we should suppport pure b mode for
1131 * full speed USB.
1132 */
1133 r = set_mandatory_rates(chip, IEEE80211G);
1134 if (r)
1135 goto out;
1136 /* Disabling interrupts is certainly a smart thing here.
1137 */
1138 r = disable_hwint(chip);
1139 if (r)
1140 goto out;
1141 r = read_pod(chip, &rf_type);
1142 if (r)
1143 goto out;
1144 r = hw_init(chip);
1145 if (r)
1146 goto out;
1147 r = zd_rf_init_hw(&chip->rf, rf_type);
1148 if (r)
1149 goto out;
1150
1151 r = print_fw_version(chip);
1152 if (r)
1153 goto out;
1154
1155 #ifdef DEBUG
1156 dump_fw_registers(chip);
1157 r = test_init(chip);
1158 if (r)
1159 goto out;
1160 #endif /* DEBUG */
1161
1162 r = read_e2p_mac_addr(chip);
1163 if (r)
1164 goto out;
1165
1166 r = read_cal_int_tables(chip);
1167 if (r)
1168 goto out;
1169
1170 print_id(chip);
1171 out:
1172 mutex_unlock(&chip->mutex);
1173 return r;
1174 }
1175
1176 static int update_pwr_int(struct zd_chip *chip, u8 channel)
1177 {
1178 u8 value = chip->pwr_int_values[channel - 1];
1179 dev_dbg_f(zd_chip_dev(chip), "channel %d pwr_int %#04x\n",
1180 channel, value);
1181 return zd_iowrite16_locked(chip, value, CR31);
1182 }
1183
1184 static int update_pwr_cal(struct zd_chip *chip, u8 channel)
1185 {
1186 u8 value = chip->pwr_cal_values[channel-1];
1187 dev_dbg_f(zd_chip_dev(chip), "channel %d pwr_cal %#04x\n",
1188 channel, value);
1189 return zd_iowrite16_locked(chip, value, CR68);
1190 }
1191
1192 static int update_ofdm_cal(struct zd_chip *chip, u8 channel)
1193 {
1194 struct zd_ioreq16 ioreqs[3];
1195
1196 ioreqs[0].addr = CR67;
1197 ioreqs[0].value = chip->ofdm_cal_values[OFDM_36M_INDEX][channel-1];
1198 ioreqs[1].addr = CR66;
1199 ioreqs[1].value = chip->ofdm_cal_values[OFDM_48M_INDEX][channel-1];
1200 ioreqs[2].addr = CR65;
1201 ioreqs[2].value = chip->ofdm_cal_values[OFDM_54M_INDEX][channel-1];
1202
1203 dev_dbg_f(zd_chip_dev(chip),
1204 "channel %d ofdm_cal 36M %#04x 48M %#04x 54M %#04x\n",
1205 channel, ioreqs[0].value, ioreqs[1].value, ioreqs[2].value);
1206 return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1207 }
1208
1209 static int update_channel_integration_and_calibration(struct zd_chip *chip,
1210 u8 channel)
1211 {
1212 int r;
1213
1214 r = update_pwr_int(chip, channel);
1215 if (r)
1216 return r;
1217 if (chip->is_zd1211b) {
1218 static const struct zd_ioreq16 ioreqs[] = {
1219 { CR69, 0x28 },
1220 {},
1221 { CR69, 0x2a },
1222 };
1223
1224 r = update_ofdm_cal(chip, channel);
1225 if (r)
1226 return r;
1227 r = update_pwr_cal(chip, channel);
1228 if (r)
1229 return r;
1230 r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1231 if (r)
1232 return r;
1233 }
1234
1235 return 0;
1236 }
1237
1238 /* The CCK baseband gain can be optionally patched by the EEPROM */
1239 static int patch_cck_gain(struct zd_chip *chip)
1240 {
1241 int r;
1242 u32 value;
1243
1244 if (!chip->patch_cck_gain)
1245 return 0;
1246
1247 ZD_ASSERT(mutex_is_locked(&chip->mutex));
1248 r = zd_ioread32_locked(chip, &value, E2P_PHY_REG);
1249 if (r)
1250 return r;
1251 dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value & 0xff);
1252 return zd_iowrite16_locked(chip, value & 0xff, CR47);
1253 }
1254
1255 int zd_chip_set_channel(struct zd_chip *chip, u8 channel)
1256 {
1257 int r, t;
1258
1259 mutex_lock(&chip->mutex);
1260 r = zd_chip_lock_phy_regs(chip);
1261 if (r)
1262 goto out;
1263 r = zd_rf_set_channel(&chip->rf, channel);
1264 if (r)
1265 goto unlock;
1266 r = update_channel_integration_and_calibration(chip, channel);
1267 if (r)
1268 goto unlock;
1269 r = patch_cck_gain(chip);
1270 if (r)
1271 goto unlock;
1272 r = patch_6m_band_edge(chip, channel);
1273 if (r)
1274 goto unlock;
1275 r = zd_iowrite32_locked(chip, 0, CR_CONFIG_PHILIPS);
1276 unlock:
1277 t = zd_chip_unlock_phy_regs(chip);
1278 if (t && !r)
1279 r = t;
1280 out:
1281 mutex_unlock(&chip->mutex);
1282 return r;
1283 }
1284
1285 u8 zd_chip_get_channel(struct zd_chip *chip)
1286 {
1287 u8 channel;
1288
1289 mutex_lock(&chip->mutex);
1290 channel = chip->rf.channel;
1291 mutex_unlock(&chip->mutex);
1292 return channel;
1293 }
1294
1295 int zd_chip_control_leds(struct zd_chip *chip, enum led_status status)
1296 {
1297 static const zd_addr_t a[] = {
1298 FW_LINK_STATUS,
1299 CR_LED,
1300 };
1301
1302 int r;
1303 u16 v[ARRAY_SIZE(a)];
1304 struct zd_ioreq16 ioreqs[ARRAY_SIZE(a)] = {
1305 [0] = { FW_LINK_STATUS },
1306 [1] = { CR_LED },
1307 };
1308 u16 other_led;
1309
1310 mutex_lock(&chip->mutex);
1311 r = zd_ioread16v_locked(chip, v, (const zd_addr_t *)a, ARRAY_SIZE(a));
1312 if (r)
1313 goto out;
1314
1315 other_led = chip->link_led == LED1 ? LED2 : LED1;
1316
1317 switch (status) {
1318 case LED_OFF:
1319 ioreqs[0].value = FW_LINK_OFF;
1320 ioreqs[1].value = v[1] & ~(LED1|LED2);
1321 break;
1322 case LED_SCANNING:
1323 ioreqs[0].value = FW_LINK_OFF;
1324 ioreqs[1].value = v[1] & ~other_led;
1325 if (get_seconds() % 3 == 0) {
1326 ioreqs[1].value &= ~chip->link_led;
1327 } else {
1328 ioreqs[1].value |= chip->link_led;
1329 }
1330 break;
1331 case LED_ASSOCIATED:
1332 ioreqs[0].value = FW_LINK_TX;
1333 ioreqs[1].value = v[1] & ~other_led;
1334 ioreqs[1].value |= chip->link_led;
1335 break;
1336 default:
1337 r = -EINVAL;
1338 goto out;
1339 }
1340
1341 if (v[0] != ioreqs[0].value || v[1] != ioreqs[1].value) {
1342 r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1343 if (r)
1344 goto out;
1345 }
1346 r = 0;
1347 out:
1348 mutex_unlock(&chip->mutex);
1349 return r;
1350 }
1351
1352 int zd_chip_set_basic_rates_locked(struct zd_chip *chip, u16 cr_rates)
1353 {
1354 ZD_ASSERT((cr_rates & ~(CR_RATES_80211B | CR_RATES_80211G)) == 0);
1355 dev_dbg_f(zd_chip_dev(chip), "%x\n", cr_rates);
1356
1357 return zd_iowrite32_locked(chip, cr_rates, CR_BASIC_RATE_TBL);
1358 }
1359
1360 static int ofdm_qual_db(u8 status_quality, u8 rate, unsigned int size)
1361 {
1362 static const u16 constants[] = {
1363 715, 655, 585, 540, 470, 410, 360, 315,
1364 270, 235, 205, 175, 150, 125, 105, 85,
1365 65, 50, 40, 25, 15
1366 };
1367
1368 int i;
1369 u32 x;
1370
1371 /* It seems that their quality parameter is somehow per signal
1372 * and is now transferred per bit.
1373 */
1374 switch (rate) {
1375 case ZD_OFDM_RATE_6M:
1376 case ZD_OFDM_RATE_12M:
1377 case ZD_OFDM_RATE_24M:
1378 size *= 2;
1379 break;
1380 case ZD_OFDM_RATE_9M:
1381 case ZD_OFDM_RATE_18M:
1382 case ZD_OFDM_RATE_36M:
1383 case ZD_OFDM_RATE_54M:
1384 size *= 4;
1385 size /= 3;
1386 break;
1387 case ZD_OFDM_RATE_48M:
1388 size *= 3;
1389 size /= 2;
1390 break;
1391 default:
1392 return -EINVAL;
1393 }
1394
1395 x = (10000 * status_quality)/size;
1396 for (i = 0; i < ARRAY_SIZE(constants); i++) {
1397 if (x > constants[i])
1398 break;
1399 }
1400
1401 switch (rate) {
1402 case ZD_OFDM_RATE_6M:
1403 case ZD_OFDM_RATE_9M:
1404 i += 3;
1405 break;
1406 case ZD_OFDM_RATE_12M:
1407 case ZD_OFDM_RATE_18M:
1408 i += 5;
1409 break;
1410 case ZD_OFDM_RATE_24M:
1411 case ZD_OFDM_RATE_36M:
1412 i += 9;
1413 break;
1414 case ZD_OFDM_RATE_48M:
1415 case ZD_OFDM_RATE_54M:
1416 i += 15;
1417 break;
1418 default:
1419 return -EINVAL;
1420 }
1421
1422 return i;
1423 }
1424
1425 static int ofdm_qual_percent(u8 status_quality, u8 rate, unsigned int size)
1426 {
1427 int r;
1428
1429 r = ofdm_qual_db(status_quality, rate, size);
1430 ZD_ASSERT(r >= 0);
1431 if (r < 0)
1432 r = 0;
1433
1434 r = (r * 100)/29;
1435 return r <= 100 ? r : 100;
1436 }
1437
1438 static unsigned int log10times100(unsigned int x)
1439 {
1440 static const u8 log10[] = {
1441 0,
1442 0, 30, 47, 60, 69, 77, 84, 90, 95, 100,
1443 104, 107, 111, 114, 117, 120, 123, 125, 127, 130,
1444 132, 134, 136, 138, 139, 141, 143, 144, 146, 147,
1445 149, 150, 151, 153, 154, 155, 156, 157, 159, 160,
1446 161, 162, 163, 164, 165, 166, 167, 168, 169, 169,
1447 170, 171, 172, 173, 174, 174, 175, 176, 177, 177,
1448 178, 179, 179, 180, 181, 181, 182, 183, 183, 184,
1449 185, 185, 186, 186, 187, 188, 188, 189, 189, 190,
1450 190, 191, 191, 192, 192, 193, 193, 194, 194, 195,
1451 195, 196, 196, 197, 197, 198, 198, 199, 199, 200,
1452 200, 200, 201, 201, 202, 202, 202, 203, 203, 204,
1453 204, 204, 205, 205, 206, 206, 206, 207, 207, 207,
1454 208, 208, 208, 209, 209, 210, 210, 210, 211, 211,
1455 211, 212, 212, 212, 213, 213, 213, 213, 214, 214,
1456 214, 215, 215, 215, 216, 216, 216, 217, 217, 217,
1457 217, 218, 218, 218, 219, 219, 219, 219, 220, 220,
1458 220, 220, 221, 221, 221, 222, 222, 222, 222, 223,
1459 223, 223, 223, 224, 224, 224, 224,
1460 };
1461
1462 return x < ARRAY_SIZE(log10) ? log10[x] : 225;
1463 }
1464
1465 enum {
1466 MAX_CCK_EVM_DB = 45,
1467 };
1468
1469 static int cck_evm_db(u8 status_quality)
1470 {
1471 return (20 * log10times100(status_quality)) / 100;
1472 }
1473
1474 static int cck_snr_db(u8 status_quality)
1475 {
1476 int r = MAX_CCK_EVM_DB - cck_evm_db(status_quality);
1477 ZD_ASSERT(r >= 0);
1478 return r;
1479 }
1480
1481 static int cck_qual_percent(u8 status_quality)
1482 {
1483 int r;
1484
1485 r = cck_snr_db(status_quality);
1486 r = (100*r)/17;
1487 return r <= 100 ? r : 100;
1488 }
1489
1490 u8 zd_rx_qual_percent(const void *rx_frame, unsigned int size,
1491 const struct rx_status *status)
1492 {
1493 return (status->frame_status&ZD_RX_OFDM) ?
1494 ofdm_qual_percent(status->signal_quality_ofdm,
1495 zd_ofdm_plcp_header_rate(rx_frame),
1496 size) :
1497 cck_qual_percent(status->signal_quality_cck);
1498 }
1499
1500 u8 zd_rx_strength_percent(u8 rssi)
1501 {
1502 int r = (rssi*100) / 41;
1503 if (r > 100)
1504 r = 100;
1505 return (u8) r;
1506 }
1507
1508 u16 zd_rx_rate(const void *rx_frame, const struct rx_status *status)
1509 {
1510 static const u16 ofdm_rates[] = {
1511 [ZD_OFDM_RATE_6M] = 60,
1512 [ZD_OFDM_RATE_9M] = 90,
1513 [ZD_OFDM_RATE_12M] = 120,
1514 [ZD_OFDM_RATE_18M] = 180,
1515 [ZD_OFDM_RATE_24M] = 240,
1516 [ZD_OFDM_RATE_36M] = 360,
1517 [ZD_OFDM_RATE_48M] = 480,
1518 [ZD_OFDM_RATE_54M] = 540,
1519 };
1520 u16 rate;
1521 if (status->frame_status & ZD_RX_OFDM) {
1522 u8 ofdm_rate = zd_ofdm_plcp_header_rate(rx_frame);
1523 rate = ofdm_rates[ofdm_rate & 0xf];
1524 } else {
1525 u8 cck_rate = zd_cck_plcp_header_rate(rx_frame);
1526 switch (cck_rate) {
1527 case ZD_CCK_SIGNAL_1M:
1528 rate = 10;
1529 break;
1530 case ZD_CCK_SIGNAL_2M:
1531 rate = 20;
1532 break;
1533 case ZD_CCK_SIGNAL_5M5:
1534 rate = 55;
1535 break;
1536 case ZD_CCK_SIGNAL_11M:
1537 rate = 110;
1538 break;
1539 default:
1540 rate = 0;
1541 }
1542 }
1543
1544 return rate;
1545 }
1546
1547 int zd_chip_switch_radio_on(struct zd_chip *chip)
1548 {
1549 int r;
1550
1551 mutex_lock(&chip->mutex);
1552 r = zd_switch_radio_on(&chip->rf);
1553 mutex_unlock(&chip->mutex);
1554 return r;
1555 }
1556
1557 int zd_chip_switch_radio_off(struct zd_chip *chip)
1558 {
1559 int r;
1560
1561 mutex_lock(&chip->mutex);
1562 r = zd_switch_radio_off(&chip->rf);
1563 mutex_unlock(&chip->mutex);
1564 return r;
1565 }
1566
1567 int zd_chip_enable_int(struct zd_chip *chip)
1568 {
1569 int r;
1570
1571 mutex_lock(&chip->mutex);
1572 r = zd_usb_enable_int(&chip->usb);
1573 mutex_unlock(&chip->mutex);
1574 return r;
1575 }
1576
1577 void zd_chip_disable_int(struct zd_chip *chip)
1578 {
1579 mutex_lock(&chip->mutex);
1580 zd_usb_disable_int(&chip->usb);
1581 mutex_unlock(&chip->mutex);
1582 }
1583
1584 int zd_chip_enable_rx(struct zd_chip *chip)
1585 {
1586 int r;
1587
1588 mutex_lock(&chip->mutex);
1589 r = zd_usb_enable_rx(&chip->usb);
1590 mutex_unlock(&chip->mutex);
1591 return r;
1592 }
1593
1594 void zd_chip_disable_rx(struct zd_chip *chip)
1595 {
1596 mutex_lock(&chip->mutex);
1597 zd_usb_disable_rx(&chip->usb);
1598 mutex_unlock(&chip->mutex);
1599 }
1600
1601 int zd_rfwritev_locked(struct zd_chip *chip,
1602 const u32* values, unsigned int count, u8 bits)
1603 {
1604 int r;
1605 unsigned int i;
1606
1607 for (i = 0; i < count; i++) {
1608 r = zd_rfwrite_locked(chip, values[i], bits);
1609 if (r)
1610 return r;
1611 }
1612
1613 return 0;
1614 }
1615
1616 /*
1617 * We can optionally program the RF directly through CR regs, if supported by
1618 * the hardware. This is much faster than the older method.
1619 */
1620 int zd_rfwrite_cr_locked(struct zd_chip *chip, u32 value)
1621 {
1622 struct zd_ioreq16 ioreqs[] = {
1623 { CR244, (value >> 16) & 0xff },
1624 { CR243, (value >> 8) & 0xff },
1625 { CR242, value & 0xff },
1626 };
1627 ZD_ASSERT(mutex_is_locked(&chip->mutex));
1628 return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
1629 }
1630
1631 int zd_rfwritev_cr_locked(struct zd_chip *chip,
1632 const u32 *values, unsigned int count)
1633 {
1634 int r;
1635 unsigned int i;
1636
1637 for (i = 0; i < count; i++) {
1638 r = zd_rfwrite_cr_locked(chip, values[i]);
1639 if (r)
1640 return r;
1641 }
1642
1643 return 0;
1644 }
1645
1646 int zd_chip_set_multicast_hash(struct zd_chip *chip,
1647 struct zd_mc_hash *hash)
1648 {
1649 struct zd_ioreq32 ioreqs[] = {
1650 { CR_GROUP_HASH_P1, hash->low },
1651 { CR_GROUP_HASH_P2, hash->high },
1652 };
1653
1654 dev_dbg_f(zd_chip_dev(chip), "hash l 0x%08x h 0x%08x\n",
1655 ioreqs[0].value, ioreqs[1].value);
1656 return zd_iowrite32a(chip, ioreqs, ARRAY_SIZE(ioreqs));
1657 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree