Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / drivers / net / wireless / orinoco / hermes_dld.c
1 /*
2  * Hermes download helper driver.
3  *
4  * This could be entirely merged into hermes.c.
5  *
6  * I'm keeping it separate to minimise the amount of merging between
7  * kernel upgrades. It also means the memory overhead for drivers that
8  * don't need firmware download low.
9  *
10  * This driver:
11  *  - is capable of writing to the volatile area of the hermes device
12  *  - is currently not capable of writing to non-volatile areas
13  *  - provide helpers to identify and update plugin data
14  *  - is not capable of interpreting a fw image directly. That is up to
15  *    the main card driver.
16  *  - deals with Hermes I devices. It can probably be modified to deal
17  *    with Hermes II devices
18  *
19  * Copyright (C) 2007, David Kilroy
20  *
21  * Plug data code slightly modified from spectrum_cs driver
22  *    Copyright (C) 2002-2005 Pavel Roskin <proski@gnu.org>
23  * Portions based on information in wl_lkm_718 Agere driver
24  *    COPYRIGHT (C) 2001-2004 by Agere Systems Inc. All Rights Reserved
25  *
26  * The contents of this file are subject to the Mozilla Public License
27  * Version 1.1 (the "License"); you may not use this file except in
28  * compliance with the License. You may obtain a copy of the License
29  * at http://www.mozilla.org/MPL/
30  *
31  * Software distributed under the License is distributed on an "AS IS"
32  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
33  * the License for the specific language governing rights and
34  * limitations under the License.
35  *
36  * Alternatively, the contents of this file may be used under the
37  * terms of the GNU General Public License version 2 (the "GPL"), in
38  * which case the provisions of the GPL are applicable instead of the
39  * above.  If you wish to allow the use of your version of this file
40  * only under the terms of the GPL and not to allow others to use your
41  * version of this file under the MPL, indicate your decision by
42  * deleting the provisions above and replace them with the notice and
43  * other provisions required by the GPL.  If you do not delete the
44  * provisions above, a recipient may use your version of this file
45  * under either the MPL or the GPL.
46  */
47
48 #include <linux/module.h>
49 #include <linux/delay.h>
50 #include "hermes.h"
51 #include "hermes_dld.h"
52
53 MODULE_DESCRIPTION("Download helper for Lucent Hermes chipset");
54 MODULE_AUTHOR("David Kilroy <kilroyd@gmail.com>");
55 MODULE_LICENSE("Dual MPL/GPL");
56
57 #define PFX "hermes_dld: "
58
59 /*
60  * AUX port access.  To unlock the AUX port write the access keys to the
61  * PARAM0-2 registers, then write HERMES_AUX_ENABLE to the HERMES_CONTROL
62  * register.  Then read it and make sure it's HERMES_AUX_ENABLED.
63  */
64 #define HERMES_AUX_ENABLE       0x8000  /* Enable auxiliary port access */
65 #define HERMES_AUX_DISABLE      0x4000  /* Disable to auxiliary port access */
66 #define HERMES_AUX_ENABLED      0xC000  /* Auxiliary port is open */
67 #define HERMES_AUX_DISABLED     0x0000  /* Auxiliary port is closed */
68
69 #define HERMES_AUX_PW0  0xFE01
70 #define HERMES_AUX_PW1  0xDC23
71 #define HERMES_AUX_PW2  0xBA45
72
73 /* HERMES_CMD_DOWNLD */
74 #define HERMES_PROGRAM_DISABLE             (0x0000 | HERMES_CMD_DOWNLD)
75 #define HERMES_PROGRAM_ENABLE_VOLATILE     (0x0100 | HERMES_CMD_DOWNLD)
76 #define HERMES_PROGRAM_ENABLE_NON_VOLATILE (0x0200 | HERMES_CMD_DOWNLD)
77 #define HERMES_PROGRAM_NON_VOLATILE        (0x0300 | HERMES_CMD_DOWNLD)
78
79 /* End markers used in dblocks */
80 #define PDI_END         0x00000000      /* End of PDA */
81 #define BLOCK_END       0xFFFFFFFF      /* Last image block */
82 #define TEXT_END        0x1A            /* End of text header */
83
84 /*
85  * PDA == Production Data Area
86  *
87  * In principle, the max. size of the PDA is is 4096 words. Currently,
88  * however, only about 500 bytes of this area are used.
89  *
90  * Some USB implementations can't handle sizes in excess of 1016. Note
91  * that PDA is not actually used in those USB environments, but may be
92  * retrieved by common code.
93  */
94 #define MAX_PDA_SIZE    1000
95
96 /* Limit the amout we try to download in a single shot.
97  * Size is in bytes.
98  */
99 #define MAX_DL_SIZE 1024
100 #define LIMIT_PROGRAM_SIZE 0
101
102 /*
103  * The following structures have little-endian fields denoted by
104  * the leading underscore.  Don't access them directly - use inline
105  * functions defined below.
106  */
107
108 /*
109  * The binary image to be downloaded consists of series of data blocks.
110  * Each block has the following structure.
111  */
112 struct dblock {
113         __le32 addr;            /* adapter address where to write the block */
114         __le16 len;             /* length of the data only, in bytes */
115         char data[0];           /* data to be written */
116 } __attribute__ ((packed));
117
118 /*
119  * Plug Data References are located in in the image after the last data
120  * block.  They refer to areas in the adapter memory where the plug data
121  * items with matching ID should be written.
122  */
123 struct pdr {
124         __le32 id;              /* record ID */
125         __le32 addr;            /* adapter address where to write the data */
126         __le32 len;             /* expected length of the data, in bytes */
127         char next[0];           /* next PDR starts here */
128 } __attribute__ ((packed));
129
130 /*
131  * Plug Data Items are located in the EEPROM read from the adapter by
132  * primary firmware.  They refer to the device-specific data that should
133  * be plugged into the secondary firmware.
134  */
135 struct pdi {
136         __le16 len;             /* length of ID and data, in words */
137         __le16 id;              /* record ID */
138         char data[0];           /* plug data */
139 } __attribute__ ((packed));
140
141 /*** FW data block access functions ***/
142
143 static inline u32
144 dblock_addr(const struct dblock *blk)
145 {
146         return le32_to_cpu(blk->addr);
147 }
148
149 static inline u32
150 dblock_len(const struct dblock *blk)
151 {
152         return le16_to_cpu(blk->len);
153 }
154
155 /*** PDR Access functions ***/
156
157 static inline u32
158 pdr_id(const struct pdr *pdr)
159 {
160         return le32_to_cpu(pdr->id);
161 }
162
163 static inline u32
164 pdr_addr(const struct pdr *pdr)
165 {
166         return le32_to_cpu(pdr->addr);
167 }
168
169 static inline u32
170 pdr_len(const struct pdr *pdr)
171 {
172         return le32_to_cpu(pdr->len);
173 }
174
175 /*** PDI Access functions ***/
176
177 static inline u32
178 pdi_id(const struct pdi *pdi)
179 {
180         return le16_to_cpu(pdi->id);
181 }
182
183 /* Return length of the data only, in bytes */
184 static inline u32
185 pdi_len(const struct pdi *pdi)
186 {
187         return 2 * (le16_to_cpu(pdi->len) - 1);
188 }
189
190 /*** Hermes AUX control ***/
191
192 static inline void
193 hermes_aux_setaddr(hermes_t *hw, u32 addr)
194 {
195         hermes_write_reg(hw, HERMES_AUXPAGE, (u16) (addr >> 7));
196         hermes_write_reg(hw, HERMES_AUXOFFSET, (u16) (addr & 0x7F));
197 }
198
199 static inline int
200 hermes_aux_control(hermes_t *hw, int enabled)
201 {
202         int desired_state = enabled ? HERMES_AUX_ENABLED : HERMES_AUX_DISABLED;
203         int action = enabled ? HERMES_AUX_ENABLE : HERMES_AUX_DISABLE;
204         int i;
205
206         /* Already open? */
207         if (hermes_read_reg(hw, HERMES_CONTROL) == desired_state)
208                 return 0;
209
210         hermes_write_reg(hw, HERMES_PARAM0, HERMES_AUX_PW0);
211         hermes_write_reg(hw, HERMES_PARAM1, HERMES_AUX_PW1);
212         hermes_write_reg(hw, HERMES_PARAM2, HERMES_AUX_PW2);
213         hermes_write_reg(hw, HERMES_CONTROL, action);
214
215         for (i = 0; i < 20; i++) {
216                 udelay(10);
217                 if (hermes_read_reg(hw, HERMES_CONTROL) ==
218                     desired_state)
219                         return 0;
220         }
221
222         return -EBUSY;
223 }
224
225 /*** Plug Data Functions ***/
226
227 /*
228  * Scan PDR for the record with the specified RECORD_ID.
229  * If it's not found, return NULL.
230  */
231 static struct pdr *
232 hermes_find_pdr(struct pdr *first_pdr, u32 record_id)
233 {
234         struct pdr *pdr = first_pdr;
235         void *end = (void *)first_pdr + MAX_PDA_SIZE;
236
237         while (((void *)pdr < end) &&
238                (pdr_id(pdr) != PDI_END)) {
239                 /*
240                  * PDR area is currently not terminated by PDI_END.
241                  * It's followed by CRC records, which have the type
242                  * field where PDR has length.  The type can be 0 or 1.
243                  */
244                 if (pdr_len(pdr) < 2)
245                         return NULL;
246
247                 /* If the record ID matches, we are done */
248                 if (pdr_id(pdr) == record_id)
249                         return pdr;
250
251                 pdr = (struct pdr *) pdr->next;
252         }
253         return NULL;
254 }
255
256 /* Scan production data items for a particular entry */
257 static struct pdi *
258 hermes_find_pdi(struct pdi *first_pdi, u32 record_id)
259 {
260         struct pdi *pdi = first_pdi;
261
262         while (pdi_id(pdi) != PDI_END) {
263
264                 /* If the record ID matches, we are done */
265                 if (pdi_id(pdi) == record_id)
266                         return pdi;
267
268                 pdi = (struct pdi *) &pdi->data[pdi_len(pdi)];
269         }
270         return NULL;
271 }
272
273 /* Process one Plug Data Item - find corresponding PDR and plug it */
274 static int
275 hermes_plug_pdi(hermes_t *hw, struct pdr *first_pdr, const struct pdi *pdi)
276 {
277         struct pdr *pdr;
278
279         /* Find the PDR corresponding to this PDI */
280         pdr = hermes_find_pdr(first_pdr, pdi_id(pdi));
281
282         /* No match is found, safe to ignore */
283         if (!pdr)
284                 return 0;
285
286         /* Lengths of the data in PDI and PDR must match */
287         if (pdi_len(pdi) != pdr_len(pdr))
288                 return -EINVAL;
289
290         /* do the actual plugging */
291         hermes_aux_setaddr(hw, pdr_addr(pdr));
292         hermes_write_bytes(hw, HERMES_AUXDATA, pdi->data, pdi_len(pdi));
293
294         return 0;
295 }
296
297 /* Read PDA from the adapter */
298 int hermes_read_pda(hermes_t *hw,
299                     __le16 *pda,
300                     u32 pda_addr,
301                     u16 pda_len,
302                     int use_eeprom) /* can we get this into hw? */
303 {
304         int ret;
305         u16 pda_size;
306         u16 data_len = pda_len;
307         __le16 *data = pda;
308
309         if (use_eeprom) {
310                 /* PDA of spectrum symbol is in eeprom */
311
312                 /* Issue command to read EEPROM */
313                 ret = hermes_docmd_wait(hw, HERMES_CMD_READMIF, 0, NULL);
314                 if (ret)
315                         return ret;
316         } else {
317                 /* wl_lkm does not include PDA size in the PDA area.
318                  * We will pad the information into pda, so other routines
319                  * don't have to be modified */
320                 pda[0] = cpu_to_le16(pda_len - 2);
321                         /* Includes CFG_PROD_DATA but not itself */
322                 pda[1] = cpu_to_le16(0x0800); /* CFG_PROD_DATA */
323                 data_len = pda_len - 4;
324                 data = pda + 2;
325         }
326
327         /* Open auxiliary port */
328         ret = hermes_aux_control(hw, 1);
329         printk(KERN_DEBUG PFX "AUX enable returned %d\n", ret);
330         if (ret)
331                 return ret;
332
333         /* read PDA from EEPROM */
334         hermes_aux_setaddr(hw, pda_addr);
335         hermes_read_words(hw, HERMES_AUXDATA, data, data_len / 2);
336
337         /* Close aux port */
338         ret = hermes_aux_control(hw, 0);
339         printk(KERN_DEBUG PFX "AUX disable returned %d\n", ret);
340
341         /* Check PDA length */
342         pda_size = le16_to_cpu(pda[0]);
343         printk(KERN_DEBUG PFX "Actual PDA length %d, Max allowed %d\n",
344                pda_size, pda_len);
345         if (pda_size > pda_len)
346                 return -EINVAL;
347
348         return 0;
349 }
350 EXPORT_SYMBOL(hermes_read_pda);
351
352 /* Parse PDA and write the records into the adapter
353  *
354  * Attempt to write every records that is in the specified pda
355  * which also has a valid production data record for the firmware.
356  */
357 int hermes_apply_pda(hermes_t *hw,
358                      const char *first_pdr,
359                      const __le16 *pda)
360 {
361         int ret;
362         const struct pdi *pdi;
363         struct pdr *pdr;
364
365         pdr = (struct pdr *) first_pdr;
366
367         /* Go through every PDI and plug them into the adapter */
368         pdi = (const struct pdi *) (pda + 2);
369         while (pdi_id(pdi) != PDI_END) {
370                 ret = hermes_plug_pdi(hw, pdr, pdi);
371                 if (ret)
372                         return ret;
373
374                 /* Increment to the next PDI */
375                 pdi = (const struct pdi *) &pdi->data[pdi_len(pdi)];
376         }
377         return 0;
378 }
379 EXPORT_SYMBOL(hermes_apply_pda);
380
381 /* Identify the total number of bytes in all blocks
382  * including the header data.
383  */
384 size_t
385 hermes_blocks_length(const char *first_block)
386 {
387         const struct dblock *blk = (const struct dblock *) first_block;
388         int total_len = 0;
389         int len;
390
391         /* Skip all blocks to locate Plug Data References
392          * (Spectrum CS) */
393         while (dblock_addr(blk) != BLOCK_END) {
394                 len = dblock_len(blk);
395                 total_len += sizeof(*blk) + len;
396                 blk = (struct dblock *) &blk->data[len];
397         }
398
399         return total_len;
400 }
401 EXPORT_SYMBOL(hermes_blocks_length);
402
403 /*** Hermes programming ***/
404
405 /* About to start programming data (Hermes I)
406  * offset is the entry point
407  *
408  * Spectrum_cs' Symbol fw does not require this
409  * wl_lkm Agere fw does
410  * Don't know about intersil
411  */
412 int hermesi_program_init(hermes_t *hw, u32 offset)
413 {
414         int err;
415
416         /* Disable interrupts?*/
417         /*hw->inten = 0x0;*/
418         /*hermes_write_regn(hw, INTEN, 0);*/
419         /*hermes_set_irqmask(hw, 0);*/
420
421         /* Acknowledge any outstanding command */
422         hermes_write_regn(hw, EVACK, 0xFFFF);
423
424         /* Using doicmd_wait rather than docmd_wait */
425         err = hermes_doicmd_wait(hw,
426                                  0x0100 | HERMES_CMD_INIT,
427                                  0, 0, 0, NULL);
428         if (err)
429                 return err;
430
431         err = hermes_doicmd_wait(hw,
432                                  0x0000 | HERMES_CMD_INIT,
433                                  0, 0, 0, NULL);
434         if (err)
435                 return err;
436
437         err = hermes_aux_control(hw, 1);
438         printk(KERN_DEBUG PFX "AUX enable returned %d\n", err);
439
440         if (err)
441                 return err;
442
443         printk(KERN_DEBUG PFX "Enabling volatile, EP 0x%08x\n", offset);
444         err = hermes_doicmd_wait(hw,
445                                  HERMES_PROGRAM_ENABLE_VOLATILE,
446                                  offset & 0xFFFFu,
447                                  offset >> 16,
448                                  0,
449                                  NULL);
450         printk(KERN_DEBUG PFX "PROGRAM_ENABLE returned %d\n",
451                err);
452
453         return err;
454 }
455 EXPORT_SYMBOL(hermesi_program_init);
456
457 /* Done programming data (Hermes I)
458  *
459  * Spectrum_cs' Symbol fw does not require this
460  * wl_lkm Agere fw does
461  * Don't know about intersil
462  */
463 int hermesi_program_end(hermes_t *hw)
464 {
465         struct hermes_response resp;
466         int rc = 0;
467         int err;
468
469         rc = hermes_docmd_wait(hw, HERMES_PROGRAM_DISABLE, 0, &resp);
470
471         printk(KERN_DEBUG PFX "PROGRAM_DISABLE returned %d, "
472                "r0 0x%04x, r1 0x%04x, r2 0x%04x\n",
473                rc, resp.resp0, resp.resp1, resp.resp2);
474
475         if ((rc == 0) &&
476             ((resp.status & HERMES_STATUS_CMDCODE) != HERMES_CMD_DOWNLD))
477                 rc = -EIO;
478
479         err = hermes_aux_control(hw, 0);
480         printk(KERN_DEBUG PFX "AUX disable returned %d\n", err);
481
482         /* Acknowledge any outstanding command */
483         hermes_write_regn(hw, EVACK, 0xFFFF);
484
485         /* Reinitialise, ignoring return */
486         (void) hermes_doicmd_wait(hw, 0x0000 | HERMES_CMD_INIT,
487                                   0, 0, 0, NULL);
488
489         return rc ? rc : err;
490 }
491 EXPORT_SYMBOL(hermesi_program_end);
492
493 /* Program the data blocks */
494 int hermes_program(hermes_t *hw, const char *first_block, const char *end)
495 {
496         const struct dblock *blk;
497         u32 blkaddr;
498         u32 blklen;
499 #if LIMIT_PROGRAM_SIZE
500         u32 addr;
501         u32 len;
502 #endif
503
504         blk = (const struct dblock *) first_block;
505
506         if ((const char *) blk > (end - sizeof(*blk)))
507                 return -EIO;
508
509         blkaddr = dblock_addr(blk);
510         blklen = dblock_len(blk);
511
512         while ((blkaddr != BLOCK_END) &&
513                (((const char *) blk + blklen) <= end)) {
514                 printk(KERN_DEBUG PFX
515                        "Programming block of length %d to address 0x%08x\n",
516                        blklen, blkaddr);
517
518 #if !LIMIT_PROGRAM_SIZE
519                 /* wl_lkm driver splits this into writes of 2000 bytes */
520                 hermes_aux_setaddr(hw, blkaddr);
521                 hermes_write_bytes(hw, HERMES_AUXDATA, blk->data,
522                                    blklen);
523 #else
524                 len = (blklen < MAX_DL_SIZE) ? blklen : MAX_DL_SIZE;
525                 addr = blkaddr;
526
527                 while (addr < (blkaddr + blklen)) {
528                         printk(KERN_DEBUG PFX
529                                "Programming subblock of length %d "
530                                "to address 0x%08x. Data @ %p\n",
531                                len, addr, &blk->data[addr - blkaddr]);
532
533                         hermes_aux_setaddr(hw, addr);
534                         hermes_write_bytes(hw, HERMES_AUXDATA,
535                                            &blk->data[addr - blkaddr],
536                                            len);
537
538                         addr += len;
539                         len = ((blkaddr + blklen - addr) < MAX_DL_SIZE) ?
540                                 (blkaddr + blklen - addr) : MAX_DL_SIZE;
541                 }
542 #endif
543                 blk = (const struct dblock *) &blk->data[blklen];
544
545                 if ((const char *) blk > (end - sizeof(*blk)))
546                         return -EIO;
547
548                 blkaddr = dblock_addr(blk);
549                 blklen = dblock_len(blk);
550         }
551         return 0;
552 }
553 EXPORT_SYMBOL(hermes_program);
554
555 static int __init init_hermes_dld(void)
556 {
557         return 0;
558 }
559
560 static void __exit exit_hermes_dld(void)
561 {
562 }
563
564 module_init(init_hermes_dld);
565 module_exit(exit_hermes_dld);
566
567 /*** Default plugging data for Hermes I ***/
568 /* Values from wl_lkm_718/hcf/dhf.c */
569
570 #define DEFINE_DEFAULT_PDR(pid, length, data)                           \
571 static const struct {                                                   \
572         __le16 len;                                                     \
573         __le16 id;                                                      \
574         u8 val[length];                                                 \
575 } __attribute__ ((packed)) default_pdr_data_##pid = {                   \
576         __constant_cpu_to_le16((sizeof(default_pdr_data_##pid)/         \
577                                 sizeof(__le16)) - 1),                   \
578         __constant_cpu_to_le16(pid),                                    \
579         data                                                            \
580 }
581
582 #define DEFAULT_PDR(pid) default_pdr_data_##pid
583
584 /*  HWIF Compatiblity */
585 DEFINE_DEFAULT_PDR(0x0005, 10, "\x00\x00\x06\x00\x01\x00\x01\x00\x01\x00");
586
587 /* PPPPSign */
588 DEFINE_DEFAULT_PDR(0x0108, 4, "\x00\x00\x00\x00");
589
590 /* PPPPProf */
591 DEFINE_DEFAULT_PDR(0x0109, 10, "\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00");
592
593 /* Antenna diversity */
594 DEFINE_DEFAULT_PDR(0x0150, 2, "\x00\x3F");
595
596 /* Modem VCO band Set-up */
597 DEFINE_DEFAULT_PDR(0x0160, 28,
598                    "\x00\x00\x00\x00\x00\x00\x00\x00"
599                    "\x00\x00\x00\x00\x00\x00\x00\x00"
600                    "\x00\x00\x00\x00\x00\x00\x00\x00"
601                    "\x00\x00\x00\x00");
602
603 /* Modem Rx Gain Table Values */
604 DEFINE_DEFAULT_PDR(0x0161, 256,
605                    "\x3F\x01\x3F\01\x3F\x01\x3F\x01"
606                    "\x3F\x01\x3F\01\x3F\x01\x3F\x01"
607                    "\x3F\x01\x3F\01\x3F\x01\x3F\x01"
608                    "\x3F\x01\x3F\01\x3F\x01\x3F\x01"
609                    "\x3F\x01\x3E\01\x3E\x01\x3D\x01"
610                    "\x3D\x01\x3C\01\x3C\x01\x3B\x01"
611                    "\x3B\x01\x3A\01\x3A\x01\x39\x01"
612                    "\x39\x01\x38\01\x38\x01\x37\x01"
613                    "\x37\x01\x36\01\x36\x01\x35\x01"
614                    "\x35\x01\x34\01\x34\x01\x33\x01"
615                    "\x33\x01\x32\x01\x32\x01\x31\x01"
616                    "\x31\x01\x30\x01\x30\x01\x7B\x01"
617                    "\x7B\x01\x7A\x01\x7A\x01\x79\x01"
618                    "\x79\x01\x78\x01\x78\x01\x77\x01"
619                    "\x77\x01\x76\x01\x76\x01\x75\x01"
620                    "\x75\x01\x74\x01\x74\x01\x73\x01"
621                    "\x73\x01\x72\x01\x72\x01\x71\x01"
622                    "\x71\x01\x70\x01\x70\x01\x68\x01"
623                    "\x68\x01\x67\x01\x67\x01\x66\x01"
624                    "\x66\x01\x65\x01\x65\x01\x57\x01"
625                    "\x57\x01\x56\x01\x56\x01\x55\x01"
626                    "\x55\x01\x54\x01\x54\x01\x53\x01"
627                    "\x53\x01\x52\x01\x52\x01\x51\x01"
628                    "\x51\x01\x50\x01\x50\x01\x48\x01"
629                    "\x48\x01\x47\x01\x47\x01\x46\x01"
630                    "\x46\x01\x45\x01\x45\x01\x44\x01"
631                    "\x44\x01\x43\x01\x43\x01\x42\x01"
632                    "\x42\x01\x41\x01\x41\x01\x40\x01"
633                    "\x40\x01\x40\x01\x40\x01\x40\x01"
634                    "\x40\x01\x40\x01\x40\x01\x40\x01"
635                    "\x40\x01\x40\x01\x40\x01\x40\x01"
636                    "\x40\x01\x40\x01\x40\x01\x40\x01");
637
638 /* Write PDA according to certain rules.
639  *
640  * For every production data record, look for a previous setting in
641  * the pda, and use that.
642  *
643  * For certain records, use defaults if they are not found in pda.
644  */
645 int hermes_apply_pda_with_defaults(hermes_t *hw,
646                                    const char *first_pdr,
647                                    const __le16 *pda)
648 {
649         const struct pdr *pdr = (const struct pdr *) first_pdr;
650         struct pdi *first_pdi = (struct pdi *) &pda[2];
651         struct pdi *pdi;
652         struct pdi *default_pdi = NULL;
653         struct pdi *outdoor_pdi;
654         void *end = (void *)first_pdr + MAX_PDA_SIZE;
655         int record_id;
656
657         while (((void *)pdr < end) &&
658                (pdr_id(pdr) != PDI_END)) {
659                 /*
660                  * For spectrum_cs firmwares,
661                  * PDR area is currently not terminated by PDI_END.
662                  * It's followed by CRC records, which have the type
663                  * field where PDR has length.  The type can be 0 or 1.
664                  */
665                 if (pdr_len(pdr) < 2)
666                         break;
667                 record_id = pdr_id(pdr);
668
669                 pdi = hermes_find_pdi(first_pdi, record_id);
670                 if (pdi)
671                         printk(KERN_DEBUG PFX "Found record 0x%04x at %p\n",
672                                record_id, pdi);
673
674                 switch (record_id) {
675                 case 0x110: /* Modem REFDAC values */
676                 case 0x120: /* Modem VGDAC values */
677                         outdoor_pdi = hermes_find_pdi(first_pdi, record_id + 1);
678                         default_pdi = NULL;
679                         if (outdoor_pdi) {
680                                 pdi = outdoor_pdi;
681                                 printk(KERN_DEBUG PFX
682                                        "Using outdoor record 0x%04x at %p\n",
683                                        record_id + 1, pdi);
684                         }
685                         break;
686                 case 0x5: /*  HWIF Compatiblity */
687                         default_pdi = (struct pdi *) &DEFAULT_PDR(0x0005);
688                         break;
689                 case 0x108: /* PPPPSign */
690                         default_pdi = (struct pdi *) &DEFAULT_PDR(0x0108);
691                         break;
692                 case 0x109: /* PPPPProf */
693                         default_pdi = (struct pdi *) &DEFAULT_PDR(0x0109);
694                         break;
695                 case 0x150: /* Antenna diversity */
696                         default_pdi = (struct pdi *) &DEFAULT_PDR(0x0150);
697                         break;
698                 case 0x160: /* Modem VCO band Set-up */
699                         default_pdi = (struct pdi *) &DEFAULT_PDR(0x0160);
700                         break;
701                 case 0x161: /* Modem Rx Gain Table Values */
702                         default_pdi = (struct pdi *) &DEFAULT_PDR(0x0161);
703                         break;
704                 default:
705                         default_pdi = NULL;
706                         break;
707                 }
708                 if (!pdi && default_pdi) {
709                         /* Use default */
710                         pdi = default_pdi;
711                         printk(KERN_DEBUG PFX
712                                "Using default record 0x%04x at %p\n",
713                                record_id, pdi);
714                 }
715
716                 if (pdi) {
717                         /* Lengths of the data in PDI and PDR must match */
718                         if (pdi_len(pdi) == pdr_len(pdr)) {
719                                 /* do the actual plugging */
720                                 hermes_aux_setaddr(hw, pdr_addr(pdr));
721                                 hermes_write_bytes(hw, HERMES_AUXDATA,
722                                                    pdi->data, pdi_len(pdi));
723                         }
724                 }
725
726                 pdr++;
727         }
728         return 0;
729 }
730 EXPORT_SYMBOL(hermes_apply_pda_with_defaults);