kernel/drivers/scsi/aic94xx/aic94xx_sds.c

   1 /*
   2  * Aic94xx SAS/SATA driver access to shared data structures and memory
   3  * maps.
   4  *
   5  * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
   6  * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
   7  *
   8  * This file is licensed under GPLv2.
   9  *
  10  * This file is part of the aic94xx driver.
  11  *
  12  * The aic94xx driver is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License as
  14  * published by the Free Software Foundation; version 2 of the
  15  * License.
  16  *
  17  * The aic94xx driver is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with the aic94xx driver; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  25  *
  26  */
  27
  28 #include <linux/pci.h>
  29 #include <linux/slab.h>
  30 #include <linux/delay.h>
  31
  32 #include "aic94xx.h"
  33 #include "aic94xx_reg.h"
  34 #include "aic94xx_sds.h"
  35
  36 /* ---------- OCM stuff ---------- */
  37
  38 struct asd_ocm_dir_ent {
  39         u8 type;
  40         u8 offs[3];
  41         u8 _r1;
  42         u8 size[3];
  43 } __attribute__ ((packed));
  44
  45 struct asd_ocm_dir {
  46         char sig[2];
  47         u8   _r1[2];
  48         u8   major;          /* 0 */
  49         u8   minor;          /* 0 */
  50         u8   _r2;
  51         u8   num_de;
  52         struct asd_ocm_dir_ent entry[15];
  53 } __attribute__ ((packed));
  54
  55 #define OCM_DE_OCM_DIR                  0x00
  56 #define OCM_DE_WIN_DRVR                 0x01
  57 #define OCM_DE_BIOS_CHIM                0x02
  58 #define OCM_DE_RAID_ENGN                0x03
  59 #define OCM_DE_BIOS_INTL                0x04
  60 #define OCM_DE_BIOS_CHIM_OSM            0x05
  61 #define OCM_DE_BIOS_CHIM_DYNAMIC        0x06
  62 #define OCM_DE_ADDC2C_RES0              0x07
  63 #define OCM_DE_ADDC2C_RES1              0x08
  64 #define OCM_DE_ADDC2C_RES2              0x09
  65 #define OCM_DE_ADDC2C_RES3              0x0A
  66
  67 #define OCM_INIT_DIR_ENTRIES    5
  68 /***************************************************************************
  69 *  OCM directory default
  70 ***************************************************************************/
  71 static struct asd_ocm_dir OCMDirInit =
  72 {
  73         .sig = {0x4D, 0x4F},    /* signature */
  74         .num_de = OCM_INIT_DIR_ENTRIES, /* no. of directory entries */
  75 };
  76
  77 /***************************************************************************
  78 *  OCM directory Entries default
  79 ***************************************************************************/
  80 static struct asd_ocm_dir_ent OCMDirEntriesInit[OCM_INIT_DIR_ENTRIES] =
  81 {
  82         {
  83                 .type = (OCM_DE_ADDC2C_RES0),   /* Entry type  */
  84                 .offs = {128},                  /* Offset */
  85                 .size = {0, 4},                 /* size */
  86         },
  87         {
  88                 .type = (OCM_DE_ADDC2C_RES1),   /* Entry type  */
  89                 .offs = {128, 4},               /* Offset */
  90                 .size = {0, 4},                 /* size */
  91         },
  92         {
  93                 .type = (OCM_DE_ADDC2C_RES2),   /* Entry type  */
  94                 .offs = {128, 8},               /* Offset */
  95                 .size = {0, 4},                 /* size */
  96         },
  97         {
  98                 .type = (OCM_DE_ADDC2C_RES3),   /* Entry type  */
  99                 .offs = {128, 12},              /* Offset */
 100                 .size = {0, 4},                 /* size */
 101         },
 102         {
 103                 .type = (OCM_DE_WIN_DRVR),      /* Entry type  */
 104                 .offs = {128, 16},              /* Offset */
 105                 .size = {128, 235, 1},          /* size */
 106         },
 107 };
 108
 109 struct asd_bios_chim_struct {
 110         char sig[4];
 111         u8   major;          /* 1 */
 112         u8   minor;          /* 0 */
 113         u8   bios_major;
 114         u8   bios_minor;
 115         __le32  bios_build;
 116         u8   flags;
 117         u8   pci_slot;
 118         __le16  ue_num;
 119         __le16  ue_size;
 120         u8  _r[14];
 121         /* The unit element array is right here.
 122          */
 123 } __attribute__ ((packed));
 124
 125 /**
 126  * asd_read_ocm_seg - read an on chip memory (OCM) segment
 127  * @asd_ha: pointer to the host adapter structure
 128  * @buffer: where to write the read data
 129  * @offs: offset into OCM where to read from
 130  * @size: how many bytes to read
 131  *
 132  * Return the number of bytes not read. Return 0 on success.
 133  */
 134 static int asd_read_ocm_seg(struct asd_ha_struct *asd_ha, void *buffer,
 135                             u32 offs, int size)
 136 {
 137         u8 *p = buffer;
 138         if (unlikely(asd_ha->iospace))
 139                 asd_read_reg_string(asd_ha, buffer, offs+OCM_BASE_ADDR, size);
 140         else {
 141                 for ( ; size > 0; size--, offs++, p++)
 142                         *p = asd_read_ocm_byte(asd_ha, offs);
 143         }
 144         return size;
 145 }
 146
 147 static int asd_read_ocm_dir(struct asd_ha_struct *asd_ha,
 148                             struct asd_ocm_dir *dir, u32 offs)
 149 {
 150         int err = asd_read_ocm_seg(asd_ha, dir, offs, sizeof(*dir));
 151         if (err) {
 152                 ASD_DPRINTK("couldn't read ocm segment\n");
 153                 return err;
 154         }
 155
 156         if (dir->sig[0] != 'M' || dir->sig[1] != 'O') {
 157                 ASD_DPRINTK("no valid dir signature(%c%c) at start of OCM\n",
 158                             dir->sig[0], dir->sig[1]);
 159                 return -ENOENT;
 160         }
 161         if (dir->major != 0) {
 162                 asd_printk("unsupported major version of ocm dir:0x%x\n",
 163                            dir->major);
 164                 return -ENOENT;
 165         }
 166         dir->num_de &= 0xf;
 167         return 0;
 168 }
 169
 170 /**
 171  * asd_write_ocm_seg - write an on chip memory (OCM) segment
 172  * @asd_ha: pointer to the host adapter structure
 173  * @buffer: where to read the write data
 174  * @offs: offset into OCM to write to
 175  * @size: how many bytes to write
 176  *
 177  * Return the number of bytes not written. Return 0 on success.
 178  */
 179 static void asd_write_ocm_seg(struct asd_ha_struct *asd_ha, void *buffer,
 180                             u32 offs, int size)
 181 {
 182         u8 *p = buffer;
 183         if (unlikely(asd_ha->iospace))
 184                 asd_write_reg_string(asd_ha, buffer, offs+OCM_BASE_ADDR, size);
 185         else {
 186                 for ( ; size > 0; size--, offs++, p++)
 187                         asd_write_ocm_byte(asd_ha, offs, *p);
 188         }
 189         return;
 190 }
 191
 192 #define THREE_TO_NUM(X) ((X)[0] | ((X)[1] << 8) | ((X)[2] << 16))
 193
 194 static int asd_find_dir_entry(struct asd_ocm_dir *dir, u8 type,
 195                               u32 *offs, u32 *size)
 196 {
 197         int i;
 198         struct asd_ocm_dir_ent *ent;
 199
 200         for (i = 0; i < dir->num_de; i++) {
 201                 if (dir->entry[i].type == type)
 202                         break;
 203         }
 204         if (i >= dir->num_de)
 205                 return -ENOENT;
 206         ent = &dir->entry[i];
 207         *offs = (u32) THREE_TO_NUM(ent->offs);
 208         *size = (u32) THREE_TO_NUM(ent->size);
 209         return 0;
 210 }
 211
 212 #define OCM_BIOS_CHIM_DE  2
 213 #define BC_BIOS_PRESENT   1
 214
 215 static int asd_get_bios_chim(struct asd_ha_struct *asd_ha,
 216                              struct asd_ocm_dir *dir)
 217 {
 218         int err;
 219         struct asd_bios_chim_struct *bc_struct;
 220         u32 offs, size;
 221
 222         err = asd_find_dir_entry(dir, OCM_BIOS_CHIM_DE, &offs, &size);
 223         if (err) {
 224                 ASD_DPRINTK("couldn't find BIOS_CHIM dir ent\n");
 225                 goto out;
 226         }
 227         err = -ENOMEM;
 228         bc_struct = kmalloc(sizeof(*bc_struct), GFP_KERNEL);
 229         if (!bc_struct) {
 230                 asd_printk("no memory for bios_chim struct\n");
 231                 goto out;
 232         }
 233         err = asd_read_ocm_seg(asd_ha, (void *)bc_struct, offs,
 234                                sizeof(*bc_struct));
 235         if (err) {
 236                 ASD_DPRINTK("couldn't read ocm segment\n");
 237                 goto out2;
 238         }
 239         if (strncmp(bc_struct->sig, "SOIB", 4)
 240             && strncmp(bc_struct->sig, "IPSA", 4)) {
 241                 ASD_DPRINTK("BIOS_CHIM entry has no valid sig(%c%c%c%c)\n",
 242                             bc_struct->sig[0], bc_struct->sig[1],
 243                             bc_struct->sig[2], bc_struct->sig[3]);
 244                 err = -ENOENT;
 245                 goto out2;
 246         }
 247         if (bc_struct->major != 1) {
 248                 asd_printk("BIOS_CHIM unsupported major version:0x%x\n",
 249                            bc_struct->major);
 250                 err = -ENOENT;
 251                 goto out2;
 252         }
 253         if (bc_struct->flags & BC_BIOS_PRESENT) {
 254                 asd_ha->hw_prof.bios.present = 1;
 255                 asd_ha->hw_prof.bios.maj = bc_struct->bios_major;
 256                 asd_ha->hw_prof.bios.min = bc_struct->bios_minor;
 257                 asd_ha->hw_prof.bios.bld = le32_to_cpu(bc_struct->bios_build);
 258                 ASD_DPRINTK("BIOS present (%d,%d), %d\n",
 259                             asd_ha->hw_prof.bios.maj,
 260                             asd_ha->hw_prof.bios.min,
 261                             asd_ha->hw_prof.bios.bld);
 262         }
 263         asd_ha->hw_prof.ue.num = le16_to_cpu(bc_struct->ue_num);
 264         asd_ha->hw_prof.ue.size= le16_to_cpu(bc_struct->ue_size);
 265         ASD_DPRINTK("ue num:%d, ue size:%d\n", asd_ha->hw_prof.ue.num,
 266                     asd_ha->hw_prof.ue.size);
 267         size = asd_ha->hw_prof.ue.num * asd_ha->hw_prof.ue.size;
 268         if (size > 0) {
 269                 err = -ENOMEM;
 270                 asd_ha->hw_prof.ue.area = kmalloc(size, GFP_KERNEL);
 271                 if (!asd_ha->hw_prof.ue.area)
 272                         goto out2;
 273                 err = asd_read_ocm_seg(asd_ha, (void *)asd_ha->hw_prof.ue.area,
 274                                        offs + sizeof(*bc_struct), size);
 275                 if (err) {
 276                         kfree(asd_ha->hw_prof.ue.area);
 277                         asd_ha->hw_prof.ue.area = NULL;
 278                         asd_ha->hw_prof.ue.num  = 0;
 279                         asd_ha->hw_prof.ue.size = 0;
 280                         ASD_DPRINTK("couldn't read ue entries(%d)\n", err);
 281                 }
 282         }
 283 out2:
 284         kfree(bc_struct);
 285 out:
 286         return err;
 287 }
 288
 289 static void
 290 asd_hwi_initialize_ocm_dir (struct asd_ha_struct *asd_ha)
 291 {
 292         int i;
 293
 294         /* Zero OCM */
 295         for (i = 0; i < OCM_MAX_SIZE; i += 4)
 296                 asd_write_ocm_dword(asd_ha, i, 0);
 297
 298         /* Write Dir */
 299         asd_write_ocm_seg(asd_ha, &OCMDirInit, 0,
 300                           sizeof(struct asd_ocm_dir));
 301
 302         /* Write Dir Entries */
 303         for (i = 0; i < OCM_INIT_DIR_ENTRIES; i++)
 304                 asd_write_ocm_seg(asd_ha, &OCMDirEntriesInit[i],
 305                                   sizeof(struct asd_ocm_dir) +
 306                                   (i * sizeof(struct asd_ocm_dir_ent))
 307                                   , sizeof(struct asd_ocm_dir_ent));
 308
 309 }
 310
 311 static int
 312 asd_hwi_check_ocm_access (struct asd_ha_struct *asd_ha)
 313 {
 314         struct pci_dev *pcidev = asd_ha->pcidev;
 315         u32 reg;
 316         int err = 0;
 317         u32 v;
 318
 319         /* check if OCM has been initialized by BIOS */
 320         reg = asd_read_reg_dword(asd_ha, EXSICNFGR);
 321
 322         if (!(reg & OCMINITIALIZED)) {
 323                 err = pci_read_config_dword(pcidev, PCIC_INTRPT_STAT, &v);
 324                 if (err) {
 325                         asd_printk("couldn't access PCIC_INTRPT_STAT of %s\n",
 326                                         pci_name(pcidev));
 327                         goto out;
 328                 }
 329
 330                 printk(KERN_INFO "OCM is not initialized by BIOS,"
 331                        "reinitialize it and ignore it, current IntrptStatus"
 332                        "is 0x%x\n", v);
 333
 334                 if (v)
 335                         err = pci_write_config_dword(pcidev,
 336                                                      PCIC_INTRPT_STAT, v);
 337                 if (err) {
 338                         asd_printk("couldn't write PCIC_INTRPT_STAT of %s\n",
 339                                         pci_name(pcidev));
 340                         goto out;
 341                 }
 342
 343                 asd_hwi_initialize_ocm_dir(asd_ha);
 344
 345         }
 346 out:
 347         return err;
 348 }
 349
 350 /**
 351  * asd_read_ocm - read on chip memory (OCM)
 352  * @asd_ha: pointer to the host adapter structure
 353  */
 354 int asd_read_ocm(struct asd_ha_struct *asd_ha)
 355 {
 356         int err;
 357         struct asd_ocm_dir *dir;
 358
 359         if (asd_hwi_check_ocm_access(asd_ha))
 360                 return -1;
 361
 362         dir = kmalloc(sizeof(*dir), GFP_KERNEL);
 363         if (!dir) {
 364                 asd_printk("no memory for ocm dir\n");
 365                 return -ENOMEM;
 366         }
 367
 368         err = asd_read_ocm_dir(asd_ha, dir, 0);
 369         if (err)
 370                 goto out;
 371
 372         err = asd_get_bios_chim(asd_ha, dir);
 373 out:
 374         kfree(dir);
 375         return err;
 376 }
 377
 378 /* ---------- FLASH stuff ---------- */
 379
 380 #define FLASH_RESET                     0xF0
 381
 382 #define ASD_FLASH_SIZE                  0x200000
 383 #define FLASH_DIR_COOKIE                "*** ADAPTEC FLASH DIRECTORY *** "
 384 #define FLASH_NEXT_ENTRY_OFFS           0x2000
 385 #define FLASH_MAX_DIR_ENTRIES           32
 386
 387 #define FLASH_DE_TYPE_MASK              0x3FFFFFFF
 388 #define FLASH_DE_MS                     0x120
 389 #define FLASH_DE_CTRL_A_USER            0xE0
 390
 391 struct asd_flash_de {
 392         __le32   type;
 393         __le32   offs;
 394         __le32   pad_size;
 395         __le32   image_size;
 396         __le32   chksum;
 397         u8       _r[12];
 398         u8       version[32];
 399 } __attribute__ ((packed));
 400
 401 struct asd_flash_dir {
 402         u8    cookie[32];
 403         __le32   rev;             /* 2 */
 404         __le32   chksum;
 405         __le32   chksum_antidote;
 406         __le32   bld;
 407         u8    bld_id[32];         /* build id data */
 408         u8    ver_data[32];       /* date and time of build */
 409         __le32   ae_mask;
 410         __le32   v_mask;
 411         __le32   oc_mask;
 412         u8    _r[20];
 413         struct asd_flash_de dir_entry[FLASH_MAX_DIR_ENTRIES];
 414 } __attribute__ ((packed));
 415
 416 struct asd_manuf_sec {
 417         char  sig[2];             /* 'S', 'M' */
 418         u16   offs_next;
 419         u8    maj;           /* 0 */
 420         u8    min;           /* 0 */
 421         u16   chksum;
 422         u16   size;
 423         u8    _r[6];
 424         u8    sas_addr[SAS_ADDR_SIZE];
 425         u8    pcba_sn[ASD_PCBA_SN_SIZE];
 426         /* Here start the other segments */
 427         u8    linked_list[0];
 428 } __attribute__ ((packed));
 429
 430 struct asd_manuf_phy_desc {
 431         u8    state;         /* low 4 bits */
 432 #define MS_PHY_STATE_ENABLED    0
 433 #define MS_PHY_STATE_REPORTED   1
 434 #define MS_PHY_STATE_HIDDEN     2
 435         u8    phy_id;
 436         u16   _r;
 437         u8    phy_control_0; /* mode 5 reg 0x160 */
 438         u8    phy_control_1; /* mode 5 reg 0x161 */
 439         u8    phy_control_2; /* mode 5 reg 0x162 */
 440         u8    phy_control_3; /* mode 5 reg 0x163 */
 441 } __attribute__ ((packed));
 442
 443 struct asd_manuf_phy_param {
 444         char  sig[2];             /* 'P', 'M' */
 445         u16   next;
 446         u8    maj;           /* 0 */
 447         u8    min;           /* 2 */
 448         u8    num_phy_desc;  /* 8 */
 449         u8    phy_desc_size; /* 8 */
 450         u8    _r[3];
 451         u8    usage_model_id;
 452         u32   _r2;
 453         struct asd_manuf_phy_desc phy_desc[ASD_MAX_PHYS];
 454 } __attribute__ ((packed));
 455
 456 #if 0
 457 static const char *asd_sb_type[] = {
 458         "unknown",
 459         "SGPIO",
 460         [2 ... 0x7F] = "unknown",
 461         [0x80] = "ADPT_I2C",
 462         [0x81 ... 0xFF] = "VENDOR_UNIQUExx"
 463 };
 464 #endif
 465
 466 struct asd_ms_sb_desc {
 467         u8    type;
 468         u8    node_desc_index;
 469         u8    conn_desc_index;
 470         u8    _recvd[0];
 471 } __attribute__ ((packed));
 472
 473 #if 0
 474 static const char *asd_conn_type[] = {
 475         [0 ... 7] = "unknown",
 476         "SFF8470",
 477         "SFF8482",
 478         "SFF8484",
 479         [0x80] = "PCIX_DAUGHTER0",
 480         [0x81] = "SAS_DAUGHTER0",
 481         [0x82 ... 0xFF] = "VENDOR_UNIQUExx"
 482 };
 483
 484 static const char *asd_conn_location[] = {
 485         "unknown",
 486         "internal",
 487         "external",
 488         "board_to_board",
 489 };
 490 #endif
 491
 492 struct asd_ms_conn_desc {
 493         u8    type;
 494         u8    location;
 495         u8    num_sideband_desc;
 496         u8    size_sideband_desc;
 497         u32   _resvd;
 498         u8    name[16];
 499         struct asd_ms_sb_desc sb_desc[0];
 500 } __attribute__ ((packed));
 501
 502 struct asd_nd_phy_desc {
 503         u8    vp_attch_type;
 504         u8    attch_specific[0];
 505 } __attribute__ ((packed));
 506
 507 #if 0
 508 static const char *asd_node_type[] = {
 509         "IOP",
 510         "IO_CONTROLLER",
 511         "EXPANDER",
 512         "PORT_MULTIPLIER",
 513         "PORT_MULTIPLEXER",
 514         "MULTI_DROP_I2C_BUS",
 515 };
 516 #endif
 517
 518 struct asd_ms_node_desc {
 519         u8    type;
 520         u8    num_phy_desc;
 521         u8    size_phy_desc;
 522         u8    _resvd;
 523         u8    name[16];
 524         struct asd_nd_phy_desc phy_desc[0];
 525 } __attribute__ ((packed));
 526
 527 struct asd_ms_conn_map {
 528         char  sig[2];             /* 'M', 'C' */
 529         __le16 next;
 530         u8    maj;                /* 0 */
 531         u8    min;                /* 0 */
 532         __le16 cm_size;           /* size of this struct */
 533         u8    num_conn;
 534         u8    conn_size;
 535         u8    num_nodes;
 536         u8    usage_model_id;
 537         u32   _resvd;
 538         struct asd_ms_conn_desc conn_desc[0];
 539         struct asd_ms_node_desc node_desc[0];
 540 } __attribute__ ((packed));
 541
 542 struct asd_ctrla_phy_entry {
 543         u8    sas_addr[SAS_ADDR_SIZE];
 544         u8    sas_link_rates;  /* max in hi bits, min in low bits */
 545         u8    flags;
 546         u8    sata_link_rates;
 547         u8    _r[5];
 548 } __attribute__ ((packed));
 549
 550 struct asd_ctrla_phy_settings {
 551         u8    id0;                /* P'h'y */
 552         u8    _r;
 553         u16   next;
 554         u8    num_phys;       /* number of PHYs in the PCI function */
 555         u8    _r2[3];
 556         struct asd_ctrla_phy_entry phy_ent[ASD_MAX_PHYS];
 557 } __attribute__ ((packed));
 558
 559 struct asd_ll_el {
 560         u8   id0;
 561         u8   id1;
 562         __le16  next;
 563         u8   something_here[0];
 564 } __attribute__ ((packed));
 565
 566 static int asd_poll_flash(struct asd_ha_struct *asd_ha)
 567 {
 568         int c;
 569         u8 d;
 570
 571         for (c = 5000; c > 0; c--) {
 572                 d  = asd_read_reg_byte(asd_ha, asd_ha->hw_prof.flash.bar);
 573                 d ^= asd_read_reg_byte(asd_ha, asd_ha->hw_prof.flash.bar);
 574                 if (!d)
 575                         return 0;
 576                 udelay(5);
 577         }
 578         return -ENOENT;
 579 }
 580
 581 static int asd_reset_flash(struct asd_ha_struct *asd_ha)
 582 {
 583         int err;
 584
 585         err = asd_poll_flash(asd_ha);
 586         if (err)
 587                 return err;
 588         asd_write_reg_byte(asd_ha, asd_ha->hw_prof.flash.bar, FLASH_RESET);
 589         err = asd_poll_flash(asd_ha);
 590
 591         return err;
 592 }
 593
 594 static int asd_read_flash_seg(struct asd_ha_struct *asd_ha,
 595                               void *buffer, u32 offs, int size)
 596 {
 597         asd_read_reg_string(asd_ha, buffer, asd_ha->hw_prof.flash.bar+offs,
 598                             size);
 599         return 0;
 600 }
 601
 602 /**
 603  * asd_find_flash_dir - finds and reads the flash directory
 604  * @asd_ha: pointer to the host adapter structure
 605  * @flash_dir: pointer to flash directory structure
 606  *
 607  * If found, the flash directory segment will be copied to
 608  * @flash_dir.  Return 1 if found, 0 if not.
 609  */
 610 static int asd_find_flash_dir(struct asd_ha_struct *asd_ha,
 611                               struct asd_flash_dir *flash_dir)
 612 {
 613         u32 v;
 614         for (v = 0; v < ASD_FLASH_SIZE; v += FLASH_NEXT_ENTRY_OFFS) {
 615                 asd_read_flash_seg(asd_ha, flash_dir, v,
 616                                    sizeof(FLASH_DIR_COOKIE)-1);
 617                 if (memcmp(flash_dir->cookie, FLASH_DIR_COOKIE,
 618                            sizeof(FLASH_DIR_COOKIE)-1) == 0) {
 619                         asd_ha->hw_prof.flash.dir_offs = v;
 620                         asd_read_flash_seg(asd_ha, flash_dir, v,
 621                                            sizeof(*flash_dir));
 622                         return 1;
 623                 }
 624         }
 625         return 0;
 626 }
 627
 628 static int asd_flash_getid(struct asd_ha_struct *asd_ha)
 629 {
 630         int err = 0;
 631         u32 reg;
 632
 633         reg = asd_read_reg_dword(asd_ha, EXSICNFGR);
 634
 635         if (pci_read_config_dword(asd_ha->pcidev, PCI_CONF_FLSH_BAR,
 636                                   &asd_ha->hw_prof.flash.bar)) {
 637                 asd_printk("couldn't read PCI_CONF_FLSH_BAR of %s\n",
 638                            pci_name(asd_ha->pcidev));
 639                 return -ENOENT;
 640         }
 641         asd_ha->hw_prof.flash.present = 1;
 642         asd_ha->hw_prof.flash.wide = reg & FLASHW ? 1 : 0;
 643         err = asd_reset_flash(asd_ha);
 644         if (err) {
 645                 ASD_DPRINTK("couldn't reset flash(%d)\n", err);
 646                 return err;
 647         }
 648         return 0;
 649 }
 650
 651 static u16 asd_calc_flash_chksum(u16 *p, int size)
 652 {
 653         u16 chksum = 0;
 654
 655         while (size-- > 0)
 656                 chksum += *p++;
 657
 658         return chksum;
 659 }
 660
 661
 662 static int asd_find_flash_de(struct asd_flash_dir *flash_dir, u32 entry_type,
 663                              u32 *offs, u32 *size)
 664 {
 665         int i;
 666         struct asd_flash_de *de;
 667
 668         for (i = 0; i < FLASH_MAX_DIR_ENTRIES; i++) {
 669                 u32 type = le32_to_cpu(flash_dir->dir_entry[i].type);
 670
 671                 type &= FLASH_DE_TYPE_MASK;
 672                 if (type == entry_type)
 673                         break;
 674         }
 675         if (i >= FLASH_MAX_DIR_ENTRIES)
 676                 return -ENOENT;
 677         de = &flash_dir->dir_entry[i];
 678         *offs = le32_to_cpu(de->offs);
 679         *size = le32_to_cpu(de->pad_size);
 680         return 0;
 681 }
 682
 683 static int asd_validate_ms(struct asd_manuf_sec *ms)
 684 {
 685         if (ms->sig[0] != 'S' || ms->sig[1] != 'M') {
 686                 ASD_DPRINTK("manuf sec: no valid sig(%c%c)\n",
 687                             ms->sig[0], ms->sig[1]);
 688                 return -ENOENT;
 689         }
 690         if (ms->maj != 0) {
 691                 asd_printk("unsupported manuf. sector. major version:%x\n",
 692                            ms->maj);
 693                 return -ENOENT;
 694         }
 695         ms->offs_next = le16_to_cpu((__force __le16) ms->offs_next);
 696         ms->chksum = le16_to_cpu((__force __le16) ms->chksum);
 697         ms->size = le16_to_cpu((__force __le16) ms->size);
 698
 699         if (asd_calc_flash_chksum((u16 *)ms, ms->size/2)) {
 700                 asd_printk("failed manuf sector checksum\n");
 701         }
 702
 703         return 0;
 704 }
 705
 706 static int asd_ms_get_sas_addr(struct asd_ha_struct *asd_ha,
 707                                struct asd_manuf_sec *ms)
 708 {
 709         memcpy(asd_ha->hw_prof.sas_addr, ms->sas_addr, SAS_ADDR_SIZE);
 710         return 0;
 711 }
 712
 713 static int asd_ms_get_pcba_sn(struct asd_ha_struct *asd_ha,
 714                               struct asd_manuf_sec *ms)
 715 {
 716         memcpy(asd_ha->hw_prof.pcba_sn, ms->pcba_sn, ASD_PCBA_SN_SIZE);
 717         asd_ha->hw_prof.pcba_sn[ASD_PCBA_SN_SIZE] = '\0';
 718         return 0;
 719 }
 720
 721 /**
 722  * asd_find_ll_by_id - find a linked list entry by its id
 723  * @start: void pointer to the first element in the linked list
 724  * @id0: the first byte of the id  (offs 0)
 725  * @id1: the second byte of the id (offs 1)
 726  *
 727  * @start has to be the _base_ element start, since the
 728  * linked list entries's offset is from this pointer.
 729  * Some linked list entries use only the first id, in which case
 730  * you can pass 0xFF for the second.
 731  */
 732 static void *asd_find_ll_by_id(void * const start, const u8 id0, const u8 id1)
 733 {
 734         struct asd_ll_el *el = start;
 735
 736         do {
 737                 switch (id1) {
 738                 default:
 739                         if (el->id1 == id1)
 740                 case 0xFF:
 741                                 if (el->id0 == id0)
 742                                         return el;
 743                 }
 744                 el = start + le16_to_cpu(el->next);
 745         } while (el != start);
 746
 747         return NULL;
 748 }
 749
 750 /**
 751  * asd_ms_get_phy_params - get phy parameters from the manufacturing sector
 752  * @asd_ha: pointer to the host adapter structure
 753  * @manuf_sec: pointer to the manufacturing sector
 754  *
 755  * The manufacturing sector contans also the linked list of sub-segments,
 756  * since when it was read, its size was taken from the flash directory,
 757  * not from the structure size.
 758  *
 759  * HIDDEN phys do not count in the total count.  REPORTED phys cannot
 760  * be enabled but are reported and counted towards the total.
 761  * ENABLED phys are enabled by default and count towards the total.
 762  * The absolute total phy number is ASD_MAX_PHYS.  hw_prof->num_phys
 763  * merely specifies the number of phys the host adapter decided to
 764  * report.  E.g., it is possible for phys 0, 1 and 2 to be HIDDEN,
 765  * phys 3, 4 and 5 to be REPORTED and phys 6 and 7 to be ENABLED.
 766  * In this case ASD_MAX_PHYS is 8, hw_prof->num_phys is 5, and only 2
 767  * are actually enabled (enabled by default, max number of phys
 768  * enableable in this case).
 769  */
 770 static int asd_ms_get_phy_params(struct asd_ha_struct *asd_ha,
 771                                  struct asd_manuf_sec *manuf_sec)
 772 {
 773         int i;
 774         int en_phys = 0;
 775         int rep_phys = 0;
 776         struct asd_manuf_phy_param *phy_param;
 777         struct asd_manuf_phy_param dflt_phy_param;
 778
 779         phy_param = asd_find_ll_by_id(manuf_sec, 'P', 'M');
 780         if (!phy_param) {
 781                 ASD_DPRINTK("ms: no phy parameters found\n");
 782                 ASD_DPRINTK("ms: Creating default phy parameters\n");
 783                 dflt_phy_param.sig[0] = 'P';
 784                 dflt_phy_param.sig[1] = 'M';
 785                 dflt_phy_param.maj = 0;
 786                 dflt_phy_param.min = 2;
 787                 dflt_phy_param.num_phy_desc = 8;
 788                 dflt_phy_param.phy_desc_size = sizeof(struct asd_manuf_phy_desc);
 789                 for (i =0; i < ASD_MAX_PHYS; i++) {
 790                         dflt_phy_param.phy_desc[i].state = 0;
 791                         dflt_phy_param.phy_desc[i].phy_id = i;
 792                         dflt_phy_param.phy_desc[i].phy_control_0 = 0xf6;
 793                         dflt_phy_param.phy_desc[i].phy_control_1 = 0x10;
 794                         dflt_phy_param.phy_desc[i].phy_control_2 = 0x43;
 795                         dflt_phy_param.phy_desc[i].phy_control_3 = 0xeb;
 796                 }
 797
 798                 phy_param = &dflt_phy_param;
 799
 800         }
 801
 802         if (phy_param->maj != 0) {
 803                 asd_printk("unsupported manuf. phy param major version:0x%x\n",
 804                            phy_param->maj);
 805                 return -ENOENT;
 806         }
 807
 808         ASD_DPRINTK("ms: num_phy_desc: %d\n", phy_param->num_phy_desc);
 809         asd_ha->hw_prof.enabled_phys = 0;
 810         for (i = 0; i < phy_param->num_phy_desc; i++) {
 811                 struct asd_manuf_phy_desc *pd = &phy_param->phy_desc[i];
 812                 switch (pd->state & 0xF) {
 813                 case MS_PHY_STATE_HIDDEN:
 814                         ASD_DPRINTK("ms: phy%d: HIDDEN\n", i);
 815                         continue;
 816                 case MS_PHY_STATE_REPORTED:
 817                         ASD_DPRINTK("ms: phy%d: REPORTED\n", i);
 818                         asd_ha->hw_prof.enabled_phys &= ~(1 << i);
 819                         rep_phys++;
 820                         continue;
 821                 case MS_PHY_STATE_ENABLED:
 822                         ASD_DPRINTK("ms: phy%d: ENABLED\n", i);
 823                         asd_ha->hw_prof.enabled_phys |= (1 << i);
 824                         en_phys++;
 825                         break;
 826                 }
 827                 asd_ha->hw_prof.phy_desc[i].phy_control_0 = pd->phy_control_0;
 828                 asd_ha->hw_prof.phy_desc[i].phy_control_1 = pd->phy_control_1;
 829                 asd_ha->hw_prof.phy_desc[i].phy_control_2 = pd->phy_control_2;
 830                 asd_ha->hw_prof.phy_desc[i].phy_control_3 = pd->phy_control_3;
 831         }
 832         asd_ha->hw_prof.max_phys = rep_phys + en_phys;
 833         asd_ha->hw_prof.num_phys = en_phys;
 834         ASD_DPRINTK("ms: max_phys:0x%x, num_phys:0x%x\n",
 835                     asd_ha->hw_prof.max_phys, asd_ha->hw_prof.num_phys);
 836         ASD_DPRINTK("ms: enabled_phys:0x%x\n", asd_ha->hw_prof.enabled_phys);
 837         return 0;
 838 }
 839
 840 static int asd_ms_get_connector_map(struct asd_ha_struct *asd_ha,
 841                                     struct asd_manuf_sec *manuf_sec)
 842 {
 843         struct asd_ms_conn_map *cm;
 844
 845         cm = asd_find_ll_by_id(manuf_sec, 'M', 'C');
 846         if (!cm) {
 847                 ASD_DPRINTK("ms: no connector map found\n");
 848                 return 0;
 849         }
 850
 851         if (cm->maj != 0) {
 852                 ASD_DPRINTK("ms: unsupported: connector map major version 0x%x"
 853                             "\n", cm->maj);
 854                 return -ENOENT;
 855         }
 856
 857         /* XXX */
 858
 859         return 0;
 860 }
 861
 862
 863 /**
 864  * asd_process_ms - find and extract information from the manufacturing sector
 865  * @asd_ha: pointer to the host adapter structure
 866  * @flash_dir: pointer to the flash directory
 867  */
 868 static int asd_process_ms(struct asd_ha_struct *asd_ha,
 869                           struct asd_flash_dir *flash_dir)
 870 {
 871         int err;
 872         struct asd_manuf_sec *manuf_sec;
 873         u32 offs, size;
 874
 875         err = asd_find_flash_de(flash_dir, FLASH_DE_MS, &offs, &size);
 876         if (err) {
 877                 ASD_DPRINTK("Couldn't find the manuf. sector\n");
 878                 goto out;
 879         }
 880
 881         if (size == 0)
 882                 goto out;
 883
 884         err = -ENOMEM;
 885         manuf_sec = kmalloc(size, GFP_KERNEL);
 886         if (!manuf_sec) {
 887                 ASD_DPRINTK("no mem for manuf sector\n");
 888                 goto out;
 889         }
 890
 891         err = asd_read_flash_seg(asd_ha, (void *)manuf_sec, offs, size);
 892         if (err) {
 893                 ASD_DPRINTK("couldn't read manuf sector at 0x%x, size 0x%x\n",
 894                             offs, size);
 895                 goto out2;
 896         }
 897
 898         err = asd_validate_ms(manuf_sec);
 899         if (err) {
 900                 ASD_DPRINTK("couldn't validate manuf sector\n");
 901                 goto out2;
 902         }
 903
 904         err = asd_ms_get_sas_addr(asd_ha, manuf_sec);
 905         if (err) {
 906                 ASD_DPRINTK("couldn't read the SAS_ADDR\n");
 907                 goto out2;
 908         }
 909         ASD_DPRINTK("manuf sect SAS_ADDR %llx\n",
 910                     SAS_ADDR(asd_ha->hw_prof.sas_addr));
 911
 912         err = asd_ms_get_pcba_sn(asd_ha, manuf_sec);
 913         if (err) {
 914                 ASD_DPRINTK("couldn't read the PCBA SN\n");
 915                 goto out2;
 916         }
 917         ASD_DPRINTK("manuf sect PCBA SN %s\n", asd_ha->hw_prof.pcba_sn);
 918
 919         err = asd_ms_get_phy_params(asd_ha, manuf_sec);
 920         if (err) {
 921                 ASD_DPRINTK("ms: couldn't get phy parameters\n");
 922                 goto out2;
 923         }
 924
 925         err = asd_ms_get_connector_map(asd_ha, manuf_sec);
 926         if (err) {
 927                 ASD_DPRINTK("ms: couldn't get connector map\n");
 928                 goto out2;
 929         }
 930
 931 out2:
 932         kfree(manuf_sec);
 933 out:
 934         return err;
 935 }
 936
 937 static int asd_process_ctrla_phy_settings(struct asd_ha_struct *asd_ha,
 938                                           struct asd_ctrla_phy_settings *ps)
 939 {
 940         int i;
 941         for (i = 0; i < ps->num_phys; i++) {
 942                 struct asd_ctrla_phy_entry *pe = &ps->phy_ent[i];
 943
 944                 if (!PHY_ENABLED(asd_ha, i))
 945                         continue;
 946                 if (*(u64 *)pe->sas_addr == 0) {
 947                         asd_ha->hw_prof.enabled_phys &= ~(1 << i);
 948                         continue;
 949                 }
 950                 /* This is the SAS address which should be sent in IDENTIFY. */
 951                 memcpy(asd_ha->hw_prof.phy_desc[i].sas_addr, pe->sas_addr,
 952                        SAS_ADDR_SIZE);
 953                 asd_ha->hw_prof.phy_desc[i].max_sas_lrate =
 954                         (pe->sas_link_rates & 0xF0) >> 4;
 955                 asd_ha->hw_prof.phy_desc[i].min_sas_lrate =
 956                         (pe->sas_link_rates & 0x0F);
 957                 asd_ha->hw_prof.phy_desc[i].max_sata_lrate =
 958                         (pe->sata_link_rates & 0xF0) >> 4;
 959                 asd_ha->hw_prof.phy_desc[i].min_sata_lrate =
 960                         (pe->sata_link_rates & 0x0F);
 961                 asd_ha->hw_prof.phy_desc[i].flags = pe->flags;
 962                 ASD_DPRINTK("ctrla: phy%d: sas_addr: %llx, sas rate:0x%x-0x%x,"
 963                             " sata rate:0x%x-0x%x, flags:0x%x\n",
 964                             i,
 965                             SAS_ADDR(asd_ha->hw_prof.phy_desc[i].sas_addr),
 966                             asd_ha->hw_prof.phy_desc[i].max_sas_lrate,
 967                             asd_ha->hw_prof.phy_desc[i].min_sas_lrate,
 968                             asd_ha->hw_prof.phy_desc[i].max_sata_lrate,
 969                             asd_ha->hw_prof.phy_desc[i].min_sata_lrate,
 970                             asd_ha->hw_prof.phy_desc[i].flags);
 971         }
 972
 973         return 0;
 974 }
 975
 976 /**
 977  * asd_process_ctrl_a_user - process CTRL-A user settings
 978  * @asd_ha: pointer to the host adapter structure
 979  * @flash_dir: pointer to the flash directory
 980  */
 981 static int asd_process_ctrl_a_user(struct asd_ha_struct *asd_ha,
 982                                    struct asd_flash_dir *flash_dir)
 983 {
 984         int err, i;
 985         u32 offs, size;
 986         struct asd_ll_el *el;
 987         struct asd_ctrla_phy_settings *ps;
 988         struct asd_ctrla_phy_settings dflt_ps;
 989
 990         err = asd_find_flash_de(flash_dir, FLASH_DE_CTRL_A_USER, &offs, &size);
 991         if (err) {
 992                 ASD_DPRINTK("couldn't find CTRL-A user settings section\n");
 993                 ASD_DPRINTK("Creating default CTRL-A user settings section\n");
 994
 995                 dflt_ps.id0 = 'h';
 996                 dflt_ps.num_phys = 8;
 997                 for (i =0; i < ASD_MAX_PHYS; i++) {
 998                         memcpy(dflt_ps.phy_ent[i].sas_addr,
 999                                asd_ha->hw_prof.sas_addr, SAS_ADDR_SIZE);
1000                         dflt_ps.phy_ent[i].sas_link_rates = 0x98;
1001                         dflt_ps.phy_ent[i].flags = 0x0;
1002                         dflt_ps.phy_ent[i].sata_link_rates = 0x0;
1003                 }
1004
1005                 size = sizeof(struct asd_ctrla_phy_settings);
1006                 ps = &dflt_ps;
1007         }
1008
1009         if (size == 0)
1010                 goto out;
1011
1012         err = -ENOMEM;
1013         el = kmalloc(size, GFP_KERNEL);
1014         if (!el) {
1015                 ASD_DPRINTK("no mem for ctrla user settings section\n");
1016                 goto out;
1017         }
1018
1019         err = asd_read_flash_seg(asd_ha, (void *)el, offs, size);
1020         if (err) {
1021                 ASD_DPRINTK("couldn't read ctrla phy settings section\n");
1022                 goto out2;
1023         }
1024
1025         err = -ENOENT;
1026         ps = asd_find_ll_by_id(el, 'h', 0xFF);
1027         if (!ps) {
1028                 ASD_DPRINTK("couldn't find ctrla phy settings struct\n");
1029                 goto out2;
1030         }
1031
1032         err = asd_process_ctrla_phy_settings(asd_ha, ps);
1033         if (err) {
1034                 ASD_DPRINTK("couldn't process ctrla phy settings\n");
1035                 goto out2;
1036         }
1037 out2:
1038         kfree(el);
1039 out:
1040         return err;
1041 }
1042
1043 /**
1044  * asd_read_flash - read flash memory
1045  * @asd_ha: pointer to the host adapter structure
1046  */
1047 int asd_read_flash(struct asd_ha_struct *asd_ha)
1048 {
1049         int err;
1050         struct asd_flash_dir *flash_dir;
1051
1052         err = asd_flash_getid(asd_ha);
1053         if (err)
1054                 return err;
1055
1056         flash_dir = kmalloc(sizeof(*flash_dir), GFP_KERNEL);
1057         if (!flash_dir)
1058                 return -ENOMEM;
1059
1060         err = -ENOENT;
1061         if (!asd_find_flash_dir(asd_ha, flash_dir)) {
1062                 ASD_DPRINTK("couldn't find flash directory\n");
1063                 goto out;
1064         }
1065
1066         if (le32_to_cpu(flash_dir->rev) != 2) {
1067                 asd_printk("unsupported flash dir version:0x%x\n",
1068                            le32_to_cpu(flash_dir->rev));
1069                 goto out;
1070         }
1071
1072         err = asd_process_ms(asd_ha, flash_dir);
1073         if (err) {
1074                 ASD_DPRINTK("couldn't process manuf sector settings\n");
1075                 goto out;
1076         }
1077
1078         err = asd_process_ctrl_a_user(asd_ha, flash_dir);
1079         if (err) {
1080                 ASD_DPRINTK("couldn't process CTRL-A user settings\n");
1081                 goto out;
1082         }
1083
1084 out:
1085         kfree(flash_dir);
1086         return err;
1087 }
1088
1089 /**
1090  * asd_verify_flash_seg - verify data with flash memory
1091  * @asd_ha: pointer to the host adapter structure
1092  * @src: pointer to the source data to be verified
1093  * @dest_offset: offset from flash memory
1094  * @bytes_to_verify: total bytes to verify
1095  */
1096 int asd_verify_flash_seg(struct asd_ha_struct *asd_ha,
1097                          const void *src, u32 dest_offset, u32 bytes_to_verify)
1098 {
1099         const u8 *src_buf;
1100         u8 flash_char;
1101         int err;
1102         u32 nv_offset, reg, i;
1103
1104         reg = asd_ha->hw_prof.flash.bar;
1105         src_buf = NULL;
1106
1107         err = FLASH_OK;
1108         nv_offset = dest_offset;
1109         src_buf = (const u8 *)src;
1110         for (i = 0; i < bytes_to_verify; i++) {
1111                 flash_char = asd_read_reg_byte(asd_ha, reg + nv_offset + i);
1112                 if (flash_char != src_buf[i]) {
1113                         err = FAIL_VERIFY;
1114                         break;
1115                 }
1116         }
1117         return err;
1118 }
1119
1120 /**
1121  * asd_write_flash_seg - write data into flash memory
1122  * @asd_ha: pointer to the host adapter structure
1123  * @src: pointer to the source data to be written
1124  * @dest_offset: offset from flash memory
1125  * @bytes_to_write: total bytes to write
1126  */
1127 int asd_write_flash_seg(struct asd_ha_struct *asd_ha,
1128                         const void *src, u32 dest_offset, u32 bytes_to_write)
1129 {
1130         const u8 *src_buf;
1131         u32 nv_offset, reg, i;
1132         int err;
1133
1134         reg = asd_ha->hw_prof.flash.bar;
1135         src_buf = NULL;
1136
1137         err = asd_check_flash_type(asd_ha);
1138         if (err) {
1139                 ASD_DPRINTK("couldn't find the type of flash. err=%d\n", err);
1140                 return err;
1141         }
1142
1143         nv_offset = dest_offset;
1144         err = asd_erase_nv_sector(asd_ha, nv_offset, bytes_to_write);
1145         if (err) {
1146                 ASD_DPRINTK("Erase failed at offset:0x%x\n",
1147                         nv_offset);
1148                 return err;
1149         }
1150
1151         err = asd_reset_flash(asd_ha);
1152         if (err) {
1153                 ASD_DPRINTK("couldn't reset flash. err=%d\n", err);
1154                 return err;
1155         }
1156
1157         src_buf = (const u8 *)src;
1158         for (i = 0; i < bytes_to_write; i++) {
1159                 /* Setup program command sequence */
1160                 switch (asd_ha->hw_prof.flash.method) {
1161                 case FLASH_METHOD_A:
1162                 {
1163                         asd_write_reg_byte(asd_ha,
1164                                         (reg + 0xAAA), 0xAA);
1165                         asd_write_reg_byte(asd_ha,
1166                                         (reg + 0x555), 0x55);
1167                         asd_write_reg_byte(asd_ha,
1168                                         (reg + 0xAAA), 0xA0);
1169                         asd_write_reg_byte(asd_ha,
1170                                         (reg + nv_offset + i),
1171                                         (*(src_buf + i)));
1172                         break;
1173                 }
1174                 case FLASH_METHOD_B:
1175                 {
1176                         asd_write_reg_byte(asd_ha,
1177                                         (reg + 0x555), 0xAA);
1178                         asd_write_reg_byte(asd_ha,
1179                                         (reg + 0x2AA), 0x55);
1180                         asd_write_reg_byte(asd_ha,
1181                                         (reg + 0x555), 0xA0);
1182                         asd_write_reg_byte(asd_ha,
1183                                         (reg + nv_offset + i),
1184                                         (*(src_buf + i)));
1185                         break;
1186                 }
1187                 default:
1188                         break;
1189                 }
1190                 if (asd_chk_write_status(asd_ha,
1191                                 (nv_offset + i), 0) != 0) {
1192                         ASD_DPRINTK("aicx: Write failed at offset:0x%x\n",
1193                                 reg + nv_offset + i);
1194                         return FAIL_WRITE_FLASH;
1195                 }
1196         }
1197
1198         err = asd_reset_flash(asd_ha);
1199         if (err) {
1200                 ASD_DPRINTK("couldn't reset flash. err=%d\n", err);
1201                 return err;
1202         }
1203         return 0;
1204 }
1205
1206 int asd_chk_write_status(struct asd_ha_struct *asd_ha,
1207          u32 sector_addr, u8 erase_flag)
1208 {
1209         u32 reg;
1210         u32 loop_cnt;
1211         u8  nv_data1, nv_data2;
1212         u8  toggle_bit1;
1213
1214         /*
1215          * Read from DQ2 requires sector address
1216          * while it's dont care for DQ6
1217          */
1218         reg = asd_ha->hw_prof.flash.bar;
1219
1220         for (loop_cnt = 0; loop_cnt < 50000; loop_cnt++) {
1221                 nv_data1 = asd_read_reg_byte(asd_ha, reg);
1222                 nv_data2 = asd_read_reg_byte(asd_ha, reg);
1223
1224                 toggle_bit1 = ((nv_data1 & FLASH_STATUS_BIT_MASK_DQ6)
1225                                  ^ (nv_data2 & FLASH_STATUS_BIT_MASK_DQ6));
1226
1227                 if (toggle_bit1 == 0) {
1228                         return 0;
1229                 } else {
1230                         if (nv_data2 & FLASH_STATUS_BIT_MASK_DQ5) {
1231                                 nv_data1 = asd_read_reg_byte(asd_ha,
1232                                                                 reg);
1233                                 nv_data2 = asd_read_reg_byte(asd_ha,
1234                                                                 reg);
1235                                 toggle_bit1 =
1236                                 ((nv_data1 & FLASH_STATUS_BIT_MASK_DQ6)
1237                                 ^ (nv_data2 & FLASH_STATUS_BIT_MASK_DQ6));
1238
1239                                 if (toggle_bit1 == 0)
1240                                         return 0;
1241                         }
1242                 }
1243
1244                 /*
1245                  * ERASE is a sector-by-sector operation and requires
1246                  * more time to finish while WRITE is byte-byte-byte
1247                  * operation and takes lesser time to finish.
1248                  *
1249                  * For some strange reason a reduced ERASE delay gives different
1250                  * behaviour across different spirit boards. Hence we set
1251                  * a optimum balance of 50mus for ERASE which works well
1252                  * across all boards.
1253                  */
1254                 if (erase_flag) {
1255                         udelay(FLASH_STATUS_ERASE_DELAY_COUNT);
1256                 } else {
1257                         udelay(FLASH_STATUS_WRITE_DELAY_COUNT);
1258                 }
1259         }
1260         return -1;
1261 }
1262
1263 /**
1264  * asd_hwi_erase_nv_sector - Erase the flash memory sectors.
1265  * @asd_ha: pointer to the host adapter structure
1266  * @flash_addr: pointer to offset from flash memory
1267  * @size: total bytes to erase.
1268  */
1269 int asd_erase_nv_sector(struct asd_ha_struct *asd_ha, u32 flash_addr, u32 size)
1270 {
1271         u32 reg;
1272         u32 sector_addr;
1273
1274         reg = asd_ha->hw_prof.flash.bar;
1275
1276         /* sector staring address */
1277         sector_addr = flash_addr & FLASH_SECTOR_SIZE_MASK;
1278
1279         /*
1280          * Erasing an flash sector needs to be done in six consecutive
1281          * write cyles.
1282          */
1283         while (sector_addr < flash_addr+size) {
1284                 switch (asd_ha->hw_prof.flash.method) {
1285                 case FLASH_METHOD_A:
1286                         asd_write_reg_byte(asd_ha, (reg + 0xAAA), 0xAA);
1287                         asd_write_reg_byte(asd_ha, (reg + 0x555), 0x55);
1288                         asd_write_reg_byte(asd_ha, (reg + 0xAAA), 0x80);
1289                         asd_write_reg_byte(asd_ha, (reg + 0xAAA), 0xAA);
1290                         asd_write_reg_byte(asd_ha, (reg + 0x555), 0x55);
1291                         asd_write_reg_byte(asd_ha, (reg + sector_addr), 0x30);
1292                         break;
1293                 case FLASH_METHOD_B:
1294                         asd_write_reg_byte(asd_ha, (reg + 0x555), 0xAA);
1295                         asd_write_reg_byte(asd_ha, (reg + 0x2AA), 0x55);
1296                         asd_write_reg_byte(asd_ha, (reg + 0x555), 0x80);
1297                         asd_write_reg_byte(asd_ha, (reg + 0x555), 0xAA);
1298                         asd_write_reg_byte(asd_ha, (reg + 0x2AA), 0x55);
1299                         asd_write_reg_byte(asd_ha, (reg + sector_addr), 0x30);
1300                         break;
1301                 default:
1302                         break;
1303                 }
1304
1305                 if (asd_chk_write_status(asd_ha, sector_addr, 1) != 0)
1306                         return FAIL_ERASE_FLASH;
1307
1308                 sector_addr += FLASH_SECTOR_SIZE;
1309         }
1310
1311         return 0;
1312 }
1313
1314 int asd_check_flash_type(struct asd_ha_struct *asd_ha)
1315 {
1316         u8 manuf_id;
1317         u8 dev_id;
1318         u8 sec_prot;
1319         u32 inc;
1320         u32 reg;
1321         int err;
1322
1323         /* get Flash memory base address */
1324         reg = asd_ha->hw_prof.flash.bar;
1325
1326         /* Determine flash info */
1327         err = asd_reset_flash(asd_ha);
1328         if (err) {
1329                 ASD_DPRINTK("couldn't reset flash. err=%d\n", err);
1330                 return err;
1331         }
1332
1333         asd_ha->hw_prof.flash.method = FLASH_METHOD_UNKNOWN;
1334         asd_ha->hw_prof.flash.manuf = FLASH_MANUF_ID_UNKNOWN;
1335         asd_ha->hw_prof.flash.dev_id = FLASH_DEV_ID_UNKNOWN;
1336
1337         /* Get flash info. This would most likely be AMD Am29LV family flash.
1338          * First try the sequence for word mode.  It is the same as for
1339          * 008B (byte mode only), 160B (word mode) and 800D (word mode).
1340          */
1341         inc = asd_ha->hw_prof.flash.wide ? 2 : 1;
1342         asd_write_reg_byte(asd_ha, reg + 0xAAA, 0xAA);
1343         asd_write_reg_byte(asd_ha, reg + 0x555, 0x55);
1344         asd_write_reg_byte(asd_ha, reg + 0xAAA, 0x90);
1345         manuf_id = asd_read_reg_byte(asd_ha, reg);
1346         dev_id = asd_read_reg_byte(asd_ha, reg + inc);
1347         sec_prot = asd_read_reg_byte(asd_ha, reg + inc + inc);
1348         /* Get out of autoselect mode. */
1349         err = asd_reset_flash(asd_ha);
1350         if (err) {
1351                 ASD_DPRINTK("couldn't reset flash. err=%d\n", err);
1352                 return err;
1353         }
1354         ASD_DPRINTK("Flash MethodA manuf_id(0x%x) dev_id(0x%x) "
1355                 "sec_prot(0x%x)\n", manuf_id, dev_id, sec_prot);
1356         err = asd_reset_flash(asd_ha);
1357         if (err != 0)
1358                 return err;
1359
1360         switch (manuf_id) {
1361         case FLASH_MANUF_ID_AMD:
1362                 switch (sec_prot) {
1363                 case FLASH_DEV_ID_AM29LV800DT:
1364                 case FLASH_DEV_ID_AM29LV640MT:
1365                 case FLASH_DEV_ID_AM29F800B:
1366                         asd_ha->hw_prof.flash.method = FLASH_METHOD_A;
1367                         break;
1368                 default:
1369                         break;
1370                 }
1371                 break;
1372         case FLASH_MANUF_ID_ST:
1373                 switch (sec_prot) {
1374                 case FLASH_DEV_ID_STM29W800DT:
1375                 case FLASH_DEV_ID_STM29LV640:
1376                         asd_ha->hw_prof.flash.method = FLASH_METHOD_A;
1377                         break;
1378                 default:
1379                         break;
1380                 }
1381                 break;
1382         case FLASH_MANUF_ID_FUJITSU:
1383                 switch (sec_prot) {
1384                 case FLASH_DEV_ID_MBM29LV800TE:
1385                 case FLASH_DEV_ID_MBM29DL800TA:
1386                         asd_ha->hw_prof.flash.method = FLASH_METHOD_A;
1387                         break;
1388                 }
1389                 break;
1390         case FLASH_MANUF_ID_MACRONIX:
1391                 switch (sec_prot) {
1392                 case FLASH_DEV_ID_MX29LV800BT:
1393                         asd_ha->hw_prof.flash.method = FLASH_METHOD_A;
1394                         break;
1395                 }
1396                 break;
1397         }
1398
1399         if (asd_ha->hw_prof.flash.method == FLASH_METHOD_UNKNOWN) {
1400                 err = asd_reset_flash(asd_ha);
1401                 if (err) {
1402                         ASD_DPRINTK("couldn't reset flash. err=%d\n", err);
1403                         return err;
1404                 }
1405
1406                 /* Issue Unlock sequence for AM29LV008BT */
1407                 asd_write_reg_byte(asd_ha, (reg + 0x555), 0xAA);
1408                 asd_write_reg_byte(asd_ha, (reg + 0x2AA), 0x55);
1409                 asd_write_reg_byte(asd_ha, (reg + 0x555), 0x90);
1410                 manuf_id = asd_read_reg_byte(asd_ha, reg);
1411                 dev_id = asd_read_reg_byte(asd_ha, reg + inc);
1412                 sec_prot = asd_read_reg_byte(asd_ha, reg + inc + inc);
1413
1414                 ASD_DPRINTK("Flash MethodB manuf_id(0x%x) dev_id(0x%x) sec_prot"
1415                         "(0x%x)\n", manuf_id, dev_id, sec_prot);
1416
1417                 err = asd_reset_flash(asd_ha);
1418                 if (err != 0) {
1419                         ASD_DPRINTK("couldn't reset flash. err=%d\n", err);
1420                         return err;
1421                 }
1422
1423                 switch (manuf_id) {
1424                 case FLASH_MANUF_ID_AMD:
1425                         switch (dev_id) {
1426                         case FLASH_DEV_ID_AM29LV008BT:
1427                                 asd_ha->hw_prof.flash.method = FLASH_METHOD_B;
1428                                 break;
1429                         default:
1430                                 break;
1431                         }
1432                         break;
1433                 case FLASH_MANUF_ID_ST:
1434                         switch (dev_id) {
1435                         case FLASH_DEV_ID_STM29008:
1436                                 asd_ha->hw_prof.flash.method = FLASH_METHOD_B;
1437                                 break;
1438                         default:
1439                                 break;
1440                         }
1441                         break;
1442                 case FLASH_MANUF_ID_FUJITSU:
1443                         switch (dev_id) {
1444                         case FLASH_DEV_ID_MBM29LV008TA:
1445                                 asd_ha->hw_prof.flash.method = FLASH_METHOD_B;
1446                                 break;
1447                         }
1448                         break;
1449                 case FLASH_MANUF_ID_INTEL:
1450                         switch (dev_id) {
1451                         case FLASH_DEV_ID_I28LV00TAT:
1452                                 asd_ha->hw_prof.flash.method = FLASH_METHOD_B;
1453                                 break;
1454                         }
1455                         break;
1456                 case FLASH_MANUF_ID_MACRONIX:
1457                         switch (dev_id) {
1458                         case FLASH_DEV_ID_I28LV00TAT:
1459                                 asd_ha->hw_prof.flash.method = FLASH_METHOD_B;
1460                                 break;
1461                         }
1462                         break;
1463                 default:
1464                         return FAIL_FIND_FLASH_ID;
1465                 }
1466         }
1467
1468         if (asd_ha->hw_prof.flash.method == FLASH_METHOD_UNKNOWN)
1469               return FAIL_FIND_FLASH_ID;
1470
1471         asd_ha->hw_prof.flash.manuf = manuf_id;
1472         asd_ha->hw_prof.flash.dev_id = dev_id;
1473         asd_ha->hw_prof.flash.sec_prot = sec_prot;
1474         return 0;
1475 }