1 2 3#include <linux/module.h> 4#include <linux/reboot.h> 5#include <linux/spinlock.h> 6#include <linux/interrupt.h> 7#include <linux/moduleparam.h> 8#include <linux/errno.h> 9#include <linux/types.h> 10#include <linux/delay.h> 11#include <linux/pci.h> 12#include <linux/time.h> 13#include <linux/mutex.h> 14#include <asm/io.h> 15#include <asm/irq.h> 16#include <asm/uaccess.h> 17#include <scsi/scsi.h> 18#include <scsi/scsi_host.h> 19#include <scsi/scsi_tcq.h> 20#include <scsi/scsi_cmnd.h> 21#include "3w-xxxx.h" 22 23/* Globals */ 24#define TW_DRIVER_VERSION "1.26.02.002" 25static TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT]; 26static int tw_device_extension_count = 0; 27static int twe_major = -1; 28 29/* Module parameters */ 30MODULE_AUTHOR("AMCC"); 31MODULE_DESCRIPTION("3ware Storage Controller Linux Driver"); 32MODULE_LICENSE("GPL"); 33MODULE_VERSION(TW_DRIVER_VERSION); 34 35/* Function prototypes */ 36static int tw_reset_device_extension(TW_Device_Extension *tw_dev); 37 38/* Functions */ 39 40/* This function will check the status register for unexpected bits */ 41static int tw_check_bits(u32 status_reg_value) 42{ 43 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) { 44 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value); 45 return 1; 46 } 47 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) { 48 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value); 49 return 1; 50 } 51 52 return 0; 53} /* End tw_check_bits() */ 54 55/* This function will print readable messages from status register errors */ 56static int tw_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value, int print_host) 57{ 58 char host[16]; 59 60 dprintk(KERN_WARNING "3w-xxxx: tw_decode_bits()\n"); 61 62 if (print_host) 63 sprintf(host, " scsi%d:", tw_dev->host->host_no); 64 else 65 host[0] = '\0'; 66 67 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) { 68 printk(KERN_WARNING "3w-xxxx:%s PCI Parity Error: clearing.\n", host); 69 outl(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 70 } 71 72 if (status_reg_value & TW_STATUS_PCI_ABORT) { 73 printk(KERN_WARNING "3w-xxxx:%s PCI Abort: clearing.\n", host); 74 outl(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev)); 75 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT); 76 } 77 78 if (status_reg_value & TW_STATUS_QUEUE_ERROR) { 79 printk(KERN_WARNING "3w-xxxx:%s Controller Queue Error: clearing.\n", host); 80 outl(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 81 } 82 83 if (status_reg_value & TW_STATUS_SBUF_WRITE_ERROR) { 84 printk(KERN_WARNING "3w-xxxx:%s SBUF Write Error: clearing.\n", host); 85 outl(TW_CONTROL_CLEAR_SBUF_WRITE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 86 } 87 88 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) { 89 if (tw_dev->reset_print == 0) { 90 printk(KERN_WARNING "3w-xxxx:%s Microcontroller Error: clearing.\n", host); 91 tw_dev->reset_print = 1; 92 } 93 return 1; 94 } 95 96 return 0; 97} /* End tw_decode_bits() */ 98 99/* This function will poll the status register for a flag */ 100static int tw_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds) 101{ 102 u32 status_reg_value; 103 unsigned long before; 104 int retval = 1; 105 106 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 107 before = jiffies; 108 109 if (tw_check_bits(status_reg_value)) 110 tw_decode_bits(tw_dev, status_reg_value, 0); 111 112 while ((status_reg_value & flag) != flag) { 113 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 114 115 if (tw_check_bits(status_reg_value)) 116 tw_decode_bits(tw_dev, status_reg_value, 0); 117 118 if (time_after(jiffies, before + HZ * seconds)) 119 goto out; 120 121 msleep(50); 122 } 123 retval = 0; 124out: 125 return retval; 126} /* End tw_poll_status() */ 127 128/* This function will poll the status register for disappearance of a flag */ 129static int tw_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds) 130{ 131 u32 status_reg_value; 132 unsigned long before; 133 int retval = 1; 134 135 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 136 before = jiffies; 137 138 if (tw_check_bits(status_reg_value)) 139 tw_decode_bits(tw_dev, status_reg_value, 0); 140 141 while ((status_reg_value & flag) != 0) { 142 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 143 144 if (tw_check_bits(status_reg_value)) 145 tw_decode_bits(tw_dev, status_reg_value, 0); 146 147 if (time_after(jiffies, before + HZ * seconds)) 148 goto out; 149 150 msleep(50); 151 } 152 retval = 0; 153out: 154 return retval; 155} /* End tw_poll_status_gone() */ 156 157/* This function will attempt to post a command packet to the board */ 158static int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id) 159{ 160 u32 status_reg_value; 161 unsigned long command_que_value; 162 163 dprintk(KERN_NOTICE "3w-xxxx: tw_post_command_packet()\n"); 164 command_que_value = tw_dev->command_packet_physical_address[request_id]; 165 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 166 167 if (tw_check_bits(status_reg_value)) { 168 dprintk(KERN_WARNING "3w-xxxx: tw_post_command_packet(): Unexpected bits.\n"); 169 tw_decode_bits(tw_dev, status_reg_value, 1); 170 } 171 172 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) { 173 /* We successfully posted the command packet */ 174 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 175 tw_dev->state[request_id] = TW_S_POSTED; 176 tw_dev->posted_request_count++; 177 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) { 178 tw_dev->max_posted_request_count = tw_dev->posted_request_count; 179 } 180 } else { 181 /* Couldn't post the command packet, so we do it in the isr */ 182 if (tw_dev->state[request_id] != TW_S_PENDING) { 183 tw_dev->state[request_id] = TW_S_PENDING; 184 tw_dev->pending_request_count++; 185 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) { 186 tw_dev->max_pending_request_count = tw_dev->pending_request_count; 187 } 188 tw_dev->pending_queue[tw_dev->pending_tail] = request_id; 189 if (tw_dev->pending_tail == TW_Q_LENGTH-1) { 190 tw_dev->pending_tail = TW_Q_START; 191 } else { 192 tw_dev->pending_tail = tw_dev->pending_tail + 1; 193 } 194 } 195 TW_UNMASK_COMMAND_INTERRUPT(tw_dev); 196 return 1; 197 } 198 return 0; 199} /* End tw_post_command_packet() */ 200 201/* This function will return valid sense buffer information for failed cmds */ 202static int tw_decode_sense(TW_Device_Extension *tw_dev, int request_id, int fill_sense) 203{ 204 int i; 205 TW_Command *command; 206 207 dprintk(KERN_WARNING "3w-xxxx: tw_decode_sense()\n"); 208 command = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 209 210 printk(KERN_WARNING "3w-xxxx: scsi%d: Command failed: status = 0x%x, flags = 0x%x, unit #%d.\n", tw_dev->host->host_no, command->status, command->flags, TW_UNIT_OUT(command->unit__hostid)); 211 212 /* Attempt to return intelligent sense information */ 213 if (fill_sense) { 214 if ((command->status == 0xc7) || (command->status == 0xcb)) { 215 for (i = 0; i < ARRAY_SIZE(tw_sense_table); i++) { 216 if (command->flags == tw_sense_table[i][0]) { 217 218 /* Valid bit and 'current errors' */ 219 tw_dev->srb[request_id]->sense_buffer[0] = (0x1 << 7 | 0x70); 220 221 /* Sense key */ 222 tw_dev->srb[request_id]->sense_buffer[2] = tw_sense_table[i][1]; 223 224 /* Additional sense length */ 225 tw_dev->srb[request_id]->sense_buffer[7] = 0xa; /* 10 bytes */ 226 227 /* Additional sense code */ 228 tw_dev->srb[request_id]->sense_buffer[12] = tw_sense_table[i][2]; 229 230 /* Additional sense code qualifier */ 231 tw_dev->srb[request_id]->sense_buffer[13] = tw_sense_table[i][3]; 232 233 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 234 return TW_ISR_DONT_RESULT; /* Special case for isr to not over-write result */ 235 } 236 } 237 } 238 239 /* If no table match, error so we get a reset */ 240 return 1; 241 } 242 243 return 0; 244} /* End tw_decode_sense() */ 245 246/* This function will report controller error status */ 247static int tw_check_errors(TW_Device_Extension *tw_dev) 248{ 249 u32 status_reg_value; 250 251 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 252 253 if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) { 254 tw_decode_bits(tw_dev, status_reg_value, 0); 255 return 1; 256 } 257 258 return 0; 259} /* End tw_check_errors() */ 260 261/* This function will empty the response que */ 262static void tw_empty_response_que(TW_Device_Extension *tw_dev) 263{ 264 u32 status_reg_value, response_que_value; 265 266 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 267 268 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 269 response_que_value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 270 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 271 } 272} /* End tw_empty_response_que() */ 273 274/* This function will free a request_id */ 275static void tw_state_request_finish(TW_Device_Extension *tw_dev, int request_id) 276{ 277 tw_dev->free_queue[tw_dev->free_tail] = request_id; 278 tw_dev->state[request_id] = TW_S_FINISHED; 279 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH; 280} /* End tw_state_request_finish() */ 281 282/* This function will assign an available request_id */ 283static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id) 284{ 285 *request_id = tw_dev->free_queue[tw_dev->free_head]; 286 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH; 287 tw_dev->state[*request_id] = TW_S_STARTED; 288} /* End tw_state_request_start() */ 289 290/* Show some statistics about the card */ 291static ssize_t tw_show_stats(struct class_device *class_dev, char *buf) 292{ 293 struct Scsi_Host *host = class_to_shost(class_dev); 294 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 295 unsigned long flags = 0; 296 ssize_t len; 297 298 spin_lock_irqsave(tw_dev->host->host_lock, flags); 299 len = snprintf(buf, PAGE_SIZE, "3w-xxxx Driver version: %s\n" 300 "Current commands posted: %4d\n" 301 "Max commands posted: %4d\n" 302 "Current pending commands: %4d\n" 303 "Max pending commands: %4d\n" 304 "Last sgl length: %4d\n" 305 "Max sgl length: %4d\n" 306 "Last sector count: %4d\n" 307 "Max sector count: %4d\n" 308 "SCSI Host Resets: %4d\n" 309 "AEN's: %4d\n", 310 TW_DRIVER_VERSION, 311 tw_dev->posted_request_count, 312 tw_dev->max_posted_request_count, 313 tw_dev->pending_request_count, 314 tw_dev->max_pending_request_count, 315 tw_dev->sgl_entries, 316 tw_dev->max_sgl_entries, 317 tw_dev->sector_count, 318 tw_dev->max_sector_count, 319 tw_dev->num_resets, 320 tw_dev->aen_count); 321 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 322 return len; 323} /* End tw_show_stats() */ 324 325/* This function will set a devices queue depth */ 326static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth) 327{ 328 if (queue_depth > TW_Q_LENGTH-2) 329 queue_depth = TW_Q_LENGTH-2; 330 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth); 331 return queue_depth; 332} /* End tw_change_queue_depth() */ 333 334/* Create sysfs 'stats' entry */ 335static struct class_device_attribute tw_host_stats_attr = { 336 .attr = { 337 .name = "stats", 338 .mode = S_IRUGO, 339 }, 340 .show = tw_show_stats 341}; 342 343/* Host attributes initializer */ 344static struct class_device_attribute *tw_host_attrs[] = { 345 &tw_host_stats_attr, 346 NULL, 347}; 348 349/* This function will read the aen queue from the isr */ 350static int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id) 351{ 352 TW_Command *command_packet; 353 TW_Param *param; 354 unsigned long command_que_value; 355 u32 status_reg_value; 356 unsigned long param_value = 0; 357 358 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n"); 359 360 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 361 if (tw_check_bits(status_reg_value)) { 362 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n"); 363 tw_decode_bits(tw_dev, status_reg_value, 1); 364 return 1; 365 } 366 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 367 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n"); 368 return 1; 369 } 370 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 371 memset(command_packet, 0, sizeof(TW_Sector)); 372 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 373 command_packet->size = 4; 374 command_packet->request_id = request_id; 375 command_packet->status = 0; 376 command_packet->flags = 0; 377 command_packet->byte6.parameter_count = 1; 378 command_que_value = tw_dev->command_packet_physical_address[request_id]; 379 if (command_que_value == 0) { 380 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n"); 381 return 1; 382 } 383 /* Now setup the param */ 384 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 385 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n"); 386 return 1; 387 } 388 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 389 memset(param, 0, sizeof(TW_Sector)); 390 param->table_id = 0x401; /* AEN table */ 391 param->parameter_id = 2; /* Unit code */ 392 param->parameter_size_bytes = 2; 393 param_value = tw_dev->alignment_physical_address[request_id]; 394 if (param_value == 0) { 395 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n"); 396 return 1; 397 } 398 command_packet->byte8.param.sgl[0].address = param_value; 399 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 400 401 /* Now post the command packet */ 402 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) { 403 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n"); 404 tw_dev->srb[request_id] = NULL; /* Flag internal command */ 405 tw_dev->state[request_id] = TW_S_POSTED; 406 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 407 } else { 408 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n"); 409 return 1; 410 } 411 412 return 0; 413} /* End tw_aen_read_queue() */ 414 415/* This function will complete an aen request from the isr */ 416static int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id) 417{ 418 TW_Param *param; 419 unsigned short aen; 420 int error = 0, table_max = 0; 421 422 dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n"); 423 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 424 printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n"); 425 return 1; 426 } 427 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 428 aen = *(unsigned short *)(param->data); 429 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen); 430 431 /* Print some useful info when certain aen codes come out */ 432 if (aen == 0x0ff) { 433 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no); 434 } else { 435 table_max = ARRAY_SIZE(tw_aen_string); 436 if ((aen & 0x0ff) < table_max) { 437 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') { 438 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8); 439 } else { 440 if (aen != 0x0) 441 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]); 442 } 443 } else { 444 printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen); 445 } 446 } 447 if (aen != TW_AEN_QUEUE_EMPTY) { 448 tw_dev->aen_count++; 449 450 /* Now queue the code */ 451 tw_dev->aen_queue[tw_dev->aen_tail] = aen; 452 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) { 453 tw_dev->aen_tail = TW_Q_START; 454 } else { 455 tw_dev->aen_tail = tw_dev->aen_tail + 1; 456 } 457 if (tw_dev->aen_head == tw_dev->aen_tail) { 458 if (tw_dev->aen_head == TW_Q_LENGTH - 1) { 459 tw_dev->aen_head = TW_Q_START; 460 } else { 461 tw_dev->aen_head = tw_dev->aen_head + 1; 462 } 463 } 464 465 error = tw_aen_read_queue(tw_dev, request_id); 466 if (error) { 467 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no); 468 tw_dev->state[request_id] = TW_S_COMPLETED; 469 tw_state_request_finish(tw_dev, request_id); 470 } 471 } else { 472 tw_dev->state[request_id] = TW_S_COMPLETED; 473 tw_state_request_finish(tw_dev, request_id); 474 } 475 476 return 0; 477} /* End tw_aen_complete() */ 478 479/* This function will drain the aen queue after a soft reset */ 480static int tw_aen_drain_queue(TW_Device_Extension *tw_dev) 481{ 482 TW_Command *command_packet; 483 TW_Param *param; 484 int request_id = 0; 485 unsigned long command_que_value; 486 unsigned long param_value; 487 TW_Response_Queue response_queue; 488 unsigned short aen; 489 unsigned short aen_code; 490 int finished = 0; 491 int first_reset = 0; 492 int queue = 0; 493 int found = 0, table_max = 0; 494 495 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n"); 496 497 if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) { 498 dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count); 499 return 1; 500 } 501 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 502 503 /* Empty response queue */ 504 tw_empty_response_que(tw_dev); 505 506 /* Initialize command packet */ 507 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 508 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n"); 509 return 1; 510 } 511 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 512 memset(command_packet, 0, sizeof(TW_Sector)); 513 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 514 command_packet->size = 4; 515 command_packet->request_id = request_id; 516 command_packet->status = 0; 517 command_packet->flags = 0; 518 command_packet->byte6.parameter_count = 1; 519 command_que_value = tw_dev->command_packet_physical_address[request_id]; 520 if (command_que_value == 0) { 521 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n"); 522 return 1; 523 } 524 525 /* Now setup the param */ 526 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 527 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n"); 528 return 1; 529 } 530 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 531 memset(param, 0, sizeof(TW_Sector)); 532 param->table_id = 0x401; /* AEN table */ 533 param->parameter_id = 2; /* Unit code */ 534 param->parameter_size_bytes = 2; 535 param_value = tw_dev->alignment_physical_address[request_id]; 536 if (param_value == 0) { 537 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n"); 538 return 1; 539 } 540 command_packet->byte8.param.sgl[0].address = param_value; 541 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 542 543 /* Now drain the controller's aen queue */ 544 do { 545 /* Post command packet */ 546 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 547 548 /* Now poll for completion */ 549 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 550 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 551 request_id = TW_RESID_OUT(response_queue.response_id); 552 553 if (request_id != 0) { 554 /* Unexpected request id */ 555 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n"); 556 return 1; 557 } 558 559 if (command_packet->status != 0) { 560 if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) { 561 /* Bad response */ 562 tw_decode_sense(tw_dev, request_id, 0); 563 return 1; 564 } else { 565 /* We know this is a 3w-1x00, and doesn't support aen's */ 566 return 0; 567 } 568 } 569 570 /* Now check the aen */ 571 aen = *(unsigned short *)(param->data); 572 aen_code = (aen & 0x0ff); 573 queue = 0; 574 switch (aen_code) { 575 case TW_AEN_QUEUE_EMPTY: 576 dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]); 577 if (first_reset != 1) { 578 return 1; 579 } else { 580 finished = 1; 581 } 582 break; 583 case TW_AEN_SOFT_RESET: 584 if (first_reset == 0) { 585 first_reset = 1; 586 } else { 587 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]); 588 tw_dev->aen_count++; 589 queue = 1; 590 } 591 break; 592 default: 593 if (aen == 0x0ff) { 594 printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n"); 595 } else { 596 table_max = ARRAY_SIZE(tw_aen_string); 597 if ((aen & 0x0ff) < table_max) { 598 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') { 599 printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8); 600 } else { 601 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]); 602 } 603 } else 604 printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen); 605 } 606 tw_dev->aen_count++; 607 queue = 1; 608 } 609 610 /* Now put the aen on the aen_queue */ 611 if (queue == 1) { 612 tw_dev->aen_queue[tw_dev->aen_tail] = aen; 613 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) { 614 tw_dev->aen_tail = TW_Q_START; 615 } else { 616 tw_dev->aen_tail = tw_dev->aen_tail + 1; 617 } 618 if (tw_dev->aen_head == tw_dev->aen_tail) { 619 if (tw_dev->aen_head == TW_Q_LENGTH - 1) { 620 tw_dev->aen_head = TW_Q_START; 621 } else { 622 tw_dev->aen_head = tw_dev->aen_head + 1; 623 } 624 } 625 } 626 found = 1; 627 } 628 if (found == 0) { 629 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n"); 630 return 1; 631 } 632 } while (finished == 0); 633 634 return 0; 635} /* End tw_aen_drain_queue() */ 636 637/* This function will allocate memory */ 638static int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) 639{ 640 int i; 641 dma_addr_t dma_handle; 642 unsigned long *cpu_addr = NULL; 643 644 dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n"); 645 646 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle); 647 if (cpu_addr == NULL) { 648 printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n"); 649 return 1; 650 } 651 652 if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) { 653 printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n"); 654 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle); 655 return 1; 656 } 657 658 memset(cpu_addr, 0, size*TW_Q_LENGTH); 659 660 for (i=0;i<TW_Q_LENGTH;i++) { 661 switch(which) { 662 case 0: 663 tw_dev->command_packet_physical_address[i] = dma_handle+(i*size); 664 tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 665 break; 666 case 1: 667 tw_dev->alignment_physical_address[i] = dma_handle+(i*size); 668 tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 669 break; 670 default: 671 printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n"); 672 return 1; 673 } 674 } 675 676 return 0; 677} /* End tw_allocate_memory() */ 678 679/* This function handles ioctl for the character device */ 680static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 681{ 682 int request_id; 683 dma_addr_t dma_handle; 684 unsigned short tw_aen_code; 685 unsigned long flags; 686 unsigned int data_buffer_length = 0; 687 unsigned long data_buffer_length_adjusted = 0; 688 unsigned long *cpu_addr; 689 long timeout; 690 TW_New_Ioctl *tw_ioctl; 691 TW_Passthru *passthru; 692 TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)]; 693 int retval = -EFAULT; 694 void __user *argp = (void __user *)arg; 695 696 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n"); 697 698 /* Only let one of these through at a time */ 699 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) 700 return -EINTR; 701 702 /* First copy down the buffer length */ 703 if (copy_from_user(&data_buffer_length, argp, sizeof(unsigned int))) 704 goto out; 705 706 /* Check size */ 707 if (data_buffer_length > TW_MAX_IOCTL_SECTORS * 512) { 708 retval = -EINVAL; 709 goto out; 710 } 711 712 /* Hardware can only do multiple of 512 byte transfers */ 713 data_buffer_length_adjusted = (data_buffer_length + 511) & ~511; 714 715 /* Now allocate ioctl buf memory */ 716 cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle, GFP_KERNEL); 717 if (cpu_addr == NULL) { 718 retval = -ENOMEM; 719 goto out; 720 } 721 722 tw_ioctl = (TW_New_Ioctl *)cpu_addr; 723 724 /* Now copy down the entire ioctl */ 725 if (copy_from_user(tw_ioctl, argp, data_buffer_length + sizeof(TW_New_Ioctl) - 1)) 726 goto out2; 727 728 passthru = (TW_Passthru *)&tw_ioctl->firmware_command; 729 730 /* See which ioctl we are doing */ 731 switch (cmd) { 732 case TW_OP_NOP: 733 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n"); 734 break; 735 case TW_OP_AEN_LISTEN: 736 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n"); 737 memset(tw_ioctl->data_buffer, 0, data_buffer_length); 738 739 spin_lock_irqsave(tw_dev->host->host_lock, flags); 740 if (tw_dev->aen_head == tw_dev->aen_tail) { 741 tw_aen_code = TW_AEN_QUEUE_EMPTY; 742 } else { 743 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head]; 744 if (tw_dev->aen_head == TW_Q_LENGTH - 1) { 745 tw_dev->aen_head = TW_Q_START; 746 } else { 747 tw_dev->aen_head = tw_dev->aen_head + 1; 748 } 749 } 750 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 751 memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code)); 752 break; 753 case TW_CMD_PACKET_WITH_DATA: 754 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n"); 755 spin_lock_irqsave(tw_dev->host->host_lock, flags); 756 757 tw_state_request_start(tw_dev, &request_id); 758 759 /* Flag internal command */ 760 tw_dev->srb[request_id] = NULL; 761 762 /* Flag chrdev ioctl */ 763 tw_dev->chrdev_request_id = request_id; 764 765 tw_ioctl->firmware_command.request_id = request_id; 766 767 /* Load the sg list */ 768 switch (TW_SGL_OUT(tw_ioctl->firmware_command.opcode__sgloffset)) { 769 case 2: 770 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 771 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted; 772 break; 773 case 3: 774 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 775 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted; 776 break; 777 case 5: 778 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 779 passthru->sg_list[0].length = data_buffer_length_adjusted; 780 break; 781 } 782 783 memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command)); 784 785 /* Now post the command packet to the controller */ 786 tw_post_command_packet(tw_dev, request_id); 787 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 788 789 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ; 790 791 /* Now wait for the command to complete */ 792 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout); 793 794 /* We timed out, and didn't get an interrupt */ 795 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) { 796 /* Now we need to reset the board */ 797 printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd); 798 retval = -EIO; 799 if (tw_reset_device_extension(tw_dev)) { 800 printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no); 801 } 802 goto out2; 803 } 804 805 /* Now copy in the command packet response */ 806 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command)); 807 808 /* Now complete the io */ 809 spin_lock_irqsave(tw_dev->host->host_lock, flags); 810 tw_dev->posted_request_count--; 811 tw_dev->state[request_id] = TW_S_COMPLETED; 812 tw_state_request_finish(tw_dev, request_id); 813 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 814 break; 815 default: 816 retval = -ENOTTY; 817 goto out2; 818 } 819 820 /* Now copy the response to userspace */ 821 if (copy_to_user(argp, tw_ioctl, sizeof(TW_New_Ioctl) + data_buffer_length - 1)) 822 goto out2; 823 retval = 0; 824out2: 825 /* Now free ioctl buf memory */ 826 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle); 827out: 828 mutex_unlock(&tw_dev->ioctl_lock); 829 return retval; 830} /* End tw_chrdev_ioctl() */ 831 832/* This function handles open for the character device */ 833static int tw_chrdev_open(struct inode *inode, struct file *file) 834{ 835 unsigned int minor_number; 836 837 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n"); 838 839 minor_number = iminor(inode); 840 if (minor_number >= tw_device_extension_count) 841 return -ENODEV; 842 843 return 0; 844} /* End tw_chrdev_open() */ 845 846/* File operations struct for character device */ 847static const struct file_operations tw_fops = { 848 .owner = THIS_MODULE, 849 .ioctl = tw_chrdev_ioctl, 850 .open = tw_chrdev_open, 851 .release = NULL 852}; 853 854/* This function will free up device extension resources */ 855static void tw_free_device_extension(TW_Device_Extension *tw_dev) 856{ 857 dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n"); 858 859 /* Free command packet and generic buffer memory */ 860 if (tw_dev->command_packet_virtual_address[0]) 861 pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Command)*TW_Q_LENGTH, tw_dev->command_packet_virtual_address[0], tw_dev->command_packet_physical_address[0]); 862 863 if (tw_dev->alignment_virtual_address[0]) 864 pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Sector)*TW_Q_LENGTH, tw_dev->alignment_virtual_address[0], tw_dev->alignment_physical_address[0]); 865} /* End tw_free_device_extension() */ 866 867/* This function will send an initconnection command to controller */ 868static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits) 869{ 870 unsigned long command_que_value; 871 TW_Command *command_packet; 872 TW_Response_Queue response_queue; 873 int request_id = 0; 874 875 dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n"); 876 877 /* Initialize InitConnection command packet */ 878 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 879 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n"); 880 return 1; 881 } 882 883 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 884 memset(command_packet, 0, sizeof(TW_Sector)); 885 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION); 886 command_packet->size = TW_INIT_COMMAND_PACKET_SIZE; 887 command_packet->request_id = request_id; 888 command_packet->status = 0x0; 889 command_packet->flags = 0x0; 890 command_packet->byte6.message_credits = message_credits; 891 command_packet->byte8.init_connection.response_queue_pointer = 0x0; 892 command_que_value = tw_dev->command_packet_physical_address[request_id]; 893 894 if (command_que_value == 0) { 895 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n"); 896 return 1; 897 } 898 899 /* Send command packet to the board */ 900 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 901 902 /* Poll for completion */ 903 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 904 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 905 request_id = TW_RESID_OUT(response_queue.response_id); 906 907 if (request_id != 0) { 908 /* unexpected request id */ 909 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n"); 910 return 1; 911 } 912 if (command_packet->status != 0) { 913 /* bad response */ 914 tw_decode_sense(tw_dev, request_id, 0); 915 return 1; 916 } 917 } 918 return 0; 919} /* End tw_initconnection() */ 920 921/* Set a value in the features table */ 922static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size, 923 unsigned char *val) 924{ 925 TW_Param *param; 926 TW_Command *command_packet; 927 TW_Response_Queue response_queue; 928 int request_id = 0; 929 unsigned long command_que_value; 930 unsigned long param_value; 931 932 /* Initialize SetParam command packet */ 933 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 934 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n"); 935 return 1; 936 } 937 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 938 memset(command_packet, 0, sizeof(TW_Sector)); 939 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 940 941 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM); 942 param->table_id = 0x404; /* Features table */ 943 param->parameter_id = parm; 944 param->parameter_size_bytes = param_size; 945 memcpy(param->data, val, param_size); 946 947 param_value = tw_dev->alignment_physical_address[request_id]; 948 if (param_value == 0) { 949 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n"); 950 tw_dev->state[request_id] = TW_S_COMPLETED; 951 tw_state_request_finish(tw_dev, request_id); 952 tw_dev->srb[request_id]->result = (DID_OK << 16); 953 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 954 } 955 command_packet->byte8.param.sgl[0].address = param_value; 956 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 957 958 command_packet->size = 4; 959 command_packet->request_id = request_id; 960 command_packet->byte6.parameter_count = 1; 961 962 command_que_value = tw_dev->command_packet_physical_address[request_id]; 963 if (command_que_value == 0) { 964 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n"); 965 return 1; 966 } 967 968 /* Send command packet to the board */ 969 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 970 971 /* Poll for completion */ 972 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 973 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 974 request_id = TW_RESID_OUT(response_queue.response_id); 975 976 if (request_id != 0) { 977 /* unexpected request id */ 978 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n"); 979 return 1; 980 } 981 if (command_packet->status != 0) { 982 /* bad response */ 983 tw_decode_sense(tw_dev, request_id, 0); 984 return 1; 985 } 986 } 987 988 return 0; 989} /* End tw_setfeature() */ 990 991/* This function will reset a controller */ 992static int tw_reset_sequence(TW_Device_Extension *tw_dev) 993{ 994 int error = 0; 995 int tries = 0; 996 unsigned char c = 1; 997 998 /* Reset the board */ 999 while (tries < TW_MAX_RESET_TRIES) { 1000 TW_SOFT_RESET(tw_dev); 1001 1002 error = tw_aen_drain_queue(tw_dev); 1003 if (error) { 1004 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no); 1005 tries++; 1006 continue; 1007 } 1008 1009 /* Check for controller errors */ 1010 if (tw_check_errors(tw_dev)) { 1011 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no); 1012 tries++; 1013 continue; 1014 } 1015 1016 /* Now the controller is in a good state */ 1017 break; 1018 } 1019 1020 if (tries >= TW_MAX_RESET_TRIES) { 1021 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no); 1022 return 1; 1023 } 1024 1025 error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS); 1026 if (error) { 1027 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no); 1028 return 1; 1029 } 1030 1031 error = tw_setfeature(tw_dev, 2, 1, &c); 1032 if (error) { 1033 printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n"); 1034 } 1035 1036 return 0; 1037} /* End tw_reset_sequence() */ 1038 1039/* This function will initialize the fields of a device extension */ 1040static int tw_initialize_device_extension(TW_Device_Extension *tw_dev) 1041{ 1042 int i, error=0; 1043 1044 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n"); 1045 1046 /* Initialize command packet buffers */ 1047 error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0); 1048 if (error) { 1049 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n"); 1050 return 1; 1051 } 1052 1053 /* Initialize generic buffer */ 1054 error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1); 1055 if (error) { 1056 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n"); 1057 return 1; 1058 } 1059 1060 for (i=0;i<TW_Q_LENGTH;i++) { 1061 tw_dev->free_queue[i] = i; 1062 tw_dev->state[i] = TW_S_INITIAL; 1063 } 1064 1065 tw_dev->pending_head = TW_Q_START; 1066 tw_dev->pending_tail = TW_Q_START; 1067 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1068 1069 mutex_init(&tw_dev->ioctl_lock); 1070 init_waitqueue_head(&tw_dev->ioctl_wqueue); 1071 1072 return 0; 1073} /* End tw_initialize_device_extension() */ 1074 1075static int tw_map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 1076{ 1077 int use_sg; 1078 1079 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data()\n"); 1080 1081 if (cmd->use_sg == 0) 1082 return 0; 1083 1084 use_sg = pci_map_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 1085 1086 if (use_sg == 0) { 1087 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data(): pci_map_sg() failed.\n"); 1088 return 0; 1089 } 1090 1091 cmd->SCp.phase = TW_PHASE_SGLIST; 1092 cmd->SCp.have_data_in = use_sg; 1093 1094 return use_sg; 1095} /* End tw_map_scsi_sg_data() */ 1096 1097static u32 tw_map_scsi_single_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 1098{ 1099 dma_addr_t mapping; 1100 1101 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data()\n"); 1102 1103 if (cmd->request_bufflen == 0) 1104 return 0; 1105 1106 mapping = pci_map_page(pdev, virt_to_page(cmd->request_buffer), offset_in_page(cmd->request_buffer), cmd->request_bufflen, DMA_BIDIRECTIONAL); 1107 1108 if (mapping == 0) { 1109 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data(): pci_map_page() failed.\n"); 1110 return 0; 1111 } 1112 1113 cmd->SCp.phase = TW_PHASE_SINGLE; 1114 cmd->SCp.have_data_in = mapping; 1115 1116 return mapping; 1117} /* End tw_map_scsi_single_data() */ 1118 1119static void tw_unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 1120{ 1121 dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n"); 1122 1123 switch(cmd->SCp.phase) { 1124 case TW_PHASE_SINGLE: 1125 pci_unmap_page(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL); 1126 break; 1127 case TW_PHASE_SGLIST: 1128 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 1129 break; 1130 } 1131} /* End tw_unmap_scsi_data() */ 1132 1133/* This function will reset a device extension */ 1134static int tw_reset_device_extension(TW_Device_Extension *tw_dev) 1135{ 1136 int i = 0; 1137 struct scsi_cmnd *srb; 1138 unsigned long flags = 0; 1139 1140 dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n"); 1141 1142 set_bit(TW_IN_RESET, &tw_dev->flags); 1143 TW_DISABLE_INTERRUPTS(tw_dev); 1144 TW_MASK_COMMAND_INTERRUPT(tw_dev); 1145 spin_lock_irqsave(tw_dev->host->host_lock, flags); 1146 1147 /* Abort all requests that are in progress */ 1148 for (i=0;i<TW_Q_LENGTH;i++) { 1149 if ((tw_dev->state[i] != TW_S_FINISHED) && 1150 (tw_dev->state[i] != TW_S_INITIAL) && 1151 (tw_dev->state[i] != TW_S_COMPLETED)) { 1152 srb = tw_dev->srb[i]; 1153 if (srb != NULL) { 1154 srb->result = (DID_RESET << 16); 1155 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]); 1156 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[i]); 1157 } 1158 } 1159 } 1160 1161 /* Reset queues and counts */ 1162 for (i=0;i<TW_Q_LENGTH;i++) { 1163 tw_dev->free_queue[i] = i; 1164 tw_dev->state[i] = TW_S_INITIAL; 1165 } 1166 tw_dev->free_head = TW_Q_START; 1167 tw_dev->free_tail = TW_Q_START; 1168 tw_dev->posted_request_count = 0; 1169 tw_dev->pending_request_count = 0; 1170 tw_dev->pending_head = TW_Q_START; 1171 tw_dev->pending_tail = TW_Q_START; 1172 tw_dev->reset_print = 0; 1173 1174 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1175 1176 if (tw_reset_sequence(tw_dev)) { 1177 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no); 1178 return 1; 1179 } 1180 1181 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 1182 clear_bit(TW_IN_RESET, &tw_dev->flags); 1183 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1184 1185 return 0; 1186} /* End tw_reset_device_extension() */ 1187 1188/* This funciton returns unit geometry in cylinders/heads/sectors */ 1189static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1190 sector_t capacity, int geom[]) 1191{ 1192 int heads, sectors, cylinders; 1193 TW_Device_Extension *tw_dev; 1194 1195 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n"); 1196 tw_dev = (TW_Device_Extension *)sdev->host->hostdata; 1197 1198 heads = 64; 1199 sectors = 32; 1200 cylinders = sector_div(capacity, heads * sectors); 1201 1202 if (capacity >= 0x200000) { 1203 heads = 255; 1204 sectors = 63; 1205 cylinders = sector_div(capacity, heads * sectors); 1206 } 1207 1208 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders); 1209 geom[0] = heads; 1210 geom[1] = sectors; 1211 geom[2] = cylinders; 1212 1213 return 0; 1214} /* End tw_scsi_biosparam() */ 1215 1216/* This is the new scsi eh reset function */ 1217static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt) 1218{ 1219 TW_Device_Extension *tw_dev=NULL; 1220 int retval = FAILED; 1221 1222 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1223 1224 tw_dev->num_resets++; 1225 1226 sdev_printk(KERN_WARNING, SCpnt->device, 1227 "WARNING: Command (0x%x) timed out, resetting card.\n", 1228 SCpnt->cmnd[0]); 1229 1230 /* Make sure we are not issuing an ioctl or resetting from ioctl */ 1231 mutex_lock(&tw_dev->ioctl_lock); 1232 1233 /* Now reset the card and some of the device extension data */ 1234 if (tw_reset_device_extension(tw_dev)) { 1235 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no); 1236 goto out; 1237 } 1238 1239 retval = SUCCESS; 1240out: 1241 mutex_unlock(&tw_dev->ioctl_lock); 1242 return retval; 1243} /* End tw_scsi_eh_reset() */ 1244 1245/* This function handles scsi inquiry commands */ 1246static int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id) 1247{ 1248 TW_Param *param; 1249 TW_Command *command_packet; 1250 unsigned long command_que_value; 1251 unsigned long param_value; 1252 1253 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n"); 1254 1255 /* Initialize command packet */ 1256 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1257 if (command_packet == NULL) { 1258 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n"); 1259 return 1; 1260 } 1261 memset(command_packet, 0, sizeof(TW_Sector)); 1262 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1263 command_packet->size = 4; 1264 command_packet->request_id = request_id; 1265 command_packet->status = 0; 1266 command_packet->flags = 0; 1267 command_packet->byte6.parameter_count = 1; 1268 1269 /* Now setup the param */ 1270 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1271 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n"); 1272 return 1; 1273 } 1274 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1275 memset(param, 0, sizeof(TW_Sector)); 1276 param->table_id = 3; /* unit summary table */ 1277 param->parameter_id = 3; /* unitsstatus parameter */ 1278 param->parameter_size_bytes = TW_MAX_UNITS; 1279 param_value = tw_dev->alignment_physical_address[request_id]; 1280 if (param_value == 0) { 1281 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n"); 1282 return 1; 1283 } 1284 1285 command_packet->byte8.param.sgl[0].address = param_value; 1286 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1287 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1288 if (command_que_value == 0) { 1289 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n"); 1290 return 1; 1291 } 1292 1293 /* Now try to post the command packet */ 1294 tw_post_command_packet(tw_dev, request_id); 1295 1296 return 0; 1297} /* End tw_scsiop_inquiry() */ 1298 1299static void tw_transfer_internal(TW_Device_Extension *tw_dev, int request_id, 1300 void *data, unsigned int len) 1301{ 1302 struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 1303 void *buf; 1304 unsigned int transfer_len; 1305 unsigned long flags = 0; 1306 1307 if (cmd->use_sg) { 1308 struct scatterlist *sg = 1309 (struct scatterlist *)cmd->request_buffer; 1310 local_irq_save(flags); 1311 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 1312 transfer_len = min(sg->length, len); 1313 } else { 1314 buf = cmd->request_buffer; 1315 transfer_len = min(cmd->request_bufflen, len); 1316 } 1317 1318 memcpy(buf, data, transfer_len); 1319 1320 if (cmd->use_sg) { 1321 struct scatterlist *sg; 1322 1323 sg = (struct scatterlist *)cmd->request_buffer; 1324 kunmap_atomic(buf - sg->offset, KM_IRQ0); 1325 local_irq_restore(flags); 1326 } 1327} 1328 1329/* This function is called by the isr to complete an inquiry command */ 1330static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id) 1331{ 1332 unsigned char *is_unit_present; 1333 unsigned char request_buffer[36]; 1334 TW_Param *param; 1335 1336 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n"); 1337 1338 memset(request_buffer, 0, sizeof(request_buffer)); 1339 request_buffer[0] = TYPE_DISK; /* Peripheral device type */ 1340 request_buffer[1] = 0; /* Device type modifier */ 1341 request_buffer[2] = 0; /* No ansi/iso compliance */ 1342 request_buffer[4] = 31; /* Additional length */ 1343 memcpy(&request_buffer[8], "3ware ", 8); /* Vendor ID */ 1344 sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id); 1345 memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3); 1346 tw_transfer_internal(tw_dev, request_id, request_buffer, 1347 sizeof(request_buffer)); 1348 1349 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1350 if (param == NULL) { 1351 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n"); 1352 return 1; 1353 } 1354 is_unit_present = &(param->data[0]); 1355 1356 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) { 1357 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1; 1358 } else { 1359 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0; 1360 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16); 1361 return TW_ISR_DONT_RESULT; 1362 } 1363 1364 return 0; 1365} /* End tw_scsiop_inquiry_complete() */ 1366 1367/* This function handles scsi mode_sense commands */ 1368static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id) 1369{ 1370 TW_Param *param; 1371 TW_Command *command_packet; 1372 unsigned long command_que_value; 1373 unsigned long param_value; 1374 1375 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n"); 1376 1377 /* Only page control = 0, page code = 0x8 (cache page) supported */ 1378 if (tw_dev->srb[request_id]->cmnd[2] != 0x8) { 1379 tw_dev->state[request_id] = TW_S_COMPLETED; 1380 tw_state_request_finish(tw_dev, request_id); 1381 tw_dev->srb[request_id]->result = (DID_OK << 16); 1382 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1383 return 0; 1384 } 1385 1386 /* Now read firmware cache setting for this unit */ 1387 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1388 if (command_packet == NULL) { 1389 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n"); 1390 return 1; 1391 } 1392 1393 /* Setup the command packet */ 1394 memset(command_packet, 0, sizeof(TW_Sector)); 1395 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1396 command_packet->size = 4; 1397 command_packet->request_id = request_id; 1398 command_packet->status = 0; 1399 command_packet->flags = 0; 1400 command_packet->byte6.parameter_count = 1; 1401 1402 /* Setup the param */ 1403 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1404 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n"); 1405 return 1; 1406 } 1407 1408 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1409 memset(param, 0, sizeof(TW_Sector)); 1410 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id; 1411 param->parameter_id = 7; /* unit flags */ 1412 param->parameter_size_bytes = 1; 1413 param_value = tw_dev->alignment_physical_address[request_id]; 1414 if (param_value == 0) { 1415 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n"); 1416 return 1; 1417 } 1418 1419 command_packet->byte8.param.sgl[0].address = param_value; 1420 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1421 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1422 if (command_que_value == 0) { 1423 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n"); 1424 return 1; 1425 } 1426 1427 /* Now try to post the command packet */ 1428 tw_post_command_packet(tw_dev, request_id); 1429 1430 return 0; 1431} /* End tw_scsiop_mode_sense() */ 1432 1433/* This function is called by the isr to complete a mode sense command */ 1434static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id) 1435{ 1436 TW_Param *param; 1437 unsigned char *flags; 1438 unsigned char request_buffer[8]; 1439 1440 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n"); 1441 1442 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1443 if (param == NULL) { 1444 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n"); 1445 return 1; 1446 } 1447 flags = (char *)&(param->data[0]); 1448 memset(request_buffer, 0, sizeof(request_buffer)); 1449 1450 request_buffer[0] = 0xf; /* mode data length */ 1451 request_buffer[1] = 0; /* default medium type */ 1452 request_buffer[2] = 0x10; /* dpo/fua support on */ 1453 request_buffer[3] = 0; /* no block descriptors */ 1454 request_buffer[4] = 0x8; /* caching page */ 1455 request_buffer[5] = 0xa; /* page length */ 1456 if (*flags & 0x1) 1457 request_buffer[6] = 0x5; /* WCE on, RCD on */ 1458 else 1459 request_buffer[6] = 0x1; /* WCE off, RCD on */ 1460 tw_transfer_internal(tw_dev, request_id, request_buffer, 1461 sizeof(request_buffer)); 1462 1463 return 0; 1464} /* End tw_scsiop_mode_sense_complete() */ 1465 1466/* This function handles scsi read_capacity commands */ 1467static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id) 1468{ 1469 TW_Param *param; 1470 TW_Command *command_packet; 1471 unsigned long command_que_value; 1472 unsigned long param_value; 1473 1474 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n"); 1475 1476 /* Initialize command packet */ 1477 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1478 1479 if (command_packet == NULL) { 1480 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n"); 1481 return 1; 1482 } 1483 memset(command_packet, 0, sizeof(TW_Sector)); 1484 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1485 command_packet->size = 4; 1486 command_packet->request_id = request_id; 1487 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id); 1488 command_packet->status = 0; 1489 command_packet->flags = 0; 1490 command_packet->byte6.block_count = 1; 1491 1492 /* Now setup the param */ 1493 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1494 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n"); 1495 return 1; 1496 } 1497 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1498 memset(param, 0, sizeof(TW_Sector)); 1499 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + 1500 tw_dev->srb[request_id]->device->id; 1501 param->parameter_id = 4; /* unitcapacity parameter */ 1502 param->parameter_size_bytes = 4; 1503 param_value = tw_dev->alignment_physical_address[request_id]; 1504 if (param_value == 0) { 1505 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n"); 1506 return 1; 1507 } 1508 1509 command_packet->byte8.param.sgl[0].address = param_value; 1510 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1511 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1512 if (command_que_value == 0) { 1513 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n"); 1514 return 1; 1515 } 1516 1517 /* Now try to post the command to the board */ 1518 tw_post_command_packet(tw_dev, request_id); 1519 1520 return 0; 1521} /* End tw_scsiop_read_capacity() */ 1522 1523/* This function is called by the isr to complete a readcapacity command */ 1524static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id) 1525{ 1526 unsigned char *param_data; 1527 u32 capacity; 1528 char buff[8]; 1529 TW_Param *param; 1530 1531 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n"); 1532 1533 memset(buff, 0, sizeof(buff)); 1534 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1535 if (param == NULL) { 1536 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n"); 1537 return 1; 1538 } 1539 param_data = &(param->data[0]); 1540 1541 capacity = (param_data[3] << 24) | (param_data[2] << 16) | 1542 (param_data[1] << 8) | param_data[0]; 1543 1544 /* Subtract one sector to fix get last sector ioctl */ 1545 capacity -= 1; 1546 1547 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity); 1548 1549 /* Number of LBA's */ 1550 buff[0] = (capacity >> 24); 1551 buff[1] = (capacity >> 16) & 0xff; 1552 buff[2] = (capacity >> 8) & 0xff; 1553 buff[3] = capacity & 0xff; 1554 1555 /* Block size in bytes (512) */ 1556 buff[4] = (TW_BLOCK_SIZE >> 24); 1557 buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff; 1558 buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff; 1559 buff[7] = TW_BLOCK_SIZE & 0xff; 1560 1561 tw_transfer_internal(tw_dev, request_id, buff, sizeof(buff)); 1562 1563 return 0; 1564} /* End tw_scsiop_read_capacity_complete() */ 1565 1566/* This function handles scsi read or write commands */ 1567static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id) 1568{ 1569 TW_Command *command_packet; 1570 unsigned long command_que_value; 1571 u32 lba = 0x0, num_sectors = 0x0, buffaddr = 0x0; 1572 int i, use_sg; 1573 struct scsi_cmnd *srb; 1574 struct scatterlist *sglist; 1575 1576 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n"); 1577 1578 if (tw_dev->srb[request_id]->request_buffer == NULL) { 1579 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n"); 1580 return 1; 1581 } 1582 sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 1583 srb = tw_dev->srb[request_id]; 1584 1585 /* Initialize command packet */ 1586 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1587 if (command_packet == NULL) { 1588 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n"); 1589 return 1; 1590 } 1591 1592 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) { 1593 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ); 1594 } else { 1595 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE); 1596 } 1597 1598 command_packet->size = 3; 1599 command_packet->request_id = request_id; 1600 command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id); 1601 command_packet->status = 0; 1602 command_packet->flags = 0; 1603 1604 if (srb->cmnd[0] == WRITE_10) { 1605 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10)) 1606 command_packet->flags = 1; 1607 } 1608 1609 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) { 1610 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3]; 1611 num_sectors = (u32)srb->cmnd[4]; 1612 } else { 1613 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5]; 1614 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8); 1615 } 1616 1617 /* Update sector statistic */ 1618 tw_dev->sector_count = num_sectors; 1619 if (tw_dev->sector_count > tw_dev->max_sector_count) 1620 tw_dev->max_sector_count = tw_dev->sector_count; 1621 1622 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors); 1623 command_packet->byte8.io.lba = lba; 1624 command_packet->byte6.block_count = num_sectors; 1625 1626 /* Do this if there are no sg list entries */ 1627 if (tw_dev->srb[request_id]->use_sg == 0) { 1628 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): SG = 0\n"); 1629 buffaddr = tw_map_scsi_single_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]); 1630 if (buffaddr == 0) 1631 return 1; 1632 1633 command_packet->byte8.io.sgl[0].address = buffaddr; 1634 command_packet->byte8.io.sgl[0].length = tw_dev->srb[request_id]->request_bufflen; 1635 command_packet->size+=2; 1636 } 1637 1638 /* Do this if we have multiple sg list entries */ 1639 if (tw_dev->srb[request_id]->use_sg > 0) { 1640 use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]); 1641 if (use_sg == 0) 1642 return 1; 1643 1644 for (i=0;i<use_sg; i++) { 1645 command_packet->byte8.io.sgl[i].address = sg_dma_address(&sglist[i]); 1646 command_packet->byte8.io.sgl[i].length = sg_dma_len(&sglist[i]); 1647 command_packet->size+=2; 1648 } 1649 } 1650 1651 /* Update SG statistics */ 1652 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg; 1653 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries) 1654 tw_dev->max_sgl_entries = tw_dev->sgl_entries; 1655 1656 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1657 if (command_que_value == 0) { 1658 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n"); 1659 return 1; 1660 } 1661 1662 /* Now try to post the command to the board */ 1663 tw_post_command_packet(tw_dev, request_id); 1664 1665 return 0; 1666} /* End tw_scsiop_read_write() */ 1667 1668/* This function will handle the request sense scsi command */ 1669static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id) 1670{ 1671 char request_buffer[18]; 1672 1673 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n"); 1674 1675 memset(request_buffer, 0, sizeof(request_buffer)); 1676 request_buffer[0] = 0x70; /* Immediate fixed format */ 1677 request_buffer[7] = 10; /* minimum size per SPC: 18 bytes */ 1678 /* leave all other fields zero, giving effectively NO_SENSE return */ 1679 tw_transfer_internal(tw_dev, request_id, request_buffer, 1680 sizeof(request_buffer)); 1681 1682 tw_dev->state[request_id] = TW_S_COMPLETED; 1683 tw_state_request_finish(tw_dev, request_id); 1684 1685 /* If we got a request_sense, we probably want a reset, return error */ 1686 tw_dev->srb[request_id]->result = (DID_ERROR << 16); 1687 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1688 1689 return 0; 1690} /* End tw_scsiop_request_sense() */ 1691 1692/* This function will handle synchronize cache scsi command */ 1693static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id) 1694{ 1695 TW_Command *command_packet; 1696 unsigned long command_que_value; 1697 1698 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n"); 1699 1700 /* Send firmware flush command for this unit */ 1701 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1702 if (command_packet == NULL) { 1703 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n"); 1704 return 1; 1705 } 1706 1707 /* Setup the command packet */ 1708 memset(command_packet, 0, sizeof(TW_Sector)); 1709 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE); 1710 command_packet->size = 2; 1711 command_packet->request_id = request_id; 1712 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id); 1713 command_packet->status = 0; 1714 command_packet->flags = 0; 1715 command_packet->byte6.parameter_count = 1; 1716 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1717 if (command_que_value == 0) { 1718 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n"); 1719 return 1; 1720 } 1721 1722 /* Now try to post the command packet */ 1723 tw_post_command_packet(tw_dev, request_id); 1724 1725 return 0; 1726} /* End tw_scsiop_synchronize_cache() */ 1727 1728/* This function will handle test unit ready scsi command */ 1729static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id) 1730{ 1731 TW_Param *param; 1732 TW_Command *command_packet; 1733 unsigned long command_que_value; 1734 unsigned long param_value; 1735 1736 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n"); 1737 1738 /* Initialize command packet */ 1739 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1740 if (command_packet == NULL) { 1741 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n"); 1742 return 1; 1743 } 1744 memset(command_packet, 0, sizeof(TW_Sector)); 1745 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1746 command_packet->size = 4; 1747 command_packet->request_id = request_id; 1748 command_packet->status = 0; 1749 command_packet->flags = 0; 1750 command_packet->byte6.parameter_count = 1; 1751 1752 /* Now setup the param */ 1753 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1754 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n"); 1755 return 1; 1756 } 1757 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1758 memset(param, 0, sizeof(TW_Sector)); 1759 param->table_id = 3; /* unit summary table */ 1760 param->parameter_id = 3; /* unitsstatus parameter */ 1761 param->parameter_size_bytes = TW_MAX_UNITS; 1762 param_value = tw_dev->alignment_physical_address[request_id]; 1763 if (param_value == 0) { 1764 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n"); 1765 return 1; 1766 } 1767 1768 command_packet->byte8.param.sgl[0].address = param_value; 1769 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1770 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1771 if (command_que_value == 0) { 1772 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n"); 1773 return 1; 1774 } 1775 1776 /* Now try to post the command packet */ 1777 tw_post_command_packet(tw_dev, request_id); 1778 1779 return 0; 1780} /* End tw_scsiop_test_unit_ready() */ 1781 1782/* This function is called by the isr to complete a testunitready command */ 1783static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id) 1784{ 1785 unsigned char *is_unit_present; 1786 TW_Param *param; 1787 1788 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n"); 1789 1790 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1791 if (param == NULL) { 1792 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n"); 1793 return 1; 1794 } 1795 is_unit_present = &(param->data[0]); 1796 1797 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) { 1798 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1; 1799 } else { 1800 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0; 1801 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16); 1802 return TW_ISR_DONT_RESULT; 1803 } 1804 1805 return 0; 1806} /* End tw_scsiop_test_unit_ready_complete() */ 1807 1808/* This is the main scsi queue function to handle scsi opcodes */ 1809static int tw_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 1810{ 1811 unsigned char *command = SCpnt->cmnd; 1812 int request_id = 0; 1813 int retval = 1; 1814 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1815 1816 /* If we are resetting due to timed out ioctl, report as busy */ 1817 if (test_bit(TW_IN_RESET, &tw_dev->flags)) 1818 return SCSI_MLQUEUE_HOST_BUSY; 1819 1820 /* Save done function into Scsi_Cmnd struct */ 1821 SCpnt->scsi_done = done; 1822 1823 /* Queue the command and get a request id */ 1824 tw_state_request_start(tw_dev, &request_id); 1825 1826 /* Save the scsi command for use by the ISR */ 1827 tw_dev->srb[request_id] = SCpnt; 1828 1829 /* Initialize phase to zero */ 1830 SCpnt->SCp.phase = TW_PHASE_INITIAL; 1831 1832 switch (*command) { 1833 case READ_10: 1834 case READ_6: 1835 case WRITE_10: 1836 case WRITE_6: 1837 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n"); 1838 retval = tw_scsiop_read_write(tw_dev, request_id); 1839 break; 1840 case TEST_UNIT_READY: 1841 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n"); 1842 retval = tw_scsiop_test_unit_ready(tw_dev, request_id); 1843 break; 1844 case INQUIRY: 1845 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n"); 1846 retval = tw_scsiop_inquiry(tw_dev, request_id); 1847 break; 1848 case READ_CAPACITY: 1849 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n"); 1850 retval = tw_scsiop_read_capacity(tw_dev, request_id); 1851 break; 1852 case REQUEST_SENSE: 1853 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n"); 1854 retval = tw_scsiop_request_sense(tw_dev, request_id); 1855 break; 1856 case MODE_SENSE: 1857 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n"); 1858 retval = tw_scsiop_mode_sense(tw_dev, request_id); 1859 break; 1860 case SYNCHRONIZE_CACHE: 1861 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n"); 1862 retval = tw_scsiop_synchronize_cache(tw_dev, request_id); 1863 break; 1864 case TW_IOCTL: 1865 printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n"); 1866 break; 1867 default: 1868 printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command); 1869 tw_dev->state[request_id] = TW_S_COMPLETED; 1870 tw_state_request_finish(tw_dev, request_id); 1871 SCpnt->result = (DID_BAD_TARGET << 16); 1872 done(SCpnt); 1873 retval = 0; 1874 } 1875 if (retval) { 1876 tw_dev->state[request_id] = TW_S_COMPLETED; 1877 tw_state_request_finish(tw_dev, request_id); 1878 SCpnt->result = (DID_ERROR << 16); 1879 done(SCpnt); 1880 retval = 0; 1881 } 1882 return retval; 1883} /* End tw_scsi_queue() */ 1884 1885/* This function is the interrupt service routine */ 1886static irqreturn_t tw_interrupt(int irq, void *dev_instance) 1887{ 1888 int request_id; 1889 u32 status_reg_value; 1890 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance; 1891 TW_Response_Queue response_que; 1892 int error = 0, retval = 0; 1893 TW_Command *command_packet; 1894 int handled = 0; 1895 1896 /* Get the host lock for io completions */ 1897 spin_lock(tw_dev->host->host_lock); 1898 1899 /* Read the registers */ 1900 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 1901 1902 /* Check if this is our interrupt, otherwise bail */ 1903 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT)) 1904 goto tw_interrupt_bail; 1905 1906 handled = 1; 1907 1908 /* If we are resetting, bail */ 1909 if (test_bit(TW_IN_RESET, &tw_dev->flags)) 1910 goto tw_interrupt_bail; 1911 1912 /* Check controller for errors */ 1913 if (tw_check_bits(status_reg_value)) { 1914 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n"); 1915 if (tw_decode_bits(tw_dev, status_reg_value, 1)) { 1916 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 1917 goto tw_interrupt_bail; 1918 } 1919 } 1920 1921 /* Handle host interrupt */ 1922 if (status_reg_value & TW_STATUS_HOST_INTERRUPT) { 1923 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n"); 1924 TW_CLEAR_HOST_INTERRUPT(tw_dev); 1925 } 1926 1927 /* Handle attention interrupt */ 1928 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) { 1929 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n"); 1930 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 1931 tw_state_request_start(tw_dev, &request_id); 1932 error = tw_aen_read_queue(tw_dev, request_id); 1933 if (error) { 1934 printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no); 1935 tw_dev->state[request_id] = TW_S_COMPLETED; 1936 tw_state_request_finish(tw_dev, request_id); 1937 } 1938 } 1939 1940 /* Handle command interrupt */ 1941 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) { 1942 /* Drain as many pending commands as we can */ 1943 while (tw_dev->pending_request_count > 0) { 1944 request_id = tw_dev->pending_queue[tw_dev->pending_head]; 1945 if (tw_dev->state[request_id] != TW_S_PENDING) { 1946 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no); 1947 break; 1948 } 1949 if (tw_post_command_packet(tw_dev, request_id)==0) { 1950 if (tw_dev->pending_head == TW_Q_LENGTH-1) { 1951 tw_dev->pending_head = TW_Q_START; 1952 } else { 1953 tw_dev->pending_head = tw_dev->pending_head + 1; 1954 } 1955 tw_dev->pending_request_count--; 1956 } else { 1957 /* If we get here, we will continue re-posting on the next command interrupt */ 1958 break; 1959 } 1960 } 1961 /* If there are no more pending requests, we mask command interrupt */ 1962 if (tw_dev->pending_request_count == 0) 1963 TW_MASK_COMMAND_INTERRUPT(tw_dev); 1964 } 1965 1966 /* Handle response interrupt */ 1967 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) { 1968 /* Drain the response queue from the board */ 1969 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 1970 /* Read response queue register */ 1971 response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 1972 request_id = TW_RESID_OUT(response_que.response_id); 1973 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1974 error = 0; 1975 1976 /* Check for bad response */ 1977 if (command_packet->status != 0) { 1978 /* If internal command, don't error, don't fill sense */ 1979 if (tw_dev->srb[request_id] == NULL) { 1980 tw_decode_sense(tw_dev, request_id, 0); 1981 } else { 1982 error = tw_decode_sense(tw_dev, request_id, 1); 1983 } 1984 } 1985 1986 /* Check for correct state */ 1987 if (tw_dev->state[request_id] != TW_S_POSTED) { 1988 if (tw_dev->srb[request_id] != NULL) { 1989 printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no); 1990 error = 1; 1991 } 1992 } 1993 1994 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id); 1995 1996 /* Check for internal command completion */ 1997 if (tw_dev->srb[request_id] == NULL) { 1998 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n"); 1999 /* Check for chrdev ioctl completion */ 2000 if (request_id != tw_dev->chrdev_request_id) { 2001 retval = tw_aen_complete(tw_dev, request_id); 2002 if (retval) { 2003 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no); 2004 } 2005 } else { 2006 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 2007 wake_up(&tw_dev->ioctl_wqueue); 2008 } 2009 } else { 2010 switch (tw_dev->srb[request_id]->cmnd[0]) { 2011 case READ_10: 2012 case READ_6: 2013 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n"); 2014 break; 2015 case WRITE_10: 2016 case WRITE_6: 2017 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n"); 2018 break; 2019 case TEST_UNIT_READY: 2020 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n"); 2021 error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id); 2022 break; 2023 case INQUIRY: 2024 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n"); 2025 error = tw_scsiop_inquiry_complete(tw_dev, request_id); 2026 break; 2027 case READ_CAPACITY: 2028 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n"); 2029 error = tw_scsiop_read_capacity_complete(tw_dev, request_id); 2030 break; 2031 case MODE_SENSE: 2032 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n"); 2033 error = tw_scsiop_mode_sense_complete(tw_dev, request_id); 2034 break; 2035 case SYNCHRONIZE_CACHE: 2036 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n"); 2037 break; 2038 default: 2039 printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n"); 2040 error = 1; 2041 } 2042 2043 /* If no error command was a success */ 2044 if (error == 0) { 2045 tw_dev->srb[request_id]->result = (DID_OK << 16); 2046 } 2047 2048 /* If error, command failed */ 2049 if (error == 1) { 2050 /* Ask for a host reset */ 2051 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 2052 } 2053 2054 /* Now complete the io */ 2055 if ((error != TW_ISR_DONT_COMPLETE)) { 2056 tw_dev->state[request_id] = TW_S_COMPLETED; 2057 tw_state_request_finish(tw_dev, request_id); 2058 tw_dev->posted_request_count--; 2059 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 2060 2061 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]); 2062 } 2063 } 2064 2065 /* Check for valid status after each drain */ 2066 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 2067 if (tw_check_bits(status_reg_value)) { 2068 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n"); 2069 if (tw_decode_bits(tw_dev, status_reg_value, 1)) { 2070 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 2071 goto tw_interrupt_bail; 2072 } 2073 } 2074 } 2075 } 2076 2077tw_interrupt_bail: 2078 spin_unlock(tw_dev->host->host_lock); 2079 return IRQ_RETVAL(handled); 2080} /* End tw_interrupt() */ 2081 2082/* This function tells the controller to shut down */ 2083static void __tw_shutdown(TW_Device_Extension *tw_dev) 2084{ 2085 /* Disable interrupts */ 2086 TW_DISABLE_INTERRUPTS(tw_dev); 2087 2088 /* Free up the IRQ */ 2089 free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 2090 2091 printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no); 2092 2093 /* Tell the card we are shutting down */ 2094 if (tw_initconnection(tw_dev, 1)) { 2095 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n"); 2096 } else { 2097 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n"); 2098 } 2099 2100 /* Clear all interrupts just before exit */ 2101 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 2102} /* End __tw_shutdown() */ 2103 2104/* Wrapper for __tw_shutdown */ 2105static void tw_shutdown(struct pci_dev *pdev) 2106{ 2107 struct Scsi_Host *host = pci_get_drvdata(pdev); 2108 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 2109 2110 __tw_shutdown(tw_dev); 2111} /* End tw_shutdown() */ 2112 2113static struct scsi_host_template driver_template = { 2114 .module = THIS_MODULE, 2115 .name = "3ware Storage Controller", 2116 .queuecommand = tw_scsi_queue, 2117 .eh_host_reset_handler = tw_scsi_eh_reset, 2118 .bios_param = tw_scsi_biosparam, 2119 .change_queue_depth = tw_change_queue_depth, 2120 .can_queue = TW_Q_LENGTH-2, 2121 .this_id = -1, 2122 .sg_tablesize = TW_MAX_SGL_LENGTH, 2123 .max_sectors = TW_MAX_SECTORS, 2124 .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 2125 .use_clustering = ENABLE_CLUSTERING, 2126 .shost_attrs = tw_host_attrs, 2127 .emulated = 1 2128}; 2129 2130/* This function will probe and initialize a card */ 2131static int __devinit tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 2132{ 2133 struct Scsi_Host *host = NULL; 2134 TW_Device_Extension *tw_dev; 2135 int retval = -ENODEV; 2136 2137 retval = pci_enable_device(pdev); 2138 if (retval) { 2139 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device."); 2140 goto out_disable_device; 2141 } 2142 2143 pci_set_master(pdev); 2144 2145 retval = pci_set_dma_mask(pdev, TW_DMA_MASK); 2146 if (retval) { 2147 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask."); 2148 goto out_disable_device; 2149 } 2150 2151 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension)); 2152 if (!host) { 2153 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension."); 2154 retval = -ENOMEM; 2155 goto out_disable_device; 2156 } 2157 tw_dev = (TW_Device_Extension *)host->hostdata; 2158 2159 memset(tw_dev, 0, sizeof(TW_Device_Extension)); 2160 2161 /* Save values to device extension */ 2162 tw_dev->host = host; 2163 tw_dev->tw_pci_dev = pdev; 2164 2165 if (tw_initialize_device_extension(tw_dev)) { 2166 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension."); 2167 goto out_free_device_extension; 2168 } 2169 2170 /* Request IO regions */ 2171 retval = pci_request_regions(pdev, "3w-xxxx"); 2172 if (retval) { 2173 printk(KERN_WARNING "3w-xxxx: Failed to get mem region."); 2174 goto out_free_device_extension; 2175 } 2176 2177 /* Save base address */ 2178 tw_dev->base_addr = pci_resource_start(pdev, 0); 2179 if (!tw_dev->base_addr) { 2180 printk(KERN_WARNING "3w-xxxx: Failed to get io address."); 2181 goto out_release_mem_region; 2182 } 2183 2184 /* Disable interrupts on the card */ 2185 TW_DISABLE_INTERRUPTS(tw_dev); 2186 2187 /* Initialize the card */ 2188 if (tw_reset_sequence(tw_dev)) 2189 goto out_release_mem_region; 2190 2191 /* Set host specific parameters */ 2192 host->max_id = TW_MAX_UNITS; 2193 host->max_cmd_len = TW_MAX_CDB_LEN; 2194 2195 /* Luns and channels aren't supported by adapter */ 2196 host->max_lun = 0; 2197 host->max_channel = 0; 2198 2199 /* Register the card with the kernel SCSI layer */ 2200 retval = scsi_add_host(host, &pdev->dev); 2201 if (retval) { 2202 printk(KERN_WARNING "3w-xxxx: scsi add host failed"); 2203 goto out_release_mem_region; 2204 } 2205 2206 pci_set_drvdata(pdev, host); 2207 2208 printk(KERN_WARNING "3w-xxxx: scsi%d: Found a 3ware Storage Controller at 0x%x, IRQ: %d.\n", host->host_no, tw_dev->base_addr, pdev->irq); 2209 2210 /* Now setup the interrupt handler */ 2211 retval = request_irq(pdev->irq, tw_interrupt, IRQF_SHARED, "3w-xxxx", tw_dev); 2212 if (retval) { 2213 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ."); 2214 goto out_remove_host; 2215 } 2216 2217 tw_device_extension_list[tw_device_extension_count] = tw_dev; 2218 tw_device_extension_count++; 2219 2220 /* Re-enable interrupts on the card */ 2221 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 2222 2223 /* Finally, scan the host */ 2224 scsi_scan_host(host); 2225 2226 if (twe_major == -1) { 2227 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0) 2228 printk(KERN_WARNING "3w-xxxx: Failed to register character device."); 2229 } 2230 return 0; 2231 2232out_remove_host: 2233 scsi_remove_host(host); 2234out_release_mem_region: 2235 pci_release_regions(pdev); 2236out_free_device_extension: 2237 tw_free_device_extension(tw_dev); 2238 scsi_host_put(host); 2239out_disable_device: 2240 pci_disable_device(pdev); 2241 2242 return retval; 2243} /* End tw_probe() */ 2244 2245/* This function is called to remove a device */ 2246static void tw_remove(struct pci_dev *pdev) 2247{ 2248 struct Scsi_Host *host = pci_get_drvdata(pdev); 2249 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 2250 2251 scsi_remove_host(tw_dev->host); 2252 2253 /* Unregister character device */ 2254 if (twe_major >= 0) { 2255 unregister_chrdev(twe_major, "twe"); 2256 twe_major = -1; 2257 } 2258 2259 /* Shutdown the card */ 2260 __tw_shutdown(tw_dev); 2261 2262 /* Free up the mem region */ 2263 pci_release_regions(pdev); 2264 2265 /* Free up device extension resources */ 2266 tw_free_device_extension(tw_dev); 2267 2268 scsi_host_put(tw_dev->host); 2269 pci_disable_device(pdev); 2270 tw_device_extension_count--; 2271} /* End tw_remove() */ 2272 2273/* PCI Devices supported by this driver */ 2274static struct pci_device_id tw_pci_tbl[] __devinitdata = { 2275 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000, 2276 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2277 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000, 2278 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2279 { } 2280}; 2281MODULE_DEVICE_TABLE(pci, tw_pci_tbl); 2282 2283/* pci_driver initializer */ 2284static struct pci_driver tw_driver = { 2285 .name = "3w-xxxx", 2286 .id_table = tw_pci_tbl, 2287 .probe = tw_probe, 2288 .remove = tw_remove, 2289 .shutdown = tw_shutdown, 2290}; 2291 2292/* This function is called on driver initialization */ 2293static int __init tw_init(void) 2294{ 2295 printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION); 2296 2297 return pci_register_driver(&tw_driver); 2298} /* End tw_init() */ 2299 2300/* This function is called on driver exit */ 2301static void __exit tw_exit(void) 2302{ 2303 pci_unregister_driver(&tw_driver); 2304} /* End tw_exit() */ 2305 2306module_init(tw_init); 2307module_exit(tw_exit); 2308