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