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 <linux/gfp.h> 41 42 #ifndef SYM_HIPD_H 43 #define SYM_HIPD_H 44 45 /* 46 * Generic driver options. 47 * 48 * They may be defined in platform specific headers, if they 49 * are useful. 50 * 51 * SYM_OPT_HANDLE_DIR_UNKNOWN 52 * When this option is set, the SCRIPTS used by the driver 53 * are able to handle SCSI transfers with direction not 54 * supplied by user. 55 * (set for Linux-2.0.X) 56 * 57 * SYM_OPT_HANDLE_DEVICE_QUEUEING 58 * When this option is set, the driver will use a queue per 59 * device and handle QUEUE FULL status requeuing internally. 60 * 61 * SYM_OPT_LIMIT_COMMAND_REORDERING 62 * When this option is set, the driver tries to limit tagged 63 * command reordering to some reasonnable value. 64 * (set for Linux) 65 */ 66 #if 0 67 #define SYM_OPT_HANDLE_DIR_UNKNOWN 68 #define SYM_OPT_HANDLE_DEVICE_QUEUEING 69 #define SYM_OPT_LIMIT_COMMAND_REORDERING 70 #endif 71 72 /* 73 * Active debugging tags and verbosity. 74 * Both DEBUG_FLAGS and sym_verbose can be redefined 75 * by the platform specific code to something else. 76 */ 77 #define DEBUG_ALLOC (0x0001) 78 #define DEBUG_PHASE (0x0002) 79 #define DEBUG_POLL (0x0004) 80 #define DEBUG_QUEUE (0x0008) 81 #define DEBUG_RESULT (0x0010) 82 #define DEBUG_SCATTER (0x0020) 83 #define DEBUG_SCRIPT (0x0040) 84 #define DEBUG_TINY (0x0080) 85 #define DEBUG_TIMING (0x0100) 86 #define DEBUG_NEGO (0x0200) 87 #define DEBUG_TAGS (0x0400) 88 #define DEBUG_POINTER (0x0800) 89 90 #ifndef DEBUG_FLAGS 91 #define DEBUG_FLAGS (0x0000) 92 #endif 93 94 #ifndef sym_verbose 95 #define sym_verbose (np->verbose) 96 #endif 97 98 /* 99 * These ones should have been already defined. 100 */ 101 #ifndef assert 102 #define assert(expression) { \ 103 if (!(expression)) { \ 104 (void)panic( \ 105 "assertion \"%s\" failed: file \"%s\", line %d\n", \ 106 #expression, \ 107 __FILE__, __LINE__); \ 108 } \ 109 } 110 #endif 111 112 /* 113 * Number of tasks per device we want to handle. 114 */ 115 #if SYM_CONF_MAX_TAG_ORDER > 8 116 #error "more than 256 tags per logical unit not allowed." 117 #endif 118 #define SYM_CONF_MAX_TASK (1<<SYM_CONF_MAX_TAG_ORDER) 119 120 /* 121 * Donnot use more tasks that we can handle. 122 */ 123 #ifndef SYM_CONF_MAX_TAG 124 #define SYM_CONF_MAX_TAG SYM_CONF_MAX_TASK 125 #endif 126 #if SYM_CONF_MAX_TAG > SYM_CONF_MAX_TASK 127 #undef SYM_CONF_MAX_TAG 128 #define SYM_CONF_MAX_TAG SYM_CONF_MAX_TASK 129 #endif 130 131 /* 132 * This one means 'NO TAG for this job' 133 */ 134 #define NO_TAG (256) 135 136 /* 137 * Number of SCSI targets. 138 */ 139 #if SYM_CONF_MAX_TARGET > 16 140 #error "more than 16 targets not allowed." 141 #endif 142 143 /* 144 * Number of logical units per target. 145 */ 146 #if SYM_CONF_MAX_LUN > 64 147 #error "more than 64 logical units per target not allowed." 148 #endif 149 150 /* 151 * Asynchronous pre-scaler (ns). Shall be 40 for 152 * the SCSI timings to be compliant. 153 */ 154 #define SYM_CONF_MIN_ASYNC (40) 155 156 157 /* 158 * MEMORY ALLOCATOR. 159 */ 160 161 #define SYM_MEM_WARN 1 /* Warn on failed operations */ 162 163 #define SYM_MEM_PAGE_ORDER 0 /* 1 PAGE maximum */ 164 #define SYM_MEM_CLUSTER_SHIFT (PAGE_SHIFT+SYM_MEM_PAGE_ORDER) 165 #define SYM_MEM_FREE_UNUSED /* Free unused pages immediately */ 166 /* 167 * Shortest memory chunk is (1<<SYM_MEM_SHIFT), currently 16. 168 * Actual allocations happen as SYM_MEM_CLUSTER_SIZE sized. 169 * (1 PAGE at a time is just fine). 170 */ 171 #define SYM_MEM_SHIFT 4 172 #define SYM_MEM_CLUSTER_SIZE (1UL << SYM_MEM_CLUSTER_SHIFT) 173 #define SYM_MEM_CLUSTER_MASK (SYM_MEM_CLUSTER_SIZE-1) 174 175 /* 176 * Number of entries in the START and DONE queues. 177 * 178 * We limit to 1 PAGE in order to succeed allocation of 179 * these queues. Each entry is 8 bytes long (2 DWORDS). 180 */ 181 #ifdef SYM_CONF_MAX_START 182 #define SYM_CONF_MAX_QUEUE (SYM_CONF_MAX_START+2) 183 #else 184 #define SYM_CONF_MAX_QUEUE (7*SYM_CONF_MAX_TASK+2) 185 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2) 186 #endif 187 188 #if SYM_CONF_MAX_QUEUE > SYM_MEM_CLUSTER_SIZE/8 189 #undef SYM_CONF_MAX_QUEUE 190 #define SYM_CONF_MAX_QUEUE (SYM_MEM_CLUSTER_SIZE/8) 191 #undef SYM_CONF_MAX_START 192 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2) 193 #endif 194 195 /* 196 * For this one, we want a short name :-) 197 */ 198 #define MAX_QUEUE SYM_CONF_MAX_QUEUE 199 200 /* 201 * Common definitions for both bus space based and legacy IO methods. 202 */ 203 204 #define INB_OFF(np, o) ioread8(np->s.ioaddr + (o)) 205 #define INW_OFF(np, o) ioread16(np->s.ioaddr + (o)) 206 #define INL_OFF(np, o) ioread32(np->s.ioaddr + (o)) 207 208 #define OUTB_OFF(np, o, val) iowrite8((val), np->s.ioaddr + (o)) 209 #define OUTW_OFF(np, o, val) iowrite16((val), np->s.ioaddr + (o)) 210 #define OUTL_OFF(np, o, val) iowrite32((val), np->s.ioaddr + (o)) 211 212 #define INB(np, r) INB_OFF(np, offsetof(struct sym_reg, r)) 213 #define INW(np, r) INW_OFF(np, offsetof(struct sym_reg, r)) 214 #define INL(np, r) INL_OFF(np, offsetof(struct sym_reg, r)) 215 216 #define OUTB(np, r, v) OUTB_OFF(np, offsetof(struct sym_reg, r), (v)) 217 #define OUTW(np, r, v) OUTW_OFF(np, offsetof(struct sym_reg, r), (v)) 218 #define OUTL(np, r, v) OUTL_OFF(np, offsetof(struct sym_reg, r), (v)) 219 220 #define OUTONB(np, r, m) OUTB(np, r, INB(np, r) | (m)) 221 #define OUTOFFB(np, r, m) OUTB(np, r, INB(np, r) & ~(m)) 222 #define OUTONW(np, r, m) OUTW(np, r, INW(np, r) | (m)) 223 #define OUTOFFW(np, r, m) OUTW(np, r, INW(np, r) & ~(m)) 224 #define OUTONL(np, r, m) OUTL(np, r, INL(np, r) | (m)) 225 #define OUTOFFL(np, r, m) OUTL(np, r, INL(np, r) & ~(m)) 226 227 /* 228 * We normally want the chip to have a consistent view 229 * of driver internal data structures when we restart it. 230 * Thus these macros. 231 */ 232 #define OUTL_DSP(np, v) \ 233 do { \ 234 MEMORY_WRITE_BARRIER(); \ 235 OUTL(np, nc_dsp, (v)); \ 236 } while (0) 237 238 #define OUTONB_STD() \ 239 do { \ 240 MEMORY_WRITE_BARRIER(); \ 241 OUTONB(np, nc_dcntl, (STD|NOCOM)); \ 242 } while (0) 243 244 /* 245 * Command control block states. 246 */ 247 #define HS_IDLE (0) 248 #define HS_BUSY (1) 249 #define HS_NEGOTIATE (2) /* sync/wide data transfer*/ 250 #define HS_DISCONNECT (3) /* Disconnected by target */ 251 #define HS_WAIT (4) /* waiting for resource */ 252 253 #define HS_DONEMASK (0x80) 254 #define HS_COMPLETE (4|HS_DONEMASK) 255 #define HS_SEL_TIMEOUT (5|HS_DONEMASK) /* Selection timeout */ 256 #define HS_UNEXPECTED (6|HS_DONEMASK) /* Unexpected disconnect */ 257 #define HS_COMP_ERR (7|HS_DONEMASK) /* Completed with error */ 258 259 /* 260 * Software Interrupt Codes 261 */ 262 #define SIR_BAD_SCSI_STATUS (1) 263 #define SIR_SEL_ATN_NO_MSG_OUT (2) 264 #define SIR_MSG_RECEIVED (3) 265 #define SIR_MSG_WEIRD (4) 266 #define SIR_NEGO_FAILED (5) 267 #define SIR_NEGO_PROTO (6) 268 #define SIR_SCRIPT_STOPPED (7) 269 #define SIR_REJECT_TO_SEND (8) 270 #define SIR_SWIDE_OVERRUN (9) 271 #define SIR_SODL_UNDERRUN (10) 272 #define SIR_RESEL_NO_MSG_IN (11) 273 #define SIR_RESEL_NO_IDENTIFY (12) 274 #define SIR_RESEL_BAD_LUN (13) 275 #define SIR_TARGET_SELECTED (14) 276 #define SIR_RESEL_BAD_I_T_L (15) 277 #define SIR_RESEL_BAD_I_T_L_Q (16) 278 #define SIR_ABORT_SENT (17) 279 #define SIR_RESEL_ABORTED (18) 280 #define SIR_MSG_OUT_DONE (19) 281 #define SIR_COMPLETE_ERROR (20) 282 #define SIR_DATA_OVERRUN (21) 283 #define SIR_BAD_PHASE (22) 284 #if SYM_CONF_DMA_ADDRESSING_MODE == 2 285 #define SIR_DMAP_DIRTY (23) 286 #define SIR_MAX (23) 287 #else 288 #define SIR_MAX (22) 289 #endif 290 291 /* 292 * Extended error bit codes. 293 * xerr_status field of struct sym_ccb. 294 */ 295 #define XE_EXTRA_DATA (1) /* unexpected data phase */ 296 #define XE_BAD_PHASE (1<<1) /* illegal phase (4/5) */ 297 #define XE_PARITY_ERR (1<<2) /* unrecovered SCSI parity error */ 298 #define XE_SODL_UNRUN (1<<3) /* ODD transfer in DATA OUT phase */ 299 #define XE_SWIDE_OVRUN (1<<4) /* ODD transfer in DATA IN phase */ 300 301 /* 302 * Negotiation status. 303 * nego_status field of struct sym_ccb. 304 */ 305 #define NS_SYNC (1) 306 #define NS_WIDE (2) 307 #define NS_PPR (3) 308 309 /* 310 * A CCB hashed table is used to retrieve CCB address 311 * from DSA value. 312 */ 313 #define CCB_HASH_SHIFT 8 314 #define CCB_HASH_SIZE (1UL << CCB_HASH_SHIFT) 315 #define CCB_HASH_MASK (CCB_HASH_SIZE-1) 316 #if 1 317 #define CCB_HASH_CODE(dsa) \ 318 (((dsa) >> (_LGRU16_(sizeof(struct sym_ccb)))) & CCB_HASH_MASK) 319 #else 320 #define CCB_HASH_CODE(dsa) (((dsa) >> 9) & CCB_HASH_MASK) 321 #endif 322 323 #if SYM_CONF_DMA_ADDRESSING_MODE == 2 324 /* 325 * We may want to use segment registers for 64 bit DMA. 326 * 16 segments registers -> up to 64 GB addressable. 327 */ 328 #define SYM_DMAP_SHIFT (4) 329 #define SYM_DMAP_SIZE (1u<<SYM_DMAP_SHIFT) 330 #define SYM_DMAP_MASK (SYM_DMAP_SIZE-1) 331 #endif 332 333 /* 334 * Device flags. 335 */ 336 #define SYM_DISC_ENABLED (1) 337 #define SYM_TAGS_ENABLED (1<<1) 338 #define SYM_SCAN_BOOT_DISABLED (1<<2) 339 #define SYM_SCAN_LUNS_DISABLED (1<<3) 340 341 /* 342 * Host adapter miscellaneous flags. 343 */ 344 #define SYM_AVOID_BUS_RESET (1) 345 346 /* 347 * Misc. 348 */ 349 #define SYM_SNOOP_TIMEOUT (10000000) 350 #define BUS_8_BIT 0 351 #define BUS_16_BIT 1 352 353 /* 354 * Gather negotiable parameters value 355 */ 356 struct sym_trans { 357 u8 period; 358 u8 offset; 359 unsigned int width:1; 360 unsigned int iu:1; 361 unsigned int dt:1; 362 unsigned int qas:1; 363 unsigned int check_nego:1; 364 }; 365 366 /* 367 * Global TCB HEADER. 368 * 369 * Due to lack of indirect addressing on earlier NCR chips, 370 * this substructure is copied from the TCB to a global 371 * address after selection. 372 * For SYMBIOS chips that support LOAD/STORE this copy is 373 * not needed and thus not performed. 374 */ 375 struct sym_tcbh { 376 /* 377 * Scripts bus addresses of LUN table accessed from scripts. 378 * LUN #0 is a special case, since multi-lun devices are rare, 379 * and we we want to speed-up the general case and not waste 380 * resources. 381 */ 382 u32 luntbl_sa; /* bus address of this table */ 383 u32 lun0_sa; /* bus address of LCB #0 */ 384 /* 385 * Actual SYNC/WIDE IO registers value for this target. 386 * 'sval', 'wval' and 'uval' are read from SCRIPTS and 387 * so have alignment constraints. 388 */ 389 /*0*/ u_char uval; /* -> SCNTL4 register */ 390 /*1*/ u_char sval; /* -> SXFER io register */ 391 /*2*/ u_char filler1; 392 /*3*/ u_char wval; /* -> SCNTL3 io register */ 393 }; 394 395 /* 396 * Target Control Block 397 */ 398 struct sym_tcb { 399 /* 400 * TCB header. 401 * Assumed at offset 0. 402 */ 403 /*0*/ struct sym_tcbh head; 404 405 /* 406 * LUN table used by the SCRIPTS processor. 407 * An array of bus addresses is used on reselection. 408 */ 409 u32 *luntbl; /* LCBs bus address table */ 410 411 /* 412 * LUN table used by the C code. 413 */ 414 struct sym_lcb *lun0p; /* LCB of LUN #0 (usual case) */ 415 #if SYM_CONF_MAX_LUN > 1 416 struct sym_lcb **lunmp; /* Other LCBs [1..MAX_LUN] */ 417 #endif 418 419 /* 420 * Bitmap that tells about LUNs that succeeded at least 421 * 1 IO and therefore assumed to be a real device. 422 * Avoid useless allocation of the LCB structure. 423 */ 424 u32 lun_map[(SYM_CONF_MAX_LUN+31)/32]; 425 426 /* 427 * Bitmap that tells about LUNs that haven't yet an LCB 428 * allocated (not discovered or LCB allocation failed). 429 */ 430 u32 busy0_map[(SYM_CONF_MAX_LUN+31)/32]; 431 432 #ifdef SYM_HAVE_STCB 433 /* 434 * O/S specific data structure. 435 */ 436 struct sym_stcb s; 437 #endif 438 439 /* Transfer goal */ 440 struct sym_trans tgoal; 441 442 /* 443 * Keep track of the CCB used for the negotiation in order 444 * to ensure that only 1 negotiation is queued at a time. 445 */ 446 struct sym_ccb * nego_cp; /* CCB used for the nego */ 447 448 /* 449 * Set when we want to reset the device. 450 */ 451 u_char to_reset; 452 453 /* 454 * Other user settable limits and options. 455 * These limits are read from the NVRAM if present. 456 */ 457 u_char usrflags; 458 u_short usrtags; 459 struct scsi_target *starget; 460 }; 461 462 /* 463 * Global LCB HEADER. 464 * 465 * Due to lack of indirect addressing on earlier NCR chips, 466 * this substructure is copied from the LCB to a global 467 * address after selection. 468 * For SYMBIOS chips that support LOAD/STORE this copy is 469 * not needed and thus not performed. 470 */ 471 struct sym_lcbh { 472 /* 473 * SCRIPTS address jumped by SCRIPTS on reselection. 474 * For not probed logical units, this address points to 475 * SCRIPTS that deal with bad LU handling (must be at 476 * offset zero of the LCB for that reason). 477 */ 478 /*0*/ u32 resel_sa; 479 480 /* 481 * Task (bus address of a CCB) read from SCRIPTS that points 482 * to the unique ITL nexus allowed to be disconnected. 483 */ 484 u32 itl_task_sa; 485 486 /* 487 * Task table bus address (read from SCRIPTS). 488 */ 489 u32 itlq_tbl_sa; 490 }; 491 492 /* 493 * Logical Unit Control Block 494 */ 495 struct sym_lcb { 496 /* 497 * TCB header. 498 * Assumed at offset 0. 499 */ 500 /*0*/ struct sym_lcbh head; 501 502 /* 503 * Task table read from SCRIPTS that contains pointers to 504 * ITLQ nexuses. The bus address read from SCRIPTS is 505 * inside the header. 506 */ 507 u32 *itlq_tbl; /* Kernel virtual address */ 508 509 /* 510 * Busy CCBs management. 511 */ 512 u_short busy_itlq; /* Number of busy tagged CCBs */ 513 u_short busy_itl; /* Number of busy untagged CCBs */ 514 515 /* 516 * Circular tag allocation buffer. 517 */ 518 u_short ia_tag; /* Tag allocation index */ 519 u_short if_tag; /* Tag release index */ 520 u_char *cb_tags; /* Circular tags buffer */ 521 522 /* 523 * O/S specific data structure. 524 */ 525 #ifdef SYM_HAVE_SLCB 526 struct sym_slcb s; 527 #endif 528 529 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING 530 /* 531 * Optionnaly the driver can handle device queueing, 532 * and requeues internally command to redo. 533 */ 534 SYM_QUEHEAD waiting_ccbq; 535 SYM_QUEHEAD started_ccbq; 536 int num_sgood; 537 u_short started_tags; 538 u_short started_no_tag; 539 u_short started_max; 540 u_short started_limit; 541 #endif 542 543 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING 544 /* 545 * Optionally the driver can try to prevent SCSI 546 * IOs from being reordered too much. 547 */ 548 u_char tags_si; /* Current index to tags sum */ 549 u_short tags_sum[2]; /* Tags sum counters */ 550 u_short tags_since; /* # of tags since last switch */ 551 #endif 552 553 /* 554 * Set when we want to clear all tasks. 555 */ 556 u_char to_clear; 557 558 /* 559 * Capabilities. 560 */ 561 u_char user_flags; 562 u_char curr_flags; 563 }; 564 565 /* 566 * Action from SCRIPTS on a task. 567 * Is part of the CCB, but is also used separately to plug 568 * error handling action to perform from SCRIPTS. 569 */ 570 struct sym_actscr { 571 u32 start; /* Jumped by SCRIPTS after selection */ 572 u32 restart; /* Jumped by SCRIPTS on relection */ 573 }; 574 575 /* 576 * Phase mismatch context. 577 * 578 * It is part of the CCB and is used as parameters for the 579 * DATA pointer. We need two contexts to handle correctly the 580 * SAVED DATA POINTER. 581 */ 582 struct sym_pmc { 583 struct sym_tblmove sg; /* Updated interrupted SG block */ 584 u32 ret; /* SCRIPT return address */ 585 }; 586 587 /* 588 * LUN control block lookup. 589 * We use a direct pointer for LUN #0, and a table of 590 * pointers which is only allocated for devices that support 591 * LUN(s) > 0. 592 */ 593 #if SYM_CONF_MAX_LUN <= 1 594 #define sym_lp(tp, lun) (!lun) ? (tp)->lun0p : NULL 595 #else 596 #define sym_lp(tp, lun) \ 597 (!lun) ? (tp)->lun0p : (tp)->lunmp ? (tp)->lunmp[(lun)] : NULL 598 #endif 599 600 /* 601 * Status are used by the host and the script processor. 602 * 603 * The last four bytes (status[4]) are copied to the 604 * scratchb register (declared as scr0..scr3) just after the 605 * select/reselect, and copied back just after disconnecting. 606 * Inside the script the XX_REG are used. 607 */ 608 609 /* 610 * Last four bytes (script) 611 */ 612 #define HX_REG scr0 613 #define HX_PRT nc_scr0 614 #define HS_REG scr1 615 #define HS_PRT nc_scr1 616 #define SS_REG scr2 617 #define SS_PRT nc_scr2 618 #define HF_REG scr3 619 #define HF_PRT nc_scr3 620 621 /* 622 * Last four bytes (host) 623 */ 624 #define host_xflags phys.head.status[0] 625 #define host_status phys.head.status[1] 626 #define ssss_status phys.head.status[2] 627 #define host_flags phys.head.status[3] 628 629 /* 630 * Host flags 631 */ 632 #define HF_IN_PM0 1u 633 #define HF_IN_PM1 (1u<<1) 634 #define HF_ACT_PM (1u<<2) 635 #define HF_DP_SAVED (1u<<3) 636 #define HF_SENSE (1u<<4) 637 #define HF_EXT_ERR (1u<<5) 638 #define HF_DATA_IN (1u<<6) 639 #ifdef SYM_CONF_IARB_SUPPORT 640 #define HF_HINT_IARB (1u<<7) 641 #endif 642 643 /* 644 * More host flags 645 */ 646 #if SYM_CONF_DMA_ADDRESSING_MODE == 2 647 #define HX_DMAP_DIRTY (1u<<7) 648 #endif 649 650 /* 651 * Global CCB HEADER. 652 * 653 * Due to lack of indirect addressing on earlier NCR chips, 654 * this substructure is copied from the ccb to a global 655 * address after selection (or reselection) and copied back 656 * before disconnect. 657 * For SYMBIOS chips that support LOAD/STORE this copy is 658 * not needed and thus not performed. 659 */ 660 661 struct sym_ccbh { 662 /* 663 * Start and restart SCRIPTS addresses (must be at 0). 664 */ 665 /*0*/ struct sym_actscr go; 666 667 /* 668 * SCRIPTS jump address that deal with data pointers. 669 * 'savep' points to the position in the script responsible 670 * for the actual transfer of data. 671 * It's written on reception of a SAVE_DATA_POINTER message. 672 */ 673 u32 savep; /* Jump address to saved data pointer */ 674 u32 lastp; /* SCRIPTS address at end of data */ 675 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN 676 u32 wlastp; 677 #endif 678 679 /* 680 * Status fields. 681 */ 682 u8 status[4]; 683 }; 684 685 /* 686 * GET/SET the value of the data pointer used by SCRIPTS. 687 * 688 * We must distinguish between the LOAD/STORE-based SCRIPTS 689 * that use directly the header in the CCB, and the NCR-GENERIC 690 * SCRIPTS that use the copy of the header in the HCB. 691 */ 692 #if SYM_CONF_GENERIC_SUPPORT 693 #define sym_set_script_dp(np, cp, dp) \ 694 do { \ 695 if (np->features & FE_LDSTR) \ 696 cp->phys.head.lastp = cpu_to_scr(dp); \ 697 else \ 698 np->ccb_head.lastp = cpu_to_scr(dp); \ 699 } while (0) 700 #define sym_get_script_dp(np, cp) \ 701 scr_to_cpu((np->features & FE_LDSTR) ? \ 702 cp->phys.head.lastp : np->ccb_head.lastp) 703 #else 704 #define sym_set_script_dp(np, cp, dp) \ 705 do { \ 706 cp->phys.head.lastp = cpu_to_scr(dp); \ 707 } while (0) 708 709 #define sym_get_script_dp(np, cp) (cp->phys.head.lastp) 710 #endif 711 712 /* 713 * Data Structure Block 714 * 715 * During execution of a ccb by the script processor, the 716 * DSA (data structure address) register points to this 717 * substructure of the ccb. 718 */ 719 struct sym_dsb { 720 /* 721 * CCB header. 722 * Also assumed at offset 0 of the sym_ccb structure. 723 */ 724 /*0*/ struct sym_ccbh head; 725 726 /* 727 * Phase mismatch contexts. 728 * We need two to handle correctly the SAVED DATA POINTER. 729 * MUST BOTH BE AT OFFSET < 256, due to using 8 bit arithmetic 730 * for address calculation from SCRIPTS. 731 */ 732 struct sym_pmc pm0; 733 struct sym_pmc pm1; 734 735 /* 736 * Table data for Script 737 */ 738 struct sym_tblsel select; 739 struct sym_tblmove smsg; 740 struct sym_tblmove smsg_ext; 741 struct sym_tblmove cmd; 742 struct sym_tblmove sense; 743 struct sym_tblmove wresid; 744 struct sym_tblmove data [SYM_CONF_MAX_SG]; 745 }; 746 747 /* 748 * Our Command Control Block 749 */ 750 struct sym_ccb { 751 /* 752 * This is the data structure which is pointed by the DSA 753 * register when it is executed by the script processor. 754 * It must be the first entry. 755 */ 756 struct sym_dsb phys; 757 758 /* 759 * Pointer to CAM ccb and related stuff. 760 */ 761 struct scsi_cmnd *cmd; /* CAM scsiio ccb */ 762 u8 cdb_buf[16]; /* Copy of CDB */ 763 #define SYM_SNS_BBUF_LEN 32 764 u8 sns_bbuf[SYM_SNS_BBUF_LEN]; /* Bounce buffer for sense data */ 765 int data_len; /* Total data length */ 766 int segments; /* Number of SG segments */ 767 768 u8 order; /* Tag type (if tagged command) */ 769 unsigned char odd_byte_adjustment; /* odd-sized req on wide bus */ 770 771 u_char nego_status; /* Negotiation status */ 772 u_char xerr_status; /* Extended error flags */ 773 u32 extra_bytes; /* Extraneous bytes transferred */ 774 775 /* 776 * Message areas. 777 * We prepare a message to be sent after selection. 778 * We may use a second one if the command is rescheduled 779 * due to CHECK_CONDITION or COMMAND TERMINATED. 780 * Contents are IDENTIFY and SIMPLE_TAG. 781 * While negotiating sync or wide transfer, 782 * a SDTR or WDTR message is appended. 783 */ 784 u_char scsi_smsg [12]; 785 u_char scsi_smsg2[12]; 786 787 /* 788 * Auto request sense related fields. 789 */ 790 u_char sensecmd[6]; /* Request Sense command */ 791 u_char sv_scsi_status; /* Saved SCSI status */ 792 u_char sv_xerr_status; /* Saved extended status */ 793 int sv_resid; /* Saved residual */ 794 795 /* 796 * Other fields. 797 */ 798 u32 ccb_ba; /* BUS address of this CCB */ 799 u_short tag; /* Tag for this transfer */ 800 /* NO_TAG means no tag */ 801 u_char target; 802 u_char lun; 803 struct sym_ccb *link_ccbh; /* Host adapter CCB hash chain */ 804 SYM_QUEHEAD link_ccbq; /* Link to free/busy CCB queue */ 805 u32 startp; /* Initial data pointer */ 806 u32 goalp; /* Expected last data pointer */ 807 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN 808 u32 wgoalp; 809 #endif 810 int ext_sg; /* Extreme data pointer, used */ 811 int ext_ofs; /* to calculate the residual. */ 812 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING 813 SYM_QUEHEAD link2_ccbq; /* Link for device queueing */ 814 u_char started; /* CCB queued to the squeue */ 815 #endif 816 u_char to_abort; /* Want this IO to be aborted */ 817 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING 818 u_char tags_si; /* Lun tags sum index (0,1) */ 819 #endif 820 }; 821 822 #define CCB_BA(cp,lbl) cpu_to_scr(cp->ccb_ba + offsetof(struct sym_ccb, lbl)) 823 824 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN 825 #define sym_goalp(cp) ((cp->host_flags & HF_DATA_IN) ? cp->goalp : cp->wgoalp) 826 #else 827 #define sym_goalp(cp) (cp->goalp) 828 #endif 829 830 typedef struct device *m_pool_ident_t; 831 832 /* 833 * Host Control Block 834 */ 835 struct sym_hcb { 836 /* 837 * Global headers. 838 * Due to poorness of addressing capabilities, earlier 839 * chips (810, 815, 825) copy part of the data structures 840 * (CCB, TCB and LCB) in fixed areas. 841 */ 842 #if SYM_CONF_GENERIC_SUPPORT 843 struct sym_ccbh ccb_head; 844 struct sym_tcbh tcb_head; 845 struct sym_lcbh lcb_head; 846 #endif 847 /* 848 * Idle task and invalid task actions and 849 * their bus addresses. 850 */ 851 struct sym_actscr idletask, notask, bad_itl, bad_itlq; 852 u32 idletask_ba, notask_ba, bad_itl_ba, bad_itlq_ba; 853 854 /* 855 * Dummy lun table to protect us against target 856 * returning bad lun number on reselection. 857 */ 858 u32 *badluntbl; /* Table physical address */ 859 u32 badlun_sa; /* SCRIPT handler BUS address */ 860 861 /* 862 * Bus address of this host control block. 863 */ 864 u32 hcb_ba; 865 866 /* 867 * Bit 32-63 of the on-chip RAM bus address in LE format. 868 * The START_RAM64 script loads the MMRS and MMWS from this 869 * field. 870 */ 871 u32 scr_ram_seg; 872 873 /* 874 * Initial value of some IO register bits. 875 * These values are assumed to have been set by BIOS, and may 876 * be used to probe adapter implementation differences. 877 */ 878 u_char sv_scntl0, sv_scntl3, sv_dmode, sv_dcntl, sv_ctest3, sv_ctest4, 879 sv_ctest5, sv_gpcntl, sv_stest2, sv_stest4, sv_scntl4, 880 sv_stest1; 881 882 /* 883 * Actual initial value of IO register bits used by the 884 * driver. They are loaded at initialisation according to 885 * features that are to be enabled/disabled. 886 */ 887 u_char rv_scntl0, rv_scntl3, rv_dmode, rv_dcntl, rv_ctest3, rv_ctest4, 888 rv_ctest5, rv_stest2, rv_ccntl0, rv_ccntl1, rv_scntl4; 889 890 /* 891 * Target data. 892 */ 893 struct sym_tcb target[SYM_CONF_MAX_TARGET]; 894 895 /* 896 * Target control block bus address array used by the SCRIPT 897 * on reselection. 898 */ 899 u32 *targtbl; 900 u32 targtbl_ba; 901 902 /* 903 * DMA pool handle for this HBA. 904 */ 905 m_pool_ident_t bus_dmat; 906 907 /* 908 * O/S specific data structure 909 */ 910 struct sym_shcb s; 911 912 /* 913 * Physical bus addresses of the chip. 914 */ 915 u32 mmio_ba; /* MMIO 32 bit BUS address */ 916 int mmio_ws; /* MMIO Window size */ 917 918 u32 ram_ba; /* RAM 32 bit BUS address */ 919 int ram_ws; /* RAM window size */ 920 921 /* 922 * SCRIPTS virtual and physical bus addresses. 923 * 'script' is loaded in the on-chip RAM if present. 924 * 'scripth' stays in main memory for all chips except the 925 * 53C895A, 53C896 and 53C1010 that provide 8K on-chip RAM. 926 */ 927 u_char *scripta0; /* Copy of scripts A, B, Z */ 928 u_char *scriptb0; 929 u_char *scriptz0; 930 u32 scripta_ba; /* Actual scripts A, B, Z */ 931 u32 scriptb_ba; /* 32 bit bus addresses. */ 932 u32 scriptz_ba; 933 u_short scripta_sz; /* Actual size of script A, B, Z*/ 934 u_short scriptb_sz; 935 u_short scriptz_sz; 936 937 /* 938 * Bus addresses, setup and patch methods for 939 * the selected firmware. 940 */ 941 struct sym_fwa_ba fwa_bas; /* Useful SCRIPTA bus addresses */ 942 struct sym_fwb_ba fwb_bas; /* Useful SCRIPTB bus addresses */ 943 struct sym_fwz_ba fwz_bas; /* Useful SCRIPTZ bus addresses */ 944 void (*fw_setup)(struct sym_hcb *np, struct sym_fw *fw); 945 void (*fw_patch)(struct sym_hcb *np); 946 char *fw_name; 947 948 /* 949 * General controller parameters and configuration. 950 */ 951 u_short device_id; /* PCI device id */ 952 u_char revision_id; /* PCI device revision id */ 953 u_int features; /* Chip features map */ 954 u_char myaddr; /* SCSI id of the adapter */ 955 u_char maxburst; /* log base 2 of dwords burst */ 956 u_char maxwide; /* Maximum transfer width */ 957 u_char minsync; /* Min sync period factor (ST) */ 958 u_char maxsync; /* Max sync period factor (ST) */ 959 u_char maxoffs; /* Max scsi offset (ST) */ 960 u_char minsync_dt; /* Min sync period factor (DT) */ 961 u_char maxsync_dt; /* Max sync period factor (DT) */ 962 u_char maxoffs_dt; /* Max scsi offset (DT) */ 963 u_char multiplier; /* Clock multiplier (1,2,4) */ 964 u_char clock_divn; /* Number of clock divisors */ 965 u32 clock_khz; /* SCSI clock frequency in KHz */ 966 u32 pciclk_khz; /* Estimated PCI clock in KHz */ 967 /* 968 * Start queue management. 969 * It is filled up by the host processor and accessed by the 970 * SCRIPTS processor in order to start SCSI commands. 971 */ 972 volatile /* Prevent code optimizations */ 973 u32 *squeue; /* Start queue virtual address */ 974 u32 squeue_ba; /* Start queue BUS address */ 975 u_short squeueput; /* Next free slot of the queue */ 976 u_short actccbs; /* Number of allocated CCBs */ 977 978 /* 979 * Command completion queue. 980 * It is the same size as the start queue to avoid overflow. 981 */ 982 u_short dqueueget; /* Next position to scan */ 983 volatile /* Prevent code optimizations */ 984 u32 *dqueue; /* Completion (done) queue */ 985 u32 dqueue_ba; /* Done queue BUS address */ 986 987 /* 988 * Miscellaneous buffers accessed by the scripts-processor. 989 * They shall be DWORD aligned, because they may be read or 990 * written with a script command. 991 */ 992 u_char msgout[8]; /* Buffer for MESSAGE OUT */ 993 u_char msgin [8]; /* Buffer for MESSAGE IN */ 994 u32 lastmsg; /* Last SCSI message sent */ 995 u32 scratch; /* Scratch for SCSI receive */ 996 /* Also used for cache test */ 997 /* 998 * Miscellaneous configuration and status parameters. 999 */ 1000 u_char usrflags; /* Miscellaneous user flags */ 1001 u_char scsi_mode; /* Current SCSI BUS mode */ 1002 u_char verbose; /* Verbosity for this controller*/ 1003 1004 /* 1005 * CCB lists and queue. 1006 */ 1007 struct sym_ccb **ccbh; /* CCBs hashed by DSA value */ 1008 /* CCB_HASH_SIZE lists of CCBs */ 1009 SYM_QUEHEAD free_ccbq; /* Queue of available CCBs */ 1010 SYM_QUEHEAD busy_ccbq; /* Queue of busy CCBs */ 1011 1012 /* 1013 * During error handling and/or recovery, 1014 * active CCBs that are to be completed with 1015 * error or requeued are moved from the busy_ccbq 1016 * to the comp_ccbq prior to completion. 1017 */ 1018 SYM_QUEHEAD comp_ccbq; 1019 1020 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING 1021 SYM_QUEHEAD dummy_ccbq; 1022 #endif 1023 1024 /* 1025 * IMMEDIATE ARBITRATION (IARB) control. 1026 * 1027 * We keep track in 'last_cp' of the last CCB that has been 1028 * queued to the SCRIPTS processor and clear 'last_cp' when 1029 * this CCB completes. If last_cp is not zero at the moment 1030 * we queue a new CCB, we set a flag in 'last_cp' that is 1031 * used by the SCRIPTS as a hint for setting IARB. 1032 * We donnot set more than 'iarb_max' consecutive hints for 1033 * IARB in order to leave devices a chance to reselect. 1034 * By the way, any non zero value of 'iarb_max' is unfair. :) 1035 */ 1036 #ifdef SYM_CONF_IARB_SUPPORT 1037 u_short iarb_max; /* Max. # consecutive IARB hints*/ 1038 u_short iarb_count; /* Actual # of these hints */ 1039 struct sym_ccb * last_cp; 1040 #endif 1041 1042 /* 1043 * Command abort handling. 1044 * We need to synchronize tightly with the SCRIPTS 1045 * processor in order to handle things correctly. 1046 */ 1047 u_char abrt_msg[4]; /* Message to send buffer */ 1048 struct sym_tblmove abrt_tbl; /* Table for the MOV of it */ 1049 struct sym_tblsel abrt_sel; /* Sync params for selection */ 1050 u_char istat_sem; /* Tells the chip to stop (SEM) */ 1051 1052 /* 1053 * 64 bit DMA handling. 1054 */ 1055 #if SYM_CONF_DMA_ADDRESSING_MODE != 0 1056 u_char use_dac; /* Use PCI DAC cycles */ 1057 #if SYM_CONF_DMA_ADDRESSING_MODE == 2 1058 u_char dmap_dirty; /* Dma segments registers dirty */ 1059 u32 dmap_bah[SYM_DMAP_SIZE];/* Segment registers map */ 1060 #endif 1061 #endif 1062 }; 1063 1064 #define HCB_BA(np, lbl) (np->hcb_ba + offsetof(struct sym_hcb, lbl)) 1065 1066 1067 /* 1068 * FIRMWARES (sym_fw.c) 1069 */ 1070 struct sym_fw * sym_find_firmware(struct sym_chip *chip); 1071 void sym_fw_bind_script(struct sym_hcb *np, u32 *start, int len); 1072 1073 /* 1074 * Driver methods called from O/S specific code. 1075 */ 1076 char *sym_driver_name(void); 1077 void sym_print_xerr(struct scsi_cmnd *cmd, int x_status); 1078 int sym_reset_scsi_bus(struct sym_hcb *np, int enab_int); 1079 struct sym_chip *sym_lookup_chip_table(u_short device_id, u_char revision); 1080 void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp); 1081 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING 1082 void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn); 1083 #endif 1084 void sym_start_up(struct sym_hcb *np, int reason); 1085 void sym_interrupt(struct sym_hcb *np); 1086 int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task); 1087 struct sym_ccb *sym_get_ccb(struct sym_hcb *np, struct scsi_cmnd *cmd, u_char tag_order); 1088 void sym_free_ccb(struct sym_hcb *np, struct sym_ccb *cp); 1089 struct sym_lcb *sym_alloc_lcb(struct sym_hcb *np, u_char tn, u_char ln); 1090 int sym_queue_scsiio(struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp); 1091 int sym_abort_scsiio(struct sym_hcb *np, struct scsi_cmnd *ccb, int timed_out); 1092 int sym_reset_scsi_target(struct sym_hcb *np, int target); 1093 void sym_hcb_free(struct sym_hcb *np); 1094 int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram *nvram); 1095 1096 /* 1097 * Build a scatter/gather entry. 1098 * 1099 * For 64 bit systems, we use the 8 upper bits of the size field 1100 * to provide bus address bits 32-39 to the SCRIPTS processor. 1101 * This allows the 895A, 896, 1010 to address up to 1 TB of memory. 1102 */ 1103 1104 #if SYM_CONF_DMA_ADDRESSING_MODE == 0 1105 #define sym_build_sge(np, data, badd, len) \ 1106 do { \ 1107 (data)->addr = cpu_to_scr(badd); \ 1108 (data)->size = cpu_to_scr(len); \ 1109 } while (0) 1110 #elif SYM_CONF_DMA_ADDRESSING_MODE == 1 1111 #define sym_build_sge(np, data, badd, len) \ 1112 do { \ 1113 (data)->addr = cpu_to_scr(badd); \ 1114 (data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len); \ 1115 } while (0) 1116 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2 1117 int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s); 1118 static __inline void 1119 sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len) 1120 { 1121 u32 h = (badd>>32); 1122 int s = (h&SYM_DMAP_MASK); 1123 1124 if (h != np->dmap_bah[s]) 1125 goto bad; 1126 good: 1127 (data)->addr = cpu_to_scr(badd); 1128 (data)->size = cpu_to_scr((s<<24) + len); 1129 return; 1130 bad: 1131 s = sym_lookup_dmap(np, h, s); 1132 goto good; 1133 } 1134 #else 1135 #error "Unsupported DMA addressing mode" 1136 #endif 1137 1138 /* 1139 * Set up data pointers used by SCRIPTS. 1140 * Called from O/S specific code. 1141 */ 1142 static inline void sym_setup_data_pointers(struct sym_hcb *np, 1143 struct sym_ccb *cp, int dir) 1144 { 1145 u32 lastp, goalp; 1146 1147 /* 1148 * No segments means no data. 1149 */ 1150 if (!cp->segments) 1151 dir = DMA_NONE; 1152 1153 /* 1154 * Set the data pointer. 1155 */ 1156 switch(dir) { 1157 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN 1158 case DMA_BIDIRECTIONAL: 1159 #endif 1160 case DMA_TO_DEVICE: 1161 goalp = SCRIPTA_BA(np, data_out2) + 8; 1162 lastp = goalp - 8 - (cp->segments * (2*4)); 1163 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN 1164 cp->wgoalp = cpu_to_scr(goalp); 1165 if (dir != DMA_BIDIRECTIONAL) 1166 break; 1167 cp->phys.head.wlastp = cpu_to_scr(lastp); 1168 /* fall through */ 1169 #else 1170 break; 1171 #endif 1172 case DMA_FROM_DEVICE: 1173 cp->host_flags |= HF_DATA_IN; 1174 goalp = SCRIPTA_BA(np, data_in2) + 8; 1175 lastp = goalp - 8 - (cp->segments * (2*4)); 1176 break; 1177 case DMA_NONE: 1178 default: 1179 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN 1180 cp->host_flags |= HF_DATA_IN; 1181 #endif 1182 lastp = goalp = SCRIPTB_BA(np, no_data); 1183 break; 1184 } 1185 1186 /* 1187 * Set all pointers values needed by SCRIPTS. 1188 */ 1189 cp->phys.head.lastp = cpu_to_scr(lastp); 1190 cp->phys.head.savep = cpu_to_scr(lastp); 1191 cp->startp = cp->phys.head.savep; 1192 cp->goalp = cpu_to_scr(goalp); 1193 1194 #ifdef SYM_OPT_HANDLE_DIR_UNKNOWN 1195 /* 1196 * If direction is unknown, start at data_io. 1197 */ 1198 if (dir == DMA_BIDIRECTIONAL) 1199 cp->phys.head.savep = cpu_to_scr(SCRIPTB_BA(np, data_io)); 1200 #endif 1201 } 1202 1203 /* 1204 * MEMORY ALLOCATOR. 1205 */ 1206 1207 #define sym_get_mem_cluster() \ 1208 (void *) __get_free_pages(GFP_ATOMIC, SYM_MEM_PAGE_ORDER) 1209 #define sym_free_mem_cluster(p) \ 1210 free_pages((unsigned long)p, SYM_MEM_PAGE_ORDER) 1211 1212 /* 1213 * Link between free memory chunks of a given size. 1214 */ 1215 typedef struct sym_m_link { 1216 struct sym_m_link *next; 1217 } *m_link_p; 1218 1219 /* 1220 * Virtual to bus physical translation for a given cluster. 1221 * Such a structure is only useful with DMA abstraction. 1222 */ 1223 typedef struct sym_m_vtob { /* Virtual to Bus address translation */ 1224 struct sym_m_vtob *next; 1225 void *vaddr; /* Virtual address */ 1226 dma_addr_t baddr; /* Bus physical address */ 1227 } *m_vtob_p; 1228 1229 /* Hash this stuff a bit to speed up translations */ 1230 #define VTOB_HASH_SHIFT 5 1231 #define VTOB_HASH_SIZE (1UL << VTOB_HASH_SHIFT) 1232 #define VTOB_HASH_MASK (VTOB_HASH_SIZE-1) 1233 #define VTOB_HASH_CODE(m) \ 1234 ((((unsigned long)(m)) >> SYM_MEM_CLUSTER_SHIFT) & VTOB_HASH_MASK) 1235 1236 /* 1237 * Memory pool of a given kind. 1238 * Ideally, we want to use: 1239 * 1) 1 pool for memory we donnot need to involve in DMA. 1240 * 2) The same pool for controllers that require same DMA 1241 * constraints and features. 1242 * The OS specific m_pool_id_t thing and the sym_m_pool_match() 1243 * method are expected to tell the driver about. 1244 */ 1245 typedef struct sym_m_pool { 1246 m_pool_ident_t dev_dmat; /* Identifies the pool (see above) */ 1247 void * (*get_mem_cluster)(struct sym_m_pool *); 1248 #ifdef SYM_MEM_FREE_UNUSED 1249 void (*free_mem_cluster)(struct sym_m_pool *, void *); 1250 #endif 1251 #define M_GET_MEM_CLUSTER() mp->get_mem_cluster(mp) 1252 #define M_FREE_MEM_CLUSTER(p) mp->free_mem_cluster(mp, p) 1253 int nump; 1254 m_vtob_p vtob[VTOB_HASH_SIZE]; 1255 struct sym_m_pool *next; 1256 struct sym_m_link h[SYM_MEM_CLUSTER_SHIFT - SYM_MEM_SHIFT + 1]; 1257 } *m_pool_p; 1258 1259 /* 1260 * Alloc, free and translate addresses to bus physical 1261 * for DMAable memory. 1262 */ 1263 void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name); 1264 void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name); 1265 dma_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m); 1266 1267 /* 1268 * Verbs used by the driver code for DMAable memory handling. 1269 * The _uvptv_ macro avoids a nasty warning about pointer to volatile 1270 * being discarded. 1271 */ 1272 #define _uvptv_(p) ((void *)((u_long)(p))) 1273 1274 #define _sym_calloc_dma(np, l, n) __sym_calloc_dma(np->bus_dmat, l, n) 1275 #define _sym_mfree_dma(np, p, l, n) \ 1276 __sym_mfree_dma(np->bus_dmat, _uvptv_(p), l, n) 1277 #define sym_calloc_dma(l, n) _sym_calloc_dma(np, l, n) 1278 #define sym_mfree_dma(p, l, n) _sym_mfree_dma(np, p, l, n) 1279 #define vtobus(p) __vtobus(np->bus_dmat, _uvptv_(p)) 1280 1281 /* 1282 * We have to provide the driver memory allocator with methods for 1283 * it to maintain virtual to bus physical address translations. 1284 */ 1285 1286 #define sym_m_pool_match(mp_id1, mp_id2) (mp_id1 == mp_id2) 1287 1288 static __inline void *sym_m_get_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp) 1289 { 1290 void *vaddr = NULL; 1291 dma_addr_t baddr = 0; 1292 1293 vaddr = dma_alloc_coherent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE, &baddr, 1294 GFP_ATOMIC); 1295 if (vaddr) { 1296 vbp->vaddr = vaddr; 1297 vbp->baddr = baddr; 1298 } 1299 return vaddr; 1300 } 1301 1302 static __inline void sym_m_free_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp) 1303 { 1304 dma_free_coherent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE, vbp->vaddr, 1305 vbp->baddr); 1306 } 1307 1308 #endif /* SYM_HIPD_H */ 1309