1 /* 2 * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family 3 * of PCI-SCSI IO processors. 4 * 5 * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr> 6 * 7 * This driver is derived from the Linux sym53c8xx driver. 8 * Copyright (C) 1998-2000 Gerard Roudier 9 * 10 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been 11 * a port of the FreeBSD ncr driver to Linux-1.2.13. 12 * 13 * The original ncr driver has been written for 386bsd and FreeBSD by 14 * Wolfgang Stanglmeier <wolf@cologne.de> 15 * Stefan Esser <se@mi.Uni-Koeln.de> 16 * Copyright (C) 1994 Wolfgang Stanglmeier 17 * 18 * Other major contributions: 19 * 20 * NVRAM detection and reading. 21 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk> 22 * 23 *----------------------------------------------------------------------------- 24 * 25 * This program is free software; you can redistribute it and/or modify 26 * it under the terms of the GNU General Public License as published by 27 * the Free Software Foundation; either version 2 of the License, or 28 * (at your option) any later version. 29 * 30 * This program is distributed in the hope that it will be useful, 31 * but WITHOUT ANY WARRANTY; without even the implied warranty of 32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 33 * GNU General Public License for more details. 34 * 35 * You should have received a copy of the GNU General Public License 36 * along with this program; if not, write to the Free Software 37 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 38 */ 39 40 #include "sym_glue.h" 41 42 /* 43 * Macros used for all firmwares. 44 */ 45 #define SYM_GEN_A(s, label) ((short) offsetof(s, label)), 46 #define SYM_GEN_B(s, label) ((short) offsetof(s, label)), 47 #define SYM_GEN_Z(s, label) ((short) offsetof(s, label)), 48 #define PADDR_A(label) SYM_GEN_PADDR_A(struct SYM_FWA_SCR, label) 49 #define PADDR_B(label) SYM_GEN_PADDR_B(struct SYM_FWB_SCR, label) 50 51 52 #if SYM_CONF_GENERIC_SUPPORT 53 /* 54 * Allocate firmware #1 script area. 55 */ 56 #define SYM_FWA_SCR sym_fw1a_scr 57 #define SYM_FWB_SCR sym_fw1b_scr 58 #define SYM_FWZ_SCR sym_fw1z_scr 59 #include "sym_fw1.h" 60 static struct sym_fwa_ofs sym_fw1a_ofs = { 61 SYM_GEN_FW_A(struct SYM_FWA_SCR) 62 }; 63 static struct sym_fwb_ofs sym_fw1b_ofs = { 64 SYM_GEN_FW_B(struct SYM_FWB_SCR) 65 }; 66 static struct sym_fwz_ofs sym_fw1z_ofs = { 67 SYM_GEN_FW_Z(struct SYM_FWZ_SCR) 68 }; 69 #undef SYM_FWA_SCR 70 #undef SYM_FWB_SCR 71 #undef SYM_FWZ_SCR 72 #endif /* SYM_CONF_GENERIC_SUPPORT */ 73 74 /* 75 * Allocate firmware #2 script area. 76 */ 77 #define SYM_FWA_SCR sym_fw2a_scr 78 #define SYM_FWB_SCR sym_fw2b_scr 79 #define SYM_FWZ_SCR sym_fw2z_scr 80 #include "sym_fw2.h" 81 static struct sym_fwa_ofs sym_fw2a_ofs = { 82 SYM_GEN_FW_A(struct SYM_FWA_SCR) 83 }; 84 static struct sym_fwb_ofs sym_fw2b_ofs = { 85 SYM_GEN_FW_B(struct SYM_FWB_SCR) 86 SYM_GEN_B(struct SYM_FWB_SCR, start64) 87 SYM_GEN_B(struct SYM_FWB_SCR, pm_handle) 88 }; 89 static struct sym_fwz_ofs sym_fw2z_ofs = { 90 SYM_GEN_FW_Z(struct SYM_FWZ_SCR) 91 }; 92 #undef SYM_FWA_SCR 93 #undef SYM_FWB_SCR 94 #undef SYM_FWZ_SCR 95 96 #undef SYM_GEN_A 97 #undef SYM_GEN_B 98 #undef SYM_GEN_Z 99 #undef PADDR_A 100 #undef PADDR_B 101 102 #if SYM_CONF_GENERIC_SUPPORT 103 /* 104 * Patch routine for firmware #1. 105 */ 106 static void 107 sym_fw1_patch(struct Scsi_Host *shost) 108 { 109 struct sym_hcb *np = sym_get_hcb(shost); 110 struct sym_fw1a_scr *scripta0; 111 struct sym_fw1b_scr *scriptb0; 112 113 scripta0 = (struct sym_fw1a_scr *) np->scripta0; 114 scriptb0 = (struct sym_fw1b_scr *) np->scriptb0; 115 116 /* 117 * Remove LED support if not needed. 118 */ 119 if (!(np->features & FE_LED0)) { 120 scripta0->idle[0] = cpu_to_scr(SCR_NO_OP); 121 scripta0->reselected[0] = cpu_to_scr(SCR_NO_OP); 122 scripta0->start[0] = cpu_to_scr(SCR_NO_OP); 123 } 124 125 #ifdef SYM_CONF_IARB_SUPPORT 126 /* 127 * If user does not want to use IMMEDIATE ARBITRATION 128 * when we are reselected while attempting to arbitrate, 129 * patch the SCRIPTS accordingly with a SCRIPT NO_OP. 130 */ 131 if (!SYM_CONF_SET_IARB_ON_ARB_LOST) 132 scripta0->ungetjob[0] = cpu_to_scr(SCR_NO_OP); 133 #endif 134 /* 135 * Patch some data in SCRIPTS. 136 * - start and done queue initial bus address. 137 * - target bus address table bus address. 138 */ 139 scriptb0->startpos[0] = cpu_to_scr(np->squeue_ba); 140 scriptb0->done_pos[0] = cpu_to_scr(np->dqueue_ba); 141 scriptb0->targtbl[0] = cpu_to_scr(np->targtbl_ba); 142 } 143 #endif /* SYM_CONF_GENERIC_SUPPORT */ 144 145 /* 146 * Patch routine for firmware #2. 147 */ 148 static void 149 sym_fw2_patch(struct Scsi_Host *shost) 150 { 151 struct sym_data *sym_data = shost_priv(shost); 152 struct pci_dev *pdev = sym_data->pdev; 153 struct sym_hcb *np = sym_data->ncb; 154 struct sym_fw2a_scr *scripta0; 155 struct sym_fw2b_scr *scriptb0; 156 157 scripta0 = (struct sym_fw2a_scr *) np->scripta0; 158 scriptb0 = (struct sym_fw2b_scr *) np->scriptb0; 159 160 /* 161 * Remove LED support if not needed. 162 */ 163 if (!(np->features & FE_LED0)) { 164 scripta0->idle[0] = cpu_to_scr(SCR_NO_OP); 165 scripta0->reselected[0] = cpu_to_scr(SCR_NO_OP); 166 scripta0->start[0] = cpu_to_scr(SCR_NO_OP); 167 } 168 169 #if SYM_CONF_DMA_ADDRESSING_MODE == 2 170 /* 171 * Remove useless 64 bit DMA specific SCRIPTS, 172 * when this feature is not available. 173 */ 174 if (!use_dac(np)) { 175 scripta0->is_dmap_dirty[0] = cpu_to_scr(SCR_NO_OP); 176 scripta0->is_dmap_dirty[1] = 0; 177 scripta0->is_dmap_dirty[2] = cpu_to_scr(SCR_NO_OP); 178 scripta0->is_dmap_dirty[3] = 0; 179 } 180 #endif 181 182 #ifdef SYM_CONF_IARB_SUPPORT 183 /* 184 * If user does not want to use IMMEDIATE ARBITRATION 185 * when we are reselected while attempting to arbitrate, 186 * patch the SCRIPTS accordingly with a SCRIPT NO_OP. 187 */ 188 if (!SYM_CONF_SET_IARB_ON_ARB_LOST) 189 scripta0->ungetjob[0] = cpu_to_scr(SCR_NO_OP); 190 #endif 191 /* 192 * Patch some variable in SCRIPTS. 193 * - start and done queue initial bus address. 194 * - target bus address table bus address. 195 */ 196 scriptb0->startpos[0] = cpu_to_scr(np->squeue_ba); 197 scriptb0->done_pos[0] = cpu_to_scr(np->dqueue_ba); 198 scriptb0->targtbl[0] = cpu_to_scr(np->targtbl_ba); 199 200 /* 201 * Remove the load of SCNTL4 on reselection if not a C10. 202 */ 203 if (!(np->features & FE_C10)) { 204 scripta0->resel_scntl4[0] = cpu_to_scr(SCR_NO_OP); 205 scripta0->resel_scntl4[1] = cpu_to_scr(0); 206 } 207 208 /* 209 * Remove a couple of work-arounds specific to C1010 if 210 * they are not desirable. See `sym_fw2.h' for more details. 211 */ 212 if (!(pdev->device == PCI_DEVICE_ID_LSI_53C1010_66 && 213 pdev->revision < 0x1 && 214 np->pciclk_khz < 60000)) { 215 scripta0->datao_phase[0] = cpu_to_scr(SCR_NO_OP); 216 scripta0->datao_phase[1] = cpu_to_scr(0); 217 } 218 if (!(pdev->device == PCI_DEVICE_ID_LSI_53C1010_33 /* && 219 pdev->revision < 0xff */)) { 220 scripta0->sel_done[0] = cpu_to_scr(SCR_NO_OP); 221 scripta0->sel_done[1] = cpu_to_scr(0); 222 } 223 224 /* 225 * Patch some other variables in SCRIPTS. 226 * These ones are loaded by the SCRIPTS processor. 227 */ 228 scriptb0->pm0_data_addr[0] = 229 cpu_to_scr(np->scripta_ba + 230 offsetof(struct sym_fw2a_scr, pm0_data)); 231 scriptb0->pm1_data_addr[0] = 232 cpu_to_scr(np->scripta_ba + 233 offsetof(struct sym_fw2a_scr, pm1_data)); 234 } 235 236 /* 237 * Fill the data area in scripts. 238 * To be done for all firmwares. 239 */ 240 static void 241 sym_fw_fill_data (u32 *in, u32 *out) 242 { 243 int i; 244 245 for (i = 0; i < SYM_CONF_MAX_SG; i++) { 246 *in++ = SCR_CHMOV_TBL ^ SCR_DATA_IN; 247 *in++ = offsetof (struct sym_dsb, data[i]); 248 *out++ = SCR_CHMOV_TBL ^ SCR_DATA_OUT; 249 *out++ = offsetof (struct sym_dsb, data[i]); 250 } 251 } 252 253 /* 254 * Setup useful script bus addresses. 255 * To be done for all firmwares. 256 */ 257 static void 258 sym_fw_setup_bus_addresses(struct sym_hcb *np, struct sym_fw *fw) 259 { 260 u32 *pa; 261 u_short *po; 262 int i; 263 264 /* 265 * Build the bus address table for script A 266 * from the script A offset table. 267 */ 268 po = (u_short *) fw->a_ofs; 269 pa = (u32 *) &np->fwa_bas; 270 for (i = 0 ; i < sizeof(np->fwa_bas)/sizeof(u32) ; i++) 271 pa[i] = np->scripta_ba + po[i]; 272 273 /* 274 * Same for script B. 275 */ 276 po = (u_short *) fw->b_ofs; 277 pa = (u32 *) &np->fwb_bas; 278 for (i = 0 ; i < sizeof(np->fwb_bas)/sizeof(u32) ; i++) 279 pa[i] = np->scriptb_ba + po[i]; 280 281 /* 282 * Same for script Z. 283 */ 284 po = (u_short *) fw->z_ofs; 285 pa = (u32 *) &np->fwz_bas; 286 for (i = 0 ; i < sizeof(np->fwz_bas)/sizeof(u32) ; i++) 287 pa[i] = np->scriptz_ba + po[i]; 288 } 289 290 #if SYM_CONF_GENERIC_SUPPORT 291 /* 292 * Setup routine for firmware #1. 293 */ 294 static void 295 sym_fw1_setup(struct sym_hcb *np, struct sym_fw *fw) 296 { 297 struct sym_fw1a_scr *scripta0; 298 299 scripta0 = (struct sym_fw1a_scr *) np->scripta0; 300 301 /* 302 * Fill variable parts in scripts. 303 */ 304 sym_fw_fill_data(scripta0->data_in, scripta0->data_out); 305 306 /* 307 * Setup bus addresses used from the C code.. 308 */ 309 sym_fw_setup_bus_addresses(np, fw); 310 } 311 #endif /* SYM_CONF_GENERIC_SUPPORT */ 312 313 /* 314 * Setup routine for firmware #2. 315 */ 316 static void 317 sym_fw2_setup(struct sym_hcb *np, struct sym_fw *fw) 318 { 319 struct sym_fw2a_scr *scripta0; 320 321 scripta0 = (struct sym_fw2a_scr *) np->scripta0; 322 323 /* 324 * Fill variable parts in scripts. 325 */ 326 sym_fw_fill_data(scripta0->data_in, scripta0->data_out); 327 328 /* 329 * Setup bus addresses used from the C code.. 330 */ 331 sym_fw_setup_bus_addresses(np, fw); 332 } 333 334 /* 335 * Allocate firmware descriptors. 336 */ 337 #if SYM_CONF_GENERIC_SUPPORT 338 static struct sym_fw sym_fw1 = SYM_FW_ENTRY(sym_fw1, "NCR-generic"); 339 #endif /* SYM_CONF_GENERIC_SUPPORT */ 340 static struct sym_fw sym_fw2 = SYM_FW_ENTRY(sym_fw2, "LOAD/STORE-based"); 341 342 /* 343 * Find the most appropriate firmware for a chip. 344 */ 345 struct sym_fw * 346 sym_find_firmware(struct sym_chip *chip) 347 { 348 if (chip->features & FE_LDSTR) 349 return &sym_fw2; 350 #if SYM_CONF_GENERIC_SUPPORT 351 else if (!(chip->features & (FE_PFEN|FE_NOPM|FE_DAC))) 352 return &sym_fw1; 353 #endif 354 else 355 return NULL; 356 } 357 358 /* 359 * Bind a script to physical addresses. 360 */ 361 void sym_fw_bind_script(struct sym_hcb *np, u32 *start, int len) 362 { 363 u32 opcode, new, old, tmp1, tmp2; 364 u32 *end, *cur; 365 int relocs; 366 367 cur = start; 368 end = start + len/4; 369 370 while (cur < end) { 371 372 opcode = *cur; 373 374 /* 375 * If we forget to change the length 376 * in scripts, a field will be 377 * padded with 0. This is an illegal 378 * command. 379 */ 380 if (opcode == 0) { 381 printf ("%s: ERROR0 IN SCRIPT at %d.\n", 382 sym_name(np), (int) (cur-start)); 383 ++cur; 384 continue; 385 }; 386 387 /* 388 * We use the bogus value 0xf00ff00f ;-) 389 * to reserve data area in SCRIPTS. 390 */ 391 if (opcode == SCR_DATA_ZERO) { 392 *cur++ = 0; 393 continue; 394 } 395 396 if (DEBUG_FLAGS & DEBUG_SCRIPT) 397 printf ("%d: <%x>\n", (int) (cur-start), 398 (unsigned)opcode); 399 400 /* 401 * We don't have to decode ALL commands 402 */ 403 switch (opcode >> 28) { 404 case 0xf: 405 /* 406 * LOAD / STORE DSA relative, don't relocate. 407 */ 408 relocs = 0; 409 break; 410 case 0xe: 411 /* 412 * LOAD / STORE absolute. 413 */ 414 relocs = 1; 415 break; 416 case 0xc: 417 /* 418 * COPY has TWO arguments. 419 */ 420 relocs = 2; 421 tmp1 = cur[1]; 422 tmp2 = cur[2]; 423 if ((tmp1 ^ tmp2) & 3) { 424 printf ("%s: ERROR1 IN SCRIPT at %d.\n", 425 sym_name(np), (int) (cur-start)); 426 } 427 /* 428 * If PREFETCH feature not enabled, remove 429 * the NO FLUSH bit if present. 430 */ 431 if ((opcode & SCR_NO_FLUSH) && 432 !(np->features & FE_PFEN)) { 433 opcode = (opcode & ~SCR_NO_FLUSH); 434 } 435 break; 436 case 0x0: 437 /* 438 * MOVE/CHMOV (absolute address) 439 */ 440 if (!(np->features & FE_WIDE)) 441 opcode = (opcode | OPC_MOVE); 442 relocs = 1; 443 break; 444 case 0x1: 445 /* 446 * MOVE/CHMOV (table indirect) 447 */ 448 if (!(np->features & FE_WIDE)) 449 opcode = (opcode | OPC_MOVE); 450 relocs = 0; 451 break; 452 #ifdef SYM_CONF_TARGET_ROLE_SUPPORT 453 case 0x2: 454 /* 455 * MOVE/CHMOV in target role (absolute address) 456 */ 457 opcode &= ~0x20000000; 458 if (!(np->features & FE_WIDE)) 459 opcode = (opcode & ~OPC_TCHMOVE); 460 relocs = 1; 461 break; 462 case 0x3: 463 /* 464 * MOVE/CHMOV in target role (table indirect) 465 */ 466 opcode &= ~0x20000000; 467 if (!(np->features & FE_WIDE)) 468 opcode = (opcode & ~OPC_TCHMOVE); 469 relocs = 0; 470 break; 471 #endif 472 case 0x8: 473 /* 474 * JUMP / CALL 475 * don't relocate if relative :-) 476 */ 477 if (opcode & 0x00800000) 478 relocs = 0; 479 else if ((opcode & 0xf8400000) == 0x80400000)/*JUMP64*/ 480 relocs = 2; 481 else 482 relocs = 1; 483 break; 484 case 0x4: 485 case 0x5: 486 case 0x6: 487 case 0x7: 488 relocs = 1; 489 break; 490 default: 491 relocs = 0; 492 break; 493 }; 494 495 /* 496 * Scriptify:) the opcode. 497 */ 498 *cur++ = cpu_to_scr(opcode); 499 500 /* 501 * If no relocation, assume 1 argument 502 * and just scriptize:) it. 503 */ 504 if (!relocs) { 505 *cur = cpu_to_scr(*cur); 506 ++cur; 507 continue; 508 } 509 510 /* 511 * Otherwise performs all needed relocations. 512 */ 513 while (relocs--) { 514 old = *cur; 515 516 switch (old & RELOC_MASK) { 517 case RELOC_REGISTER: 518 new = (old & ~RELOC_MASK) + np->mmio_ba; 519 break; 520 case RELOC_LABEL_A: 521 new = (old & ~RELOC_MASK) + np->scripta_ba; 522 break; 523 case RELOC_LABEL_B: 524 new = (old & ~RELOC_MASK) + np->scriptb_ba; 525 break; 526 case RELOC_SOFTC: 527 new = (old & ~RELOC_MASK) + np->hcb_ba; 528 break; 529 case 0: 530 /* 531 * Don't relocate a 0 address. 532 * They are mostly used for patched or 533 * script self-modified areas. 534 */ 535 if (old == 0) { 536 new = old; 537 break; 538 } 539 /* fall through */ 540 default: 541 new = 0; 542 panic("sym_fw_bind_script: " 543 "weird relocation %x\n", old); 544 break; 545 } 546 547 *cur++ = cpu_to_scr(new); 548 } 549 }; 550 } 551