2 * EEPROM parser code for mac80211 Prism54 drivers
4 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
5 * Copyright (c) 2007-2009, Christian Lamparter <chunkeey@web.de>
6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
9 * - the islsm (softmac prism54) driver, which is:
10 * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
12 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License version 2 as
16 * published by the Free Software Foundation.
19 #include <linux/init.h>
20 #include <linux/firmware.h>
21 #include <linux/etherdevice.h>
22 #include <linux/sort.h>
23 #include <linux/slab.h>
25 #include <net/mac80211.h>
31 static struct ieee80211_rate p54_bgrates
[] = {
32 { .bitrate
= 10, .hw_value
= 0, },
33 { .bitrate
= 20, .hw_value
= 1, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
34 { .bitrate
= 55, .hw_value
= 2, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
35 { .bitrate
= 110, .hw_value
= 3, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
36 { .bitrate
= 60, .hw_value
= 4, },
37 { .bitrate
= 90, .hw_value
= 5, },
38 { .bitrate
= 120, .hw_value
= 6, },
39 { .bitrate
= 180, .hw_value
= 7, },
40 { .bitrate
= 240, .hw_value
= 8, },
41 { .bitrate
= 360, .hw_value
= 9, },
42 { .bitrate
= 480, .hw_value
= 10, },
43 { .bitrate
= 540, .hw_value
= 11, },
46 static struct ieee80211_rate p54_arates
[] = {
47 { .bitrate
= 60, .hw_value
= 4, },
48 { .bitrate
= 90, .hw_value
= 5, },
49 { .bitrate
= 120, .hw_value
= 6, },
50 { .bitrate
= 180, .hw_value
= 7, },
51 { .bitrate
= 240, .hw_value
= 8, },
52 { .bitrate
= 360, .hw_value
= 9, },
53 { .bitrate
= 480, .hw_value
= 10, },
54 { .bitrate
= 540, .hw_value
= 11, },
57 #define CHAN_HAS_CAL BIT(0)
58 #define CHAN_HAS_LIMIT BIT(1)
59 #define CHAN_HAS_CURVE BIT(2)
60 #define CHAN_HAS_ALL (CHAN_HAS_CAL | CHAN_HAS_LIMIT | CHAN_HAS_CURVE)
62 struct p54_channel_entry
{
66 enum ieee80211_band band
;
69 struct p54_channel_list
{
70 struct p54_channel_entry
*channels
;
73 size_t band_channel_num
[IEEE80211_NUM_BANDS
];
76 static int p54_get_band_from_freq(u16 freq
)
78 /* FIXME: sync these values with the 802.11 spec */
80 if ((freq
>= 2412) && (freq
<= 2484))
81 return IEEE80211_BAND_2GHZ
;
83 if ((freq
>= 4920) && (freq
<= 5825))
84 return IEEE80211_BAND_5GHZ
;
89 static int p54_compare_channels(const void *_a
,
92 const struct p54_channel_entry
*a
= _a
;
93 const struct p54_channel_entry
*b
= _b
;
95 return a
->index
- b
->index
;
98 static int p54_fill_band_bitrates(struct ieee80211_hw
*dev
,
99 struct ieee80211_supported_band
*band_entry
,
100 enum ieee80211_band band
)
102 /* TODO: generate rate array dynamically */
105 case IEEE80211_BAND_2GHZ
:
106 band_entry
->bitrates
= p54_bgrates
;
107 band_entry
->n_bitrates
= ARRAY_SIZE(p54_bgrates
);
109 case IEEE80211_BAND_5GHZ
:
110 band_entry
->bitrates
= p54_arates
;
111 band_entry
->n_bitrates
= ARRAY_SIZE(p54_arates
);
120 static int p54_generate_band(struct ieee80211_hw
*dev
,
121 struct p54_channel_list
*list
,
122 enum ieee80211_band band
)
124 struct p54_common
*priv
= dev
->priv
;
125 struct ieee80211_supported_band
*tmp
, *old
;
129 if ((!list
->entries
) || (!list
->band_channel_num
[band
]))
132 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
136 tmp
->channels
= kzalloc(sizeof(struct ieee80211_channel
) *
137 list
->band_channel_num
[band
], GFP_KERNEL
);
141 ret
= p54_fill_band_bitrates(dev
, tmp
, band
);
145 for (i
= 0, j
= 0; (j
< list
->band_channel_num
[band
]) &&
146 (i
< list
->entries
); i
++) {
148 if (list
->channels
[i
].band
!= band
)
151 if (list
->channels
[i
].data
!= CHAN_HAS_ALL
) {
152 printk(KERN_ERR
"%s:%s%s%s is/are missing for "
153 "channel:%d [%d MHz].\n",
154 wiphy_name(dev
->wiphy
),
155 (list
->channels
[i
].data
& CHAN_HAS_CAL
? "" :
156 " [iqauto calibration data]"),
157 (list
->channels
[i
].data
& CHAN_HAS_LIMIT
? "" :
158 " [output power limits]"),
159 (list
->channels
[i
].data
& CHAN_HAS_CURVE
? "" :
161 list
->channels
[i
].index
, list
->channels
[i
].freq
);
165 tmp
->channels
[j
].band
= list
->channels
[i
].band
;
166 tmp
->channels
[j
].center_freq
= list
->channels
[i
].freq
;
171 printk(KERN_ERR
"%s: Disabling totally damaged %s band.\n",
172 wiphy_name(dev
->wiphy
), (band
== IEEE80211_BAND_2GHZ
) ?
180 old
= priv
->band_table
[band
];
181 priv
->band_table
[band
] = tmp
;
183 kfree(old
->channels
);
191 kfree(tmp
->channels
);
198 static void p54_update_channel_param(struct p54_channel_list
*list
,
204 * usually all lists in the eeprom are mostly sorted.
205 * so it's very likely that the entry we are looking for
206 * is right at the end of the list
208 for (i
= list
->entries
; i
>= 0; i
--) {
209 if (freq
== list
->channels
[i
].freq
) {
210 list
->channels
[i
].data
|= data
;
215 if ((i
< 0) && (list
->entries
< list
->max_entries
)) {
216 /* entry does not exist yet. Initialize a new one. */
217 band
= p54_get_band_from_freq(freq
);
220 * filter out frequencies which don't belong into
221 * any supported band.
227 list
->band_channel_num
[band
]++;
229 list
->channels
[i
].freq
= freq
;
230 list
->channels
[i
].data
= data
;
231 list
->channels
[i
].band
= band
;
232 list
->channels
[i
].index
= ieee80211_frequency_to_channel(freq
);
233 /* TODO: parse output_limit and fill max_power */
237 static int p54_generate_channel_lists(struct ieee80211_hw
*dev
)
239 struct p54_common
*priv
= dev
->priv
;
240 struct p54_channel_list
*list
;
241 unsigned int i
, j
, max_channel_num
;
245 if ((priv
->iq_autocal_len
!= priv
->curve_data
->entries
) ||
246 (priv
->iq_autocal_len
!= priv
->output_limit
->entries
))
247 printk(KERN_ERR
"%s: Unsupported or damaged EEPROM detected. "
248 "You may not be able to use all channels.\n",
249 wiphy_name(dev
->wiphy
));
251 max_channel_num
= max_t(unsigned int, priv
->output_limit
->entries
,
252 priv
->iq_autocal_len
);
253 max_channel_num
= max_t(unsigned int, max_channel_num
,
254 priv
->curve_data
->entries
);
256 list
= kzalloc(sizeof(*list
), GFP_KERNEL
);
262 list
->max_entries
= max_channel_num
;
263 list
->channels
= kzalloc(sizeof(struct p54_channel_entry
) *
264 max_channel_num
, GFP_KERNEL
);
268 for (i
= 0; i
< max_channel_num
; i
++) {
269 if (i
< priv
->iq_autocal_len
) {
270 freq
= le16_to_cpu(priv
->iq_autocal
[i
].freq
);
271 p54_update_channel_param(list
, freq
, CHAN_HAS_CAL
);
274 if (i
< priv
->output_limit
->entries
) {
275 freq
= le16_to_cpup((__le16
*) (i
*
276 priv
->output_limit
->entry_size
+
277 priv
->output_limit
->offset
+
278 priv
->output_limit
->data
));
280 p54_update_channel_param(list
, freq
, CHAN_HAS_LIMIT
);
283 if (i
< priv
->curve_data
->entries
) {
284 freq
= le16_to_cpup((__le16
*) (i
*
285 priv
->curve_data
->entry_size
+
286 priv
->curve_data
->offset
+
287 priv
->curve_data
->data
));
289 p54_update_channel_param(list
, freq
, CHAN_HAS_CURVE
);
293 /* sort the list by the channel index */
294 sort(list
->channels
, list
->entries
, sizeof(struct p54_channel_entry
),
295 p54_compare_channels
, NULL
);
297 for (i
= 0, j
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
298 if (p54_generate_band(dev
, list
, i
) == 0)
302 /* no useable band available. */
308 kfree(list
->channels
);
315 static int p54_convert_rev0(struct ieee80211_hw
*dev
,
316 struct pda_pa_curve_data
*curve_data
)
318 struct p54_common
*priv
= dev
->priv
;
319 struct p54_pa_curve_data_sample
*dst
;
320 struct pda_pa_curve_data_sample_rev0
*src
;
321 size_t cd_len
= sizeof(*curve_data
) +
322 (curve_data
->points_per_channel
*sizeof(*dst
) + 2) *
323 curve_data
->channels
;
325 void *source
, *target
;
327 priv
->curve_data
= kmalloc(sizeof(*priv
->curve_data
) + cd_len
,
329 if (!priv
->curve_data
)
332 priv
->curve_data
->entries
= curve_data
->channels
;
333 priv
->curve_data
->entry_size
= sizeof(__le16
) +
334 sizeof(*dst
) * curve_data
->points_per_channel
;
335 priv
->curve_data
->offset
= offsetof(struct pda_pa_curve_data
, data
);
336 priv
->curve_data
->len
= cd_len
;
337 memcpy(priv
->curve_data
->data
, curve_data
, sizeof(*curve_data
));
338 source
= curve_data
->data
;
339 target
= ((struct pda_pa_curve_data
*) priv
->curve_data
->data
)->data
;
340 for (i
= 0; i
< curve_data
->channels
; i
++) {
341 __le16
*freq
= source
;
342 source
+= sizeof(__le16
);
343 *((__le16
*)target
) = *freq
;
344 target
+= sizeof(__le16
);
345 for (j
= 0; j
< curve_data
->points_per_channel
; j
++) {
349 dst
->rf_power
= src
->rf_power
;
350 dst
->pa_detector
= src
->pa_detector
;
351 dst
->data_64qam
= src
->pcv
;
352 /* "invent" the points for the other modulations */
353 #define SUB(x, y) (u8)(((x) - (y)) > (x) ? 0 : (x) - (y))
354 dst
->data_16qam
= SUB(src
->pcv
, 12);
355 dst
->data_qpsk
= SUB(dst
->data_16qam
, 12);
356 dst
->data_bpsk
= SUB(dst
->data_qpsk
, 12);
357 dst
->data_barker
= SUB(dst
->data_bpsk
, 14);
359 target
+= sizeof(*dst
);
360 source
+= sizeof(*src
);
367 static int p54_convert_rev1(struct ieee80211_hw
*dev
,
368 struct pda_pa_curve_data
*curve_data
)
370 struct p54_common
*priv
= dev
->priv
;
371 struct p54_pa_curve_data_sample
*dst
;
372 struct pda_pa_curve_data_sample_rev1
*src
;
373 size_t cd_len
= sizeof(*curve_data
) +
374 (curve_data
->points_per_channel
*sizeof(*dst
) + 2) *
375 curve_data
->channels
;
377 void *source
, *target
;
379 priv
->curve_data
= kzalloc(cd_len
+ sizeof(*priv
->curve_data
),
381 if (!priv
->curve_data
)
384 priv
->curve_data
->entries
= curve_data
->channels
;
385 priv
->curve_data
->entry_size
= sizeof(__le16
) +
386 sizeof(*dst
) * curve_data
->points_per_channel
;
387 priv
->curve_data
->offset
= offsetof(struct pda_pa_curve_data
, data
);
388 priv
->curve_data
->len
= cd_len
;
389 memcpy(priv
->curve_data
->data
, curve_data
, sizeof(*curve_data
));
390 source
= curve_data
->data
;
391 target
= ((struct pda_pa_curve_data
*) priv
->curve_data
->data
)->data
;
392 for (i
= 0; i
< curve_data
->channels
; i
++) {
393 __le16
*freq
= source
;
394 source
+= sizeof(__le16
);
395 *((__le16
*)target
) = *freq
;
396 target
+= sizeof(__le16
);
397 for (j
= 0; j
< curve_data
->points_per_channel
; j
++) {
398 memcpy(target
, source
, sizeof(*src
));
400 target
+= sizeof(*dst
);
401 source
+= sizeof(*src
);
409 static const char *p54_rf_chips
[] = { "INVALID-0", "Duette3", "Duette2",
410 "Frisbee", "Xbow", "Longbow", "INVALID-6", "INVALID-7" };
412 static void p54_parse_rssical(struct ieee80211_hw
*dev
, void *data
, int len
,
415 struct p54_common
*priv
= dev
->priv
;
416 int offset
= (type
== PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED
) ? 2 : 0;
417 int entry_size
= sizeof(struct pda_rssi_cal_entry
) + offset
;
418 int num_entries
= (type
== PDR_RSSI_LINEAR_APPROXIMATION
) ? 1 : 2;
421 if (len
!= (entry_size
* num_entries
)) {
422 printk(KERN_ERR
"%s: unknown rssi calibration data packing "
423 " type:(%x) len:%d.\n",
424 wiphy_name(dev
->wiphy
), type
, len
);
426 print_hex_dump_bytes("rssical:", DUMP_PREFIX_NONE
,
429 printk(KERN_ERR
"%s: please report this issue.\n",
430 wiphy_name(dev
->wiphy
));
434 for (i
= 0; i
< num_entries
; i
++) {
435 struct pda_rssi_cal_entry
*cal
= data
+
436 (offset
+ i
* entry_size
);
437 priv
->rssical_db
[i
].mul
= (s16
) le16_to_cpu(cal
->mul
);
438 priv
->rssical_db
[i
].add
= (s16
) le16_to_cpu(cal
->add
);
442 static void p54_parse_default_country(struct ieee80211_hw
*dev
,
445 struct pda_country
*country
;
447 if (len
!= sizeof(*country
)) {
448 printk(KERN_ERR
"%s: found possible invalid default country "
449 "eeprom entry. (entry size: %d)\n",
450 wiphy_name(dev
->wiphy
), len
);
452 print_hex_dump_bytes("country:", DUMP_PREFIX_NONE
,
455 printk(KERN_ERR
"%s: please report this issue.\n",
456 wiphy_name(dev
->wiphy
));
460 country
= (struct pda_country
*) data
;
461 if (country
->flags
== PDR_COUNTRY_CERT_CODE_PSEUDO
)
462 regulatory_hint(dev
->wiphy
, country
->alpha2
);
465 * write a shared/common function that converts
466 * "Regulatory domain codes" (802.11-2007 14.8.2.2)
467 * into ISO/IEC 3166-1 alpha2 for regulatory_hint.
472 static int p54_convert_output_limits(struct ieee80211_hw
*dev
,
473 u8
*data
, size_t len
)
475 struct p54_common
*priv
= dev
->priv
;
481 printk(KERN_ERR
"%s: unknown output power db revision:%x\n",
482 wiphy_name(dev
->wiphy
), data
[0]);
486 if (2 + data
[1] * sizeof(struct pda_channel_output_limit
) > len
)
489 priv
->output_limit
= kmalloc(data
[1] *
490 sizeof(struct pda_channel_output_limit
) +
491 sizeof(*priv
->output_limit
), GFP_KERNEL
);
493 if (!priv
->output_limit
)
496 priv
->output_limit
->offset
= 0;
497 priv
->output_limit
->entries
= data
[1];
498 priv
->output_limit
->entry_size
=
499 sizeof(struct pda_channel_output_limit
);
500 priv
->output_limit
->len
= priv
->output_limit
->entry_size
*
501 priv
->output_limit
->entries
+
502 priv
->output_limit
->offset
;
504 memcpy(priv
->output_limit
->data
, &data
[2],
505 data
[1] * sizeof(struct pda_channel_output_limit
));
510 static struct p54_cal_database
*p54_convert_db(struct pda_custom_wrapper
*src
,
513 struct p54_cal_database
*dst
;
514 size_t payload_len
, entries
, entry_size
, offset
;
516 payload_len
= le16_to_cpu(src
->len
);
517 entries
= le16_to_cpu(src
->entries
);
518 entry_size
= le16_to_cpu(src
->entry_size
);
519 offset
= le16_to_cpu(src
->offset
);
520 if (((entries
* entry_size
+ offset
) != payload_len
) ||
521 (payload_len
+ sizeof(*src
) != total_len
))
524 dst
= kmalloc(sizeof(*dst
) + payload_len
, GFP_KERNEL
);
528 dst
->entries
= entries
;
529 dst
->entry_size
= entry_size
;
530 dst
->offset
= offset
;
531 dst
->len
= payload_len
;
533 memcpy(dst
->data
, src
->data
, payload_len
);
537 int p54_parse_eeprom(struct ieee80211_hw
*dev
, void *eeprom
, int len
)
539 struct p54_common
*priv
= dev
->priv
;
540 struct eeprom_pda_wrap
*wrap
;
541 struct pda_entry
*entry
;
542 unsigned int data_len
, entry_len
;
545 u8
*end
= (u8
*)eeprom
+ len
;
548 wrap
= (struct eeprom_pda_wrap
*) eeprom
;
549 entry
= (void *)wrap
->data
+ le16_to_cpu(wrap
->len
);
551 /* verify that at least the entry length/code fits */
552 while ((u8
*)entry
<= end
- sizeof(*entry
)) {
553 entry_len
= le16_to_cpu(entry
->len
);
554 data_len
= ((entry_len
- 1) << 1);
556 /* abort if entry exceeds whole structure */
557 if ((u8
*)entry
+ sizeof(*entry
) + data_len
> end
)
560 switch (le16_to_cpu(entry
->code
)) {
561 case PDR_MAC_ADDRESS
:
562 if (data_len
!= ETH_ALEN
)
564 SET_IEEE80211_PERM_ADDR(dev
, entry
->data
);
566 case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS
:
567 if (priv
->output_limit
)
569 err
= p54_convert_output_limits(dev
, entry
->data
,
574 case PDR_PRISM_PA_CAL_CURVE_DATA
: {
575 struct pda_pa_curve_data
*curve_data
=
576 (struct pda_pa_curve_data
*)entry
->data
;
577 if (data_len
< sizeof(*curve_data
)) {
582 switch (curve_data
->cal_method_rev
) {
584 err
= p54_convert_rev0(dev
, curve_data
);
587 err
= p54_convert_rev1(dev
, curve_data
);
590 printk(KERN_ERR
"%s: unknown curve data "
592 wiphy_name(dev
->wiphy
),
593 curve_data
->cal_method_rev
);
601 case PDR_PRISM_ZIF_TX_IQ_CALIBRATION
:
602 priv
->iq_autocal
= kmalloc(data_len
, GFP_KERNEL
);
603 if (!priv
->iq_autocal
) {
608 memcpy(priv
->iq_autocal
, entry
->data
, data_len
);
609 priv
->iq_autocal_len
= data_len
/ sizeof(struct pda_iq_autocal_entry
);
611 case PDR_DEFAULT_COUNTRY
:
612 p54_parse_default_country(dev
, entry
->data
, data_len
);
614 case PDR_INTERFACE_LIST
:
616 while ((u8
*)tmp
< entry
->data
+ data_len
) {
617 struct exp_if
*exp_if
= tmp
;
618 if (exp_if
->if_id
== cpu_to_le16(IF_ID_ISL39000
))
619 synth
= le16_to_cpu(exp_if
->variant
);
620 tmp
+= sizeof(*exp_if
);
623 case PDR_HARDWARE_PLATFORM_COMPONENT_ID
:
626 priv
->version
= *(u8
*)(entry
->data
+ 1);
628 case PDR_RSSI_LINEAR_APPROXIMATION
:
629 case PDR_RSSI_LINEAR_APPROXIMATION_DUAL_BAND
:
630 case PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED
:
631 p54_parse_rssical(dev
, entry
->data
, data_len
,
632 le16_to_cpu(entry
->code
));
634 case PDR_RSSI_LINEAR_APPROXIMATION_CUSTOM
: {
635 __le16
*src
= (void *) entry
->data
;
636 s16
*dst
= (void *) &priv
->rssical_db
;
639 if (data_len
!= sizeof(priv
->rssical_db
)) {
643 for (i
= 0; i
< sizeof(priv
->rssical_db
) /
645 *(dst
++) = (s16
) le16_to_cpu(*(src
++));
648 case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS_CUSTOM
: {
649 struct pda_custom_wrapper
*pda
= (void *) entry
->data
;
650 if (priv
->output_limit
|| data_len
< sizeof(*pda
))
652 priv
->output_limit
= p54_convert_db(pda
, data_len
);
655 case PDR_PRISM_PA_CAL_CURVE_DATA_CUSTOM
: {
656 struct pda_custom_wrapper
*pda
= (void *) entry
->data
;
657 if (priv
->curve_data
|| data_len
< sizeof(*pda
))
659 priv
->curve_data
= p54_convert_db(pda
, data_len
);
663 /* make it overrun */
670 entry
= (void *)entry
+ (entry_len
+ 1)*2;
673 if (!synth
|| !priv
->iq_autocal
|| !priv
->output_limit
||
675 printk(KERN_ERR
"%s: not all required entries found in eeprom!\n",
676 wiphy_name(dev
->wiphy
));
681 err
= p54_generate_channel_lists(dev
);
685 priv
->rxhw
= synth
& PDR_SYNTH_FRONTEND_MASK
;
686 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_XBOW
)
687 p54_init_xbow_synth(priv
);
688 if (!(synth
& PDR_SYNTH_24_GHZ_DISABLED
))
689 dev
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
690 priv
->band_table
[IEEE80211_BAND_2GHZ
];
691 if (!(synth
& PDR_SYNTH_5_GHZ_DISABLED
))
692 dev
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
693 priv
->band_table
[IEEE80211_BAND_5GHZ
];
694 if ((synth
& PDR_SYNTH_RX_DIV_MASK
) == PDR_SYNTH_RX_DIV_SUPPORTED
)
695 priv
->rx_diversity_mask
= 3;
696 if ((synth
& PDR_SYNTH_TX_DIV_MASK
) == PDR_SYNTH_TX_DIV_SUPPORTED
)
697 priv
->tx_diversity_mask
= 3;
699 if (!is_valid_ether_addr(dev
->wiphy
->perm_addr
)) {
700 u8 perm_addr
[ETH_ALEN
];
702 printk(KERN_WARNING
"%s: Invalid hwaddr! Using randomly generated MAC addr\n",
703 wiphy_name(dev
->wiphy
));
704 random_ether_addr(perm_addr
);
705 SET_IEEE80211_PERM_ADDR(dev
, perm_addr
);
708 printk(KERN_INFO
"%s: hwaddr %pM, MAC:isl38%02x RF:%s\n",
709 wiphy_name(dev
->wiphy
), dev
->wiphy
->perm_addr
, priv
->version
,
710 p54_rf_chips
[priv
->rxhw
]);
715 kfree(priv
->iq_autocal
);
716 kfree(priv
->output_limit
);
717 kfree(priv
->curve_data
);
718 priv
->iq_autocal
= NULL
;
719 priv
->output_limit
= NULL
;
720 priv
->curve_data
= NULL
;
722 printk(KERN_ERR
"%s: eeprom parse failed!\n",
723 wiphy_name(dev
->wiphy
));
726 EXPORT_SYMBOL_GPL(p54_parse_eeprom
);
728 int p54_read_eeprom(struct ieee80211_hw
*dev
)
730 struct p54_common
*priv
= dev
->priv
;
731 size_t eeprom_size
= 0x2020, offset
= 0, blocksize
, maxblocksize
;
735 maxblocksize
= EEPROM_READBACK_LEN
;
736 if (priv
->fw_var
>= 0x509)
741 eeprom
= kzalloc(eeprom_size
, GFP_KERNEL
);
742 if (unlikely(!eeprom
))
745 while (eeprom_size
) {
746 blocksize
= min(eeprom_size
, maxblocksize
);
747 ret
= p54_download_eeprom(priv
, (void *) (eeprom
+ offset
),
753 eeprom_size
-= blocksize
;
756 ret
= p54_parse_eeprom(dev
, eeprom
, offset
);
761 EXPORT_SYMBOL_GPL(p54_read_eeprom
);