1 // SPDX-License-Identifier: GPL-2.0
prism2_enable_aux_port(struct net_device * dev,int enable)2 static int prism2_enable_aux_port(struct net_device *dev, int enable)
3 {
4 u16 val, reg;
5 int i, tries;
6 unsigned long flags;
7 struct hostap_interface *iface;
8 local_info_t *local;
9
10 iface = netdev_priv(dev);
11 local = iface->local;
12
13 if (local->no_pri) {
14 if (enable) {
15 PDEBUG(DEBUG_EXTRA2, "%s: no PRI f/w - assuming Aux "
16 "port is already enabled\n", dev->name);
17 }
18 return 0;
19 }
20
21 spin_lock_irqsave(&local->cmdlock, flags);
22
23 /* wait until busy bit is clear */
24 tries = HFA384X_CMD_BUSY_TIMEOUT;
25 while (HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY && tries > 0) {
26 tries--;
27 udelay(1);
28 }
29 if (tries == 0) {
30 reg = HFA384X_INW(HFA384X_CMD_OFF);
31 spin_unlock_irqrestore(&local->cmdlock, flags);
32 printk("%s: prism2_enable_aux_port - timeout - reg=0x%04x\n",
33 dev->name, reg);
34 return -ETIMEDOUT;
35 }
36
37 val = HFA384X_INW(HFA384X_CONTROL_OFF);
38
39 if (enable) {
40 HFA384X_OUTW(HFA384X_AUX_MAGIC0, HFA384X_PARAM0_OFF);
41 HFA384X_OUTW(HFA384X_AUX_MAGIC1, HFA384X_PARAM1_OFF);
42 HFA384X_OUTW(HFA384X_AUX_MAGIC2, HFA384X_PARAM2_OFF);
43
44 if ((val & HFA384X_AUX_PORT_MASK) != HFA384X_AUX_PORT_DISABLED)
45 printk("prism2_enable_aux_port: was not disabled!?\n");
46 val &= ~HFA384X_AUX_PORT_MASK;
47 val |= HFA384X_AUX_PORT_ENABLE;
48 } else {
49 HFA384X_OUTW(0, HFA384X_PARAM0_OFF);
50 HFA384X_OUTW(0, HFA384X_PARAM1_OFF);
51 HFA384X_OUTW(0, HFA384X_PARAM2_OFF);
52
53 if ((val & HFA384X_AUX_PORT_MASK) != HFA384X_AUX_PORT_ENABLED)
54 printk("prism2_enable_aux_port: was not enabled!?\n");
55 val &= ~HFA384X_AUX_PORT_MASK;
56 val |= HFA384X_AUX_PORT_DISABLE;
57 }
58 HFA384X_OUTW(val, HFA384X_CONTROL_OFF);
59
60 udelay(5);
61
62 i = 10000;
63 while (i > 0) {
64 val = HFA384X_INW(HFA384X_CONTROL_OFF);
65 val &= HFA384X_AUX_PORT_MASK;
66
67 if ((enable && val == HFA384X_AUX_PORT_ENABLED) ||
68 (!enable && val == HFA384X_AUX_PORT_DISABLED))
69 break;
70
71 udelay(10);
72 i--;
73 }
74
75 spin_unlock_irqrestore(&local->cmdlock, flags);
76
77 if (i == 0) {
78 printk("prism2_enable_aux_port(%d) timed out\n",
79 enable);
80 return -ETIMEDOUT;
81 }
82
83 return 0;
84 }
85
86
hfa384x_from_aux(struct net_device * dev,unsigned int addr,int len,void * buf)87 static int hfa384x_from_aux(struct net_device *dev, unsigned int addr, int len,
88 void *buf)
89 {
90 u16 page, offset;
91 if (addr & 1 || len & 1)
92 return -1;
93
94 page = addr >> 7;
95 offset = addr & 0x7f;
96
97 HFA384X_OUTW(page, HFA384X_AUXPAGE_OFF);
98 HFA384X_OUTW(offset, HFA384X_AUXOFFSET_OFF);
99
100 udelay(5);
101
102 #ifdef PRISM2_PCI
103 {
104 __le16 *pos = (__le16 *) buf;
105 while (len > 0) {
106 *pos++ = HFA384X_INW_DATA(HFA384X_AUXDATA_OFF);
107 len -= 2;
108 }
109 }
110 #else /* PRISM2_PCI */
111 HFA384X_INSW(HFA384X_AUXDATA_OFF, buf, len / 2);
112 #endif /* PRISM2_PCI */
113
114 return 0;
115 }
116
117
hfa384x_to_aux(struct net_device * dev,unsigned int addr,int len,void * buf)118 static int hfa384x_to_aux(struct net_device *dev, unsigned int addr, int len,
119 void *buf)
120 {
121 u16 page, offset;
122 if (addr & 1 || len & 1)
123 return -1;
124
125 page = addr >> 7;
126 offset = addr & 0x7f;
127
128 HFA384X_OUTW(page, HFA384X_AUXPAGE_OFF);
129 HFA384X_OUTW(offset, HFA384X_AUXOFFSET_OFF);
130
131 udelay(5);
132
133 #ifdef PRISM2_PCI
134 {
135 __le16 *pos = (__le16 *) buf;
136 while (len > 0) {
137 HFA384X_OUTW_DATA(*pos++, HFA384X_AUXDATA_OFF);
138 len -= 2;
139 }
140 }
141 #else /* PRISM2_PCI */
142 HFA384X_OUTSW(HFA384X_AUXDATA_OFF, buf, len / 2);
143 #endif /* PRISM2_PCI */
144
145 return 0;
146 }
147
148
prism2_pda_ok(u8 * buf)149 static int prism2_pda_ok(u8 *buf)
150 {
151 __le16 *pda = (__le16 *) buf;
152 int pos;
153 u16 len, pdr;
154
155 if (buf[0] == 0xff && buf[1] == 0x00 && buf[2] == 0xff &&
156 buf[3] == 0x00)
157 return 0;
158
159 pos = 0;
160 while (pos + 1 < PRISM2_PDA_SIZE / 2) {
161 len = le16_to_cpu(pda[pos]);
162 pdr = le16_to_cpu(pda[pos + 1]);
163 if (len == 0 || pos + len > PRISM2_PDA_SIZE / 2)
164 return 0;
165
166 if (pdr == 0x0000 && len == 2) {
167 /* PDA end found */
168 return 1;
169 }
170
171 pos += len + 1;
172 }
173
174 return 0;
175 }
176
177
178 #define prism2_download_aux_dump_npages 65536
179
180 struct prism2_download_aux_dump {
181 local_info_t *local;
182 u16 page[0x80];
183 };
184
prism2_download_aux_dump_proc_show(struct seq_file * m,void * v)185 static int prism2_download_aux_dump_proc_show(struct seq_file *m, void *v)
186 {
187 struct prism2_download_aux_dump *ctx = m->private;
188
189 hfa384x_from_aux(ctx->local->dev, (unsigned long)v - 1, 0x80, ctx->page);
190 seq_write(m, ctx->page, 0x80);
191 return 0;
192 }
193
prism2_download_aux_dump_proc_start(struct seq_file * m,loff_t * _pos)194 static void *prism2_download_aux_dump_proc_start(struct seq_file *m, loff_t *_pos)
195 {
196 struct prism2_download_aux_dump *ctx = m->private;
197 prism2_enable_aux_port(ctx->local->dev, 1);
198 if (*_pos >= prism2_download_aux_dump_npages)
199 return NULL;
200 return (void *)((unsigned long)*_pos + 1);
201 }
202
prism2_download_aux_dump_proc_next(struct seq_file * m,void * v,loff_t * _pos)203 static void *prism2_download_aux_dump_proc_next(struct seq_file *m, void *v, loff_t *_pos)
204 {
205 ++*_pos;
206 if (*_pos >= prism2_download_aux_dump_npages)
207 return NULL;
208 return (void *)((unsigned long)*_pos + 1);
209 }
210
prism2_download_aux_dump_proc_stop(struct seq_file * m,void * v)211 static void prism2_download_aux_dump_proc_stop(struct seq_file *m, void *v)
212 {
213 struct prism2_download_aux_dump *ctx = m->private;
214 prism2_enable_aux_port(ctx->local->dev, 0);
215 }
216
217 static const struct seq_operations prism2_download_aux_dump_proc_seqops = {
218 .start = prism2_download_aux_dump_proc_start,
219 .next = prism2_download_aux_dump_proc_next,
220 .stop = prism2_download_aux_dump_proc_stop,
221 .show = prism2_download_aux_dump_proc_show,
222 };
223
prism2_download_aux_dump_proc_open(struct inode * inode,struct file * file)224 static int prism2_download_aux_dump_proc_open(struct inode *inode, struct file *file)
225 {
226 int ret = seq_open_private(file, &prism2_download_aux_dump_proc_seqops,
227 sizeof(struct prism2_download_aux_dump));
228 if (ret == 0) {
229 struct seq_file *m = file->private_data;
230 m->private = pde_data(inode);
231 }
232 return ret;
233 }
234
235 static const struct proc_ops prism2_download_aux_dump_proc_ops = {
236 .proc_open = prism2_download_aux_dump_proc_open,
237 .proc_read = seq_read,
238 .proc_lseek = seq_lseek,
239 .proc_release = seq_release_private,
240 };
241
242
prism2_read_pda(struct net_device * dev)243 static u8 * prism2_read_pda(struct net_device *dev)
244 {
245 u8 *buf;
246 int res, i, found = 0;
247 #define NUM_PDA_ADDRS 4
248 unsigned int pda_addr[NUM_PDA_ADDRS] = {
249 0x7f0000 /* others than HFA3841 */,
250 0x3f0000 /* HFA3841 */,
251 0x390000 /* apparently used in older cards */,
252 0x7f0002 /* Intel PRO/Wireless 2011B (PCI) */,
253 };
254
255 buf = kmalloc(PRISM2_PDA_SIZE, GFP_KERNEL);
256 if (buf == NULL)
257 return NULL;
258
259 /* Note: wlan card should be in initial state (just after init cmd)
260 * and no other operations should be performed concurrently. */
261
262 prism2_enable_aux_port(dev, 1);
263
264 for (i = 0; i < NUM_PDA_ADDRS; i++) {
265 PDEBUG(DEBUG_EXTRA2, "%s: trying to read PDA from 0x%08x",
266 dev->name, pda_addr[i]);
267 res = hfa384x_from_aux(dev, pda_addr[i], PRISM2_PDA_SIZE, buf);
268 if (res)
269 continue;
270 if (res == 0 && prism2_pda_ok(buf)) {
271 PDEBUG2(DEBUG_EXTRA2, ": OK\n");
272 found = 1;
273 break;
274 } else {
275 PDEBUG2(DEBUG_EXTRA2, ": failed\n");
276 }
277 }
278
279 prism2_enable_aux_port(dev, 0);
280
281 if (!found) {
282 printk(KERN_DEBUG "%s: valid PDA not found\n", dev->name);
283 kfree(buf);
284 buf = NULL;
285 }
286
287 return buf;
288 }
289
290
prism2_download_volatile(local_info_t * local,struct prism2_download_data * param)291 static int prism2_download_volatile(local_info_t *local,
292 struct prism2_download_data *param)
293 {
294 struct net_device *dev = local->dev;
295 int ret = 0, i;
296 u16 param0, param1;
297
298 if (local->hw_downloading) {
299 printk(KERN_WARNING "%s: Already downloading - aborting new "
300 "request\n", dev->name);
301 return -1;
302 }
303
304 local->hw_downloading = 1;
305 if (local->pri_only) {
306 hfa384x_disable_interrupts(dev);
307 } else {
308 prism2_hw_shutdown(dev, 0);
309
310 if (prism2_hw_init(dev, 0)) {
311 printk(KERN_WARNING "%s: Could not initialize card for"
312 " download\n", dev->name);
313 ret = -1;
314 goto out;
315 }
316 }
317
318 if (prism2_enable_aux_port(dev, 1)) {
319 printk(KERN_WARNING "%s: Could not enable AUX port\n",
320 dev->name);
321 ret = -1;
322 goto out;
323 }
324
325 param0 = param->start_addr & 0xffff;
326 param1 = param->start_addr >> 16;
327
328 HFA384X_OUTW(0, HFA384X_PARAM2_OFF);
329 HFA384X_OUTW(param1, HFA384X_PARAM1_OFF);
330 if (hfa384x_cmd_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
331 (HFA384X_PROGMODE_ENABLE_VOLATILE << 8),
332 param0)) {
333 printk(KERN_WARNING "%s: Download command execution failed\n",
334 dev->name);
335 ret = -1;
336 goto out;
337 }
338
339 for (i = 0; i < param->num_areas; i++) {
340 PDEBUG(DEBUG_EXTRA2, "%s: Writing %d bytes at 0x%08x\n",
341 dev->name, param->data[i].len, param->data[i].addr);
342 if (hfa384x_to_aux(dev, param->data[i].addr,
343 param->data[i].len, param->data[i].data)) {
344 printk(KERN_WARNING "%s: RAM download at 0x%08x "
345 "(len=%d) failed\n", dev->name,
346 param->data[i].addr, param->data[i].len);
347 ret = -1;
348 goto out;
349 }
350 }
351
352 HFA384X_OUTW(param1, HFA384X_PARAM1_OFF);
353 HFA384X_OUTW(0, HFA384X_PARAM2_OFF);
354 if (hfa384x_cmd_no_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
355 (HFA384X_PROGMODE_DISABLE << 8), param0)) {
356 printk(KERN_WARNING "%s: Download command execution failed\n",
357 dev->name);
358 ret = -1;
359 goto out;
360 }
361 /* ProgMode disable causes the hardware to restart itself from the
362 * given starting address. Give hw some time and ACK command just in
363 * case restart did not happen. */
364 mdelay(5);
365 HFA384X_OUTW(HFA384X_EV_CMD, HFA384X_EVACK_OFF);
366
367 if (prism2_enable_aux_port(dev, 0)) {
368 printk(KERN_DEBUG "%s: Disabling AUX port failed\n",
369 dev->name);
370 /* continue anyway.. restart should have taken care of this */
371 }
372
373 mdelay(5);
374 local->hw_downloading = 0;
375 if (prism2_hw_config(dev, 2)) {
376 printk(KERN_WARNING "%s: Card configuration after RAM "
377 "download failed\n", dev->name);
378 ret = -1;
379 goto out;
380 }
381
382 out:
383 local->hw_downloading = 0;
384 return ret;
385 }
386
387
prism2_enable_genesis(local_info_t * local,int hcr)388 static int prism2_enable_genesis(local_info_t *local, int hcr)
389 {
390 struct net_device *dev = local->dev;
391 u8 initseq[4] = { 0x00, 0xe1, 0xa1, 0xff };
392 u8 readbuf[4];
393
394 printk(KERN_DEBUG "%s: test Genesis mode with HCR 0x%02x\n",
395 dev->name, hcr);
396 local->func->cor_sreset(local);
397 hfa384x_to_aux(dev, 0x7e0038, sizeof(initseq), initseq);
398 local->func->genesis_reset(local, hcr);
399
400 /* Readback test */
401 hfa384x_from_aux(dev, 0x7e0038, sizeof(readbuf), readbuf);
402 hfa384x_to_aux(dev, 0x7e0038, sizeof(initseq), initseq);
403 hfa384x_from_aux(dev, 0x7e0038, sizeof(readbuf), readbuf);
404
405 if (memcmp(initseq, readbuf, sizeof(initseq)) == 0) {
406 printk(KERN_DEBUG "Readback test succeeded, HCR 0x%02x\n",
407 hcr);
408 return 0;
409 } else {
410 printk(KERN_DEBUG "Readback test failed, HCR 0x%02x write %4ph read %4ph\n",
411 hcr, initseq, readbuf);
412 return 1;
413 }
414 }
415
416
prism2_get_ram_size(local_info_t * local)417 static int prism2_get_ram_size(local_info_t *local)
418 {
419 int ret;
420
421 /* Try to enable genesis mode; 0x1F for x8 SRAM or 0x0F for x16 SRAM */
422 if (prism2_enable_genesis(local, 0x1f) == 0)
423 ret = 8;
424 else if (prism2_enable_genesis(local, 0x0f) == 0)
425 ret = 16;
426 else
427 ret = -1;
428
429 /* Disable genesis mode */
430 local->func->genesis_reset(local, ret == 16 ? 0x07 : 0x17);
431
432 return ret;
433 }
434
435
prism2_download_genesis(local_info_t * local,struct prism2_download_data * param)436 static int prism2_download_genesis(local_info_t *local,
437 struct prism2_download_data *param)
438 {
439 struct net_device *dev = local->dev;
440 int ram16 = 0, i;
441 int ret = 0;
442
443 if (local->hw_downloading) {
444 printk(KERN_WARNING "%s: Already downloading - aborting new "
445 "request\n", dev->name);
446 return -EBUSY;
447 }
448
449 if (!local->func->genesis_reset || !local->func->cor_sreset) {
450 printk(KERN_INFO "%s: Genesis mode downloading not supported "
451 "with this hwmodel\n", dev->name);
452 return -EOPNOTSUPP;
453 }
454
455 local->hw_downloading = 1;
456
457 if (prism2_enable_aux_port(dev, 1)) {
458 printk(KERN_DEBUG "%s: failed to enable AUX port\n",
459 dev->name);
460 ret = -EIO;
461 goto out;
462 }
463
464 if (local->sram_type == -1) {
465 /* 0x1F for x8 SRAM or 0x0F for x16 SRAM */
466 if (prism2_enable_genesis(local, 0x1f) == 0) {
467 ram16 = 0;
468 PDEBUG(DEBUG_EXTRA2, "%s: Genesis mode OK using x8 "
469 "SRAM\n", dev->name);
470 } else if (prism2_enable_genesis(local, 0x0f) == 0) {
471 ram16 = 1;
472 PDEBUG(DEBUG_EXTRA2, "%s: Genesis mode OK using x16 "
473 "SRAM\n", dev->name);
474 } else {
475 printk(KERN_DEBUG "%s: Could not initiate genesis "
476 "mode\n", dev->name);
477 ret = -EIO;
478 goto out;
479 }
480 } else {
481 if (prism2_enable_genesis(local, local->sram_type == 8 ?
482 0x1f : 0x0f)) {
483 printk(KERN_DEBUG "%s: Failed to set Genesis "
484 "mode (sram_type=%d)\n", dev->name,
485 local->sram_type);
486 ret = -EIO;
487 goto out;
488 }
489 ram16 = local->sram_type != 8;
490 }
491
492 for (i = 0; i < param->num_areas; i++) {
493 PDEBUG(DEBUG_EXTRA2, "%s: Writing %d bytes at 0x%08x\n",
494 dev->name, param->data[i].len, param->data[i].addr);
495 if (hfa384x_to_aux(dev, param->data[i].addr,
496 param->data[i].len, param->data[i].data)) {
497 printk(KERN_WARNING "%s: RAM download at 0x%08x "
498 "(len=%d) failed\n", dev->name,
499 param->data[i].addr, param->data[i].len);
500 ret = -EIO;
501 goto out;
502 }
503 }
504
505 PDEBUG(DEBUG_EXTRA2, "Disable genesis mode\n");
506 local->func->genesis_reset(local, ram16 ? 0x07 : 0x17);
507 if (prism2_enable_aux_port(dev, 0)) {
508 printk(KERN_DEBUG "%s: Failed to disable AUX port\n",
509 dev->name);
510 }
511
512 mdelay(5);
513 local->hw_downloading = 0;
514
515 PDEBUG(DEBUG_EXTRA2, "Trying to initialize card\n");
516 /*
517 * Make sure the INIT command does not generate a command completion
518 * event by disabling interrupts.
519 */
520 hfa384x_disable_interrupts(dev);
521 if (prism2_hw_init(dev, 1)) {
522 printk(KERN_DEBUG "%s: Initialization after genesis mode "
523 "download failed\n", dev->name);
524 ret = -EIO;
525 goto out;
526 }
527
528 PDEBUG(DEBUG_EXTRA2, "Card initialized - running PRI only\n");
529 if (prism2_hw_init2(dev, 1)) {
530 printk(KERN_DEBUG "%s: Initialization(2) after genesis mode "
531 "download failed\n", dev->name);
532 ret = -EIO;
533 goto out;
534 }
535
536 out:
537 local->hw_downloading = 0;
538 return ret;
539 }
540
541
542 #ifdef PRISM2_NON_VOLATILE_DOWNLOAD
543 /* Note! Non-volatile downloading functionality has not yet been tested
544 * thoroughly and it may corrupt flash image and effectively kill the card that
545 * is being updated. You have been warned. */
546
prism2_download_block(struct net_device * dev,u32 addr,u8 * data,u32 bufaddr,int rest_len)547 static inline int prism2_download_block(struct net_device *dev,
548 u32 addr, u8 *data,
549 u32 bufaddr, int rest_len)
550 {
551 u16 param0, param1;
552 int block_len;
553
554 block_len = rest_len < 4096 ? rest_len : 4096;
555
556 param0 = addr & 0xffff;
557 param1 = addr >> 16;
558
559 HFA384X_OUTW(block_len, HFA384X_PARAM2_OFF);
560 HFA384X_OUTW(param1, HFA384X_PARAM1_OFF);
561
562 if (hfa384x_cmd_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
563 (HFA384X_PROGMODE_ENABLE_NON_VOLATILE << 8),
564 param0)) {
565 printk(KERN_WARNING "%s: Flash download command execution "
566 "failed\n", dev->name);
567 return -1;
568 }
569
570 if (hfa384x_to_aux(dev, bufaddr, block_len, data)) {
571 printk(KERN_WARNING "%s: flash download at 0x%08x "
572 "(len=%d) failed\n", dev->name, addr, block_len);
573 return -1;
574 }
575
576 HFA384X_OUTW(0, HFA384X_PARAM2_OFF);
577 HFA384X_OUTW(0, HFA384X_PARAM1_OFF);
578 if (hfa384x_cmd_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
579 (HFA384X_PROGMODE_PROGRAM_NON_VOLATILE << 8),
580 0)) {
581 printk(KERN_WARNING "%s: Flash write command execution "
582 "failed\n", dev->name);
583 return -1;
584 }
585
586 return block_len;
587 }
588
589
prism2_download_nonvolatile(local_info_t * local,struct prism2_download_data * dl)590 static int prism2_download_nonvolatile(local_info_t *local,
591 struct prism2_download_data *dl)
592 {
593 struct net_device *dev = local->dev;
594 int ret = 0, i;
595 struct {
596 __le16 page;
597 __le16 offset;
598 __le16 len;
599 } dlbuffer;
600 u32 bufaddr;
601
602 if (local->hw_downloading) {
603 printk(KERN_WARNING "%s: Already downloading - aborting new "
604 "request\n", dev->name);
605 return -1;
606 }
607
608 ret = local->func->get_rid(dev, HFA384X_RID_DOWNLOADBUFFER,
609 &dlbuffer, 6, 0);
610
611 if (ret < 0) {
612 printk(KERN_WARNING "%s: Could not read download buffer "
613 "parameters\n", dev->name);
614 goto out;
615 }
616
617 printk(KERN_DEBUG "Download buffer: %d bytes at 0x%04x:0x%04x\n",
618 le16_to_cpu(dlbuffer.len),
619 le16_to_cpu(dlbuffer.page),
620 le16_to_cpu(dlbuffer.offset));
621
622 bufaddr = (le16_to_cpu(dlbuffer.page) << 7) + le16_to_cpu(dlbuffer.offset);
623
624 local->hw_downloading = 1;
625
626 if (!local->pri_only) {
627 prism2_hw_shutdown(dev, 0);
628
629 if (prism2_hw_init(dev, 0)) {
630 printk(KERN_WARNING "%s: Could not initialize card for"
631 " download\n", dev->name);
632 ret = -1;
633 goto out;
634 }
635 }
636
637 hfa384x_disable_interrupts(dev);
638
639 if (prism2_enable_aux_port(dev, 1)) {
640 printk(KERN_WARNING "%s: Could not enable AUX port\n",
641 dev->name);
642 ret = -1;
643 goto out;
644 }
645
646 printk(KERN_DEBUG "%s: starting flash download\n", dev->name);
647 for (i = 0; i < dl->num_areas; i++) {
648 int rest_len = dl->data[i].len;
649 int data_off = 0;
650
651 while (rest_len > 0) {
652 int block_len;
653
654 block_len = prism2_download_block(
655 dev, dl->data[i].addr + data_off,
656 dl->data[i].data + data_off, bufaddr,
657 rest_len);
658
659 if (block_len < 0) {
660 ret = -1;
661 goto out;
662 }
663
664 rest_len -= block_len;
665 data_off += block_len;
666 }
667 }
668
669 HFA384X_OUTW(0, HFA384X_PARAM1_OFF);
670 HFA384X_OUTW(0, HFA384X_PARAM2_OFF);
671 if (hfa384x_cmd_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
672 (HFA384X_PROGMODE_DISABLE << 8), 0)) {
673 printk(KERN_WARNING "%s: Download command execution failed\n",
674 dev->name);
675 ret = -1;
676 goto out;
677 }
678
679 if (prism2_enable_aux_port(dev, 0)) {
680 printk(KERN_DEBUG "%s: Disabling AUX port failed\n",
681 dev->name);
682 /* continue anyway.. restart should have taken care of this */
683 }
684
685 mdelay(5);
686
687 local->func->hw_reset(dev);
688 local->hw_downloading = 0;
689 if (prism2_hw_config(dev, 2)) {
690 printk(KERN_WARNING "%s: Card configuration after flash "
691 "download failed\n", dev->name);
692 ret = -1;
693 } else {
694 printk(KERN_INFO "%s: Card initialized successfully after "
695 "flash download\n", dev->name);
696 }
697
698 out:
699 local->hw_downloading = 0;
700 return ret;
701 }
702 #endif /* PRISM2_NON_VOLATILE_DOWNLOAD */
703
704
prism2_download_free_data(struct prism2_download_data * dl)705 static void prism2_download_free_data(struct prism2_download_data *dl)
706 {
707 int i;
708
709 if (dl == NULL)
710 return;
711
712 for (i = 0; i < dl->num_areas; i++)
713 kfree(dl->data[i].data);
714 kfree(dl);
715 }
716
717
prism2_download(local_info_t * local,struct prism2_download_param * param)718 static int prism2_download(local_info_t *local,
719 struct prism2_download_param *param)
720 {
721 int ret = 0;
722 int i;
723 u32 total_len = 0;
724 struct prism2_download_data *dl = NULL;
725
726 printk(KERN_DEBUG "prism2_download: dl_cmd=%d start_addr=0x%08x "
727 "num_areas=%d\n",
728 param->dl_cmd, param->start_addr, param->num_areas);
729
730 if (param->num_areas > 100) {
731 ret = -EINVAL;
732 goto out;
733 }
734
735 dl = kzalloc(sizeof(*dl) + param->num_areas *
736 sizeof(struct prism2_download_data_area), GFP_KERNEL);
737 if (dl == NULL) {
738 ret = -ENOMEM;
739 goto out;
740 }
741 dl->dl_cmd = param->dl_cmd;
742 dl->start_addr = param->start_addr;
743 dl->num_areas = param->num_areas;
744 for (i = 0; i < param->num_areas; i++) {
745 PDEBUG(DEBUG_EXTRA2,
746 " area %d: addr=0x%08x len=%d ptr=0x%p\n",
747 i, param->data[i].addr, param->data[i].len,
748 param->data[i].ptr);
749
750 dl->data[i].addr = param->data[i].addr;
751 dl->data[i].len = param->data[i].len;
752
753 total_len += param->data[i].len;
754 if (param->data[i].len > PRISM2_MAX_DOWNLOAD_AREA_LEN ||
755 total_len > PRISM2_MAX_DOWNLOAD_LEN) {
756 ret = -E2BIG;
757 goto out;
758 }
759
760 dl->data[i].data = kmalloc(dl->data[i].len, GFP_KERNEL);
761 if (dl->data[i].data == NULL) {
762 ret = -ENOMEM;
763 goto out;
764 }
765
766 if (copy_from_user(dl->data[i].data, param->data[i].ptr,
767 param->data[i].len)) {
768 ret = -EFAULT;
769 goto out;
770 }
771 }
772
773 switch (param->dl_cmd) {
774 case PRISM2_DOWNLOAD_VOLATILE:
775 case PRISM2_DOWNLOAD_VOLATILE_PERSISTENT:
776 ret = prism2_download_volatile(local, dl);
777 break;
778 case PRISM2_DOWNLOAD_VOLATILE_GENESIS:
779 case PRISM2_DOWNLOAD_VOLATILE_GENESIS_PERSISTENT:
780 ret = prism2_download_genesis(local, dl);
781 break;
782 case PRISM2_DOWNLOAD_NON_VOLATILE:
783 #ifdef PRISM2_NON_VOLATILE_DOWNLOAD
784 ret = prism2_download_nonvolatile(local, dl);
785 #else /* PRISM2_NON_VOLATILE_DOWNLOAD */
786 printk(KERN_INFO "%s: non-volatile downloading not enabled\n",
787 local->dev->name);
788 ret = -EOPNOTSUPP;
789 #endif /* PRISM2_NON_VOLATILE_DOWNLOAD */
790 break;
791 default:
792 printk(KERN_DEBUG "%s: unsupported download command %d\n",
793 local->dev->name, param->dl_cmd);
794 ret = -EINVAL;
795 break;
796 }
797
798 out:
799 if (ret == 0 && dl &&
800 param->dl_cmd == PRISM2_DOWNLOAD_VOLATILE_GENESIS_PERSISTENT) {
801 prism2_download_free_data(local->dl_pri);
802 local->dl_pri = dl;
803 } else if (ret == 0 && dl &&
804 param->dl_cmd == PRISM2_DOWNLOAD_VOLATILE_PERSISTENT) {
805 prism2_download_free_data(local->dl_sec);
806 local->dl_sec = dl;
807 } else
808 prism2_download_free_data(dl);
809
810 return ret;
811 }
812