drivers/net/wireless/intersil/hostap/hostap_download.c

   1 // SPDX-License-Identifier: GPL-2.0
   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
  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
 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
 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
 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
 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
 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
 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
 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 file_operations prism2_download_aux_dump_proc_fops = {
 236         .open           = prism2_download_aux_dump_proc_open,
 237         .read           = seq_read,
 238         .llseek         = seq_lseek,
 239         .release        = seq_release_private,
 240 };
 241
 242
 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
 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
 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 "
 411                        "write %02x %02x %02x %02x read %02x %02x %02x %02x\n",
 412                        hcr, initseq[0], initseq[1], initseq[2], initseq[3],
 413                        readbuf[0], readbuf[1], readbuf[2], readbuf[3]);
 414                 return 1;
 415         }
 416 }
 417
 418
 419 static int prism2_get_ram_size(local_info_t *local)
 420 {
 421         int ret;
 422
 423         /* Try to enable genesis mode; 0x1F for x8 SRAM or 0x0F for x16 SRAM */
 424         if (prism2_enable_genesis(local, 0x1f) == 0)
 425                 ret = 8;
 426         else if (prism2_enable_genesis(local, 0x0f) == 0)
 427                 ret = 16;
 428         else
 429                 ret = -1;
 430
 431         /* Disable genesis mode */
 432         local->func->genesis_reset(local, ret == 16 ? 0x07 : 0x17);
 433
 434         return ret;
 435 }
 436
 437
 438 static int prism2_download_genesis(local_info_t *local,
 439                                    struct prism2_download_data *param)
 440 {
 441         struct net_device *dev = local->dev;
 442         int ram16 = 0, i;
 443         int ret = 0;
 444
 445         if (local->hw_downloading) {
 446                 printk(KERN_WARNING "%s: Already downloading - aborting new "
 447                        "request\n", dev->name);
 448                 return -EBUSY;
 449         }
 450
 451         if (!local->func->genesis_reset || !local->func->cor_sreset) {
 452                 printk(KERN_INFO "%s: Genesis mode downloading not supported "
 453                        "with this hwmodel\n", dev->name);
 454                 return -EOPNOTSUPP;
 455         }
 456
 457         local->hw_downloading = 1;
 458
 459         if (prism2_enable_aux_port(dev, 1)) {
 460                 printk(KERN_DEBUG "%s: failed to enable AUX port\n",
 461                        dev->name);
 462                 ret = -EIO;
 463                 goto out;
 464         }
 465
 466         if (local->sram_type == -1) {
 467                 /* 0x1F for x8 SRAM or 0x0F for x16 SRAM */
 468                 if (prism2_enable_genesis(local, 0x1f) == 0) {
 469                         ram16 = 0;
 470                         PDEBUG(DEBUG_EXTRA2, "%s: Genesis mode OK using x8 "
 471                                "SRAM\n", dev->name);
 472                 } else if (prism2_enable_genesis(local, 0x0f) == 0) {
 473                         ram16 = 1;
 474                         PDEBUG(DEBUG_EXTRA2, "%s: Genesis mode OK using x16 "
 475                                "SRAM\n", dev->name);
 476                 } else {
 477                         printk(KERN_DEBUG "%s: Could not initiate genesis "
 478                                "mode\n", dev->name);
 479                         ret = -EIO;
 480                         goto out;
 481                 }
 482         } else {
 483                 if (prism2_enable_genesis(local, local->sram_type == 8 ?
 484                                           0x1f : 0x0f)) {
 485                         printk(KERN_DEBUG "%s: Failed to set Genesis "
 486                                "mode (sram_type=%d)\n", dev->name,
 487                                local->sram_type);
 488                         ret = -EIO;
 489                         goto out;
 490                 }
 491                 ram16 = local->sram_type != 8;
 492         }
 493
 494         for (i = 0; i < param->num_areas; i++) {
 495                 PDEBUG(DEBUG_EXTRA2, "%s: Writing %d bytes at 0x%08x\n",
 496                        dev->name, param->data[i].len, param->data[i].addr);
 497                 if (hfa384x_to_aux(dev, param->data[i].addr,
 498                                    param->data[i].len, param->data[i].data)) {
 499                         printk(KERN_WARNING "%s: RAM download at 0x%08x "
 500                                "(len=%d) failed\n", dev->name,
 501                                param->data[i].addr, param->data[i].len);
 502                         ret = -EIO;
 503                         goto out;
 504                 }
 505         }
 506
 507         PDEBUG(DEBUG_EXTRA2, "Disable genesis mode\n");
 508         local->func->genesis_reset(local, ram16 ? 0x07 : 0x17);
 509         if (prism2_enable_aux_port(dev, 0)) {
 510                 printk(KERN_DEBUG "%s: Failed to disable AUX port\n",
 511                        dev->name);
 512         }
 513
 514         mdelay(5);
 515         local->hw_downloading = 0;
 516
 517         PDEBUG(DEBUG_EXTRA2, "Trying to initialize card\n");
 518         /*
 519          * Make sure the INIT command does not generate a command completion
 520          * event by disabling interrupts.
 521          */
 522         hfa384x_disable_interrupts(dev);
 523         if (prism2_hw_init(dev, 1)) {
 524                 printk(KERN_DEBUG "%s: Initialization after genesis mode "
 525                        "download failed\n", dev->name);
 526                 ret = -EIO;
 527                 goto out;
 528         }
 529
 530         PDEBUG(DEBUG_EXTRA2, "Card initialized - running PRI only\n");
 531         if (prism2_hw_init2(dev, 1)) {
 532                 printk(KERN_DEBUG "%s: Initialization(2) after genesis mode "
 533                        "download failed\n", dev->name);
 534                 ret = -EIO;
 535                 goto out;
 536         }
 537
 538  out:
 539         local->hw_downloading = 0;
 540         return ret;
 541 }
 542
 543
 544 #ifdef PRISM2_NON_VOLATILE_DOWNLOAD
 545 /* Note! Non-volatile downloading functionality has not yet been tested
 546  * thoroughly and it may corrupt flash image and effectively kill the card that
 547  * is being updated. You have been warned. */
 548
 549 static inline int prism2_download_block(struct net_device *dev,
 550                                         u32 addr, u8 *data,
 551                                         u32 bufaddr, int rest_len)
 552 {
 553         u16 param0, param1;
 554         int block_len;
 555
 556         block_len = rest_len < 4096 ? rest_len : 4096;
 557
 558         param0 = addr & 0xffff;
 559         param1 = addr >> 16;
 560
 561         HFA384X_OUTW(block_len, HFA384X_PARAM2_OFF);
 562         HFA384X_OUTW(param1, HFA384X_PARAM1_OFF);
 563
 564         if (hfa384x_cmd_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
 565                              (HFA384X_PROGMODE_ENABLE_NON_VOLATILE << 8),
 566                              param0)) {
 567                 printk(KERN_WARNING "%s: Flash download command execution "
 568                        "failed\n", dev->name);
 569                 return -1;
 570         }
 571
 572         if (hfa384x_to_aux(dev, bufaddr, block_len, data)) {
 573                 printk(KERN_WARNING "%s: flash download at 0x%08x "
 574                        "(len=%d) failed\n", dev->name, addr, block_len);
 575                 return -1;
 576         }
 577
 578         HFA384X_OUTW(0, HFA384X_PARAM2_OFF);
 579         HFA384X_OUTW(0, HFA384X_PARAM1_OFF);
 580         if (hfa384x_cmd_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
 581                              (HFA384X_PROGMODE_PROGRAM_NON_VOLATILE << 8),
 582                              0)) {
 583                 printk(KERN_WARNING "%s: Flash write command execution "
 584                        "failed\n", dev->name);
 585                 return -1;
 586         }
 587
 588         return block_len;
 589 }
 590
 591
 592 static int prism2_download_nonvolatile(local_info_t *local,
 593                                        struct prism2_download_data *dl)
 594 {
 595         struct net_device *dev = local->dev;
 596         int ret = 0, i;
 597         struct {
 598                 __le16 page;
 599                 __le16 offset;
 600                 __le16 len;
 601         } dlbuffer;
 602         u32 bufaddr;
 603
 604         if (local->hw_downloading) {
 605                 printk(KERN_WARNING "%s: Already downloading - aborting new "
 606                        "request\n", dev->name);
 607                 return -1;
 608         }
 609
 610         ret = local->func->get_rid(dev, HFA384X_RID_DOWNLOADBUFFER,
 611                                    &dlbuffer, 6, 0);
 612
 613         if (ret < 0) {
 614                 printk(KERN_WARNING "%s: Could not read download buffer "
 615                        "parameters\n", dev->name);
 616                 goto out;
 617         }
 618
 619         printk(KERN_DEBUG "Download buffer: %d bytes at 0x%04x:0x%04x\n",
 620                le16_to_cpu(dlbuffer.len),
 621                le16_to_cpu(dlbuffer.page),
 622                le16_to_cpu(dlbuffer.offset));
 623
 624         bufaddr = (le16_to_cpu(dlbuffer.page) << 7) + le16_to_cpu(dlbuffer.offset);
 625
 626         local->hw_downloading = 1;
 627
 628         if (!local->pri_only) {
 629                 prism2_hw_shutdown(dev, 0);
 630
 631                 if (prism2_hw_init(dev, 0)) {
 632                         printk(KERN_WARNING "%s: Could not initialize card for"
 633                                " download\n", dev->name);
 634                         ret = -1;
 635                         goto out;
 636                 }
 637         }
 638
 639         hfa384x_disable_interrupts(dev);
 640
 641         if (prism2_enable_aux_port(dev, 1)) {
 642                 printk(KERN_WARNING "%s: Could not enable AUX port\n",
 643                        dev->name);
 644                 ret = -1;
 645                 goto out;
 646         }
 647
 648         printk(KERN_DEBUG "%s: starting flash download\n", dev->name);
 649         for (i = 0; i < dl->num_areas; i++) {
 650                 int rest_len = dl->data[i].len;
 651                 int data_off = 0;
 652
 653                 while (rest_len > 0) {
 654                         int block_len;
 655
 656                         block_len = prism2_download_block(
 657                                 dev, dl->data[i].addr + data_off,
 658                                 dl->data[i].data + data_off, bufaddr,
 659                                 rest_len);
 660
 661                         if (block_len < 0) {
 662                                 ret = -1;
 663                                 goto out;
 664                         }
 665
 666                         rest_len -= block_len;
 667                         data_off += block_len;
 668                 }
 669         }
 670
 671         HFA384X_OUTW(0, HFA384X_PARAM1_OFF);
 672         HFA384X_OUTW(0, HFA384X_PARAM2_OFF);
 673         if (hfa384x_cmd_wait(dev, HFA384X_CMDCODE_DOWNLOAD |
 674                                 (HFA384X_PROGMODE_DISABLE << 8), 0)) {
 675                 printk(KERN_WARNING "%s: Download command execution failed\n",
 676                        dev->name);
 677                 ret = -1;
 678                 goto out;
 679         }
 680
 681         if (prism2_enable_aux_port(dev, 0)) {
 682                 printk(KERN_DEBUG "%s: Disabling AUX port failed\n",
 683                        dev->name);
 684                 /* continue anyway.. restart should have taken care of this */
 685         }
 686
 687         mdelay(5);
 688
 689         local->func->hw_reset(dev);
 690         local->hw_downloading = 0;
 691         if (prism2_hw_config(dev, 2)) {
 692                 printk(KERN_WARNING "%s: Card configuration after flash "
 693                        "download failed\n", dev->name);
 694                 ret = -1;
 695         } else {
 696                 printk(KERN_INFO "%s: Card initialized successfully after "
 697                        "flash download\n", dev->name);
 698         }
 699
 700  out:
 701         local->hw_downloading = 0;
 702         return ret;
 703 }
 704 #endif /* PRISM2_NON_VOLATILE_DOWNLOAD */
 705
 706
 707 static void prism2_download_free_data(struct prism2_download_data *dl)
 708 {
 709         int i;
 710
 711         if (dl == NULL)
 712                 return;
 713
 714         for (i = 0; i < dl->num_areas; i++)
 715                 kfree(dl->data[i].data);
 716         kfree(dl);
 717 }
 718
 719
 720 static int prism2_download(local_info_t *local,
 721                            struct prism2_download_param *param)
 722 {
 723         int ret = 0;
 724         int i;
 725         u32 total_len = 0;
 726         struct prism2_download_data *dl = NULL;
 727
 728         printk(KERN_DEBUG "prism2_download: dl_cmd=%d start_addr=0x%08x "
 729                "num_areas=%d\n",
 730                param->dl_cmd, param->start_addr, param->num_areas);
 731
 732         if (param->num_areas > 100) {
 733                 ret = -EINVAL;
 734                 goto out;
 735         }
 736
 737         dl = kzalloc(sizeof(*dl) + param->num_areas *
 738                      sizeof(struct prism2_download_data_area), GFP_KERNEL);
 739         if (dl == NULL) {
 740                 ret = -ENOMEM;
 741                 goto out;
 742         }
 743         dl->dl_cmd = param->dl_cmd;
 744         dl->start_addr = param->start_addr;
 745         dl->num_areas = param->num_areas;
 746         for (i = 0; i < param->num_areas; i++) {
 747                 PDEBUG(DEBUG_EXTRA2,
 748                        "  area %d: addr=0x%08x len=%d ptr=0x%p\n",
 749                        i, param->data[i].addr, param->data[i].len,
 750                        param->data[i].ptr);
 751
 752                 dl->data[i].addr = param->data[i].addr;
 753                 dl->data[i].len = param->data[i].len;
 754
 755                 total_len += param->data[i].len;
 756                 if (param->data[i].len > PRISM2_MAX_DOWNLOAD_AREA_LEN ||
 757                     total_len > PRISM2_MAX_DOWNLOAD_LEN) {
 758                         ret = -E2BIG;
 759                         goto out;
 760                 }
 761
 762                 dl->data[i].data = kmalloc(dl->data[i].len, GFP_KERNEL);
 763                 if (dl->data[i].data == NULL) {
 764                         ret = -ENOMEM;
 765                         goto out;
 766                 }
 767
 768                 if (copy_from_user(dl->data[i].data, param->data[i].ptr,
 769                                    param->data[i].len)) {
 770                         ret = -EFAULT;
 771                         goto out;
 772                 }
 773         }
 774
 775         switch (param->dl_cmd) {
 776         case PRISM2_DOWNLOAD_VOLATILE:
 777         case PRISM2_DOWNLOAD_VOLATILE_PERSISTENT:
 778                 ret = prism2_download_volatile(local, dl);
 779                 break;
 780         case PRISM2_DOWNLOAD_VOLATILE_GENESIS:
 781         case PRISM2_DOWNLOAD_VOLATILE_GENESIS_PERSISTENT:
 782                 ret = prism2_download_genesis(local, dl);
 783                 break;
 784         case PRISM2_DOWNLOAD_NON_VOLATILE:
 785 #ifdef PRISM2_NON_VOLATILE_DOWNLOAD
 786                 ret = prism2_download_nonvolatile(local, dl);
 787 #else /* PRISM2_NON_VOLATILE_DOWNLOAD */
 788                 printk(KERN_INFO "%s: non-volatile downloading not enabled\n",
 789                        local->dev->name);
 790                 ret = -EOPNOTSUPP;
 791 #endif /* PRISM2_NON_VOLATILE_DOWNLOAD */
 792                 break;
 793         default:
 794                 printk(KERN_DEBUG "%s: unsupported download command %d\n",
 795                        local->dev->name, param->dl_cmd);
 796                 ret = -EINVAL;
 797                 break;
 798         }
 799
 800  out:
 801         if (ret == 0 && dl &&
 802             param->dl_cmd == PRISM2_DOWNLOAD_VOLATILE_GENESIS_PERSISTENT) {
 803                 prism2_download_free_data(local->dl_pri);
 804                 local->dl_pri = dl;
 805         } else if (ret == 0 && dl &&
 806                    param->dl_cmd == PRISM2_DOWNLOAD_VOLATILE_PERSISTENT) {
 807                 prism2_download_free_data(local->dl_sec);
 808                 local->dl_sec = dl;
 809         } else
 810                 prism2_download_free_data(dl);
 811
 812         return ret;
 813 }