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