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