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