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