1 /* 2 3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux. 3 4 Written By: Adam Radford <linuxraid@amcc.com> 5 6 Copyright (C) 2004-2005 Applied Micro Circuits Corporation. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; version 2 of the License. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 NO WARRANTY 18 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 19 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 20 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 21 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 22 solely responsible for determining the appropriateness of using and 23 distributing the Program and assumes all risks associated with its 24 exercise of rights under this Agreement, including but not limited to 25 the risks and costs of program errors, damage to or loss of data, 26 programs or equipment, and unavailability or interruption of operations. 27 28 DISCLAIMER OF LIABILITY 29 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 30 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 32 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 33 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 34 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 35 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 36 37 You should have received a copy of the GNU General Public License 38 along with this program; if not, write to the Free Software 39 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 40 41 Bugs/Comments/Suggestions should be mailed to: 42 linuxraid@amcc.com 43 44 For more information, goto: 45 http://www.amcc.com 46 47 Note: This version of the driver does not contain a bundled firmware 48 image. 49 50 History 51 ------- 52 2.26.02.000 - Driver cleanup for kernel submission. 53 2.26.02.001 - Replace schedule_timeout() calls with msleep(). 54 2.26.02.002 - Add support for PAE mode. 55 Add lun support. 56 Fix twa_remove() to free irq handler/unregister_chrdev() 57 before shutting down card. 58 Change to new 'change_queue_depth' api. 59 Fix 'handled=1' ISR usage, remove bogus IRQ check. 60 Remove un-needed eh_abort handler. 61 Add support for embedded firmware error strings. 62 2.26.02.003 - Correctly handle single sgl's with use_sg=1. 63 2.26.02.004 - Add support for 9550SX controllers. 64 */ 65 66 #include <linux/module.h> 67 #include <linux/reboot.h> 68 #include <linux/spinlock.h> 69 #include <linux/interrupt.h> 70 #include <linux/moduleparam.h> 71 #include <linux/errno.h> 72 #include <linux/types.h> 73 #include <linux/delay.h> 74 #include <linux/pci.h> 75 #include <linux/time.h> 76 #include <asm/io.h> 77 #include <asm/irq.h> 78 #include <asm/uaccess.h> 79 #include <scsi/scsi.h> 80 #include <scsi/scsi_host.h> 81 #include <scsi/scsi_tcq.h> 82 #include <scsi/scsi_cmnd.h> 83 #include "3w-9xxx.h" 84 85 /* Globals */ 86 #define TW_DRIVER_VERSION "2.26.02.004" 87 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT]; 88 static unsigned int twa_device_extension_count; 89 static int twa_major = -1; 90 extern struct timezone sys_tz; 91 92 /* Module parameters */ 93 MODULE_AUTHOR ("AMCC"); 94 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver"); 95 MODULE_LICENSE("GPL"); 96 MODULE_VERSION(TW_DRIVER_VERSION); 97 98 /* Function prototypes */ 99 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header); 100 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id); 101 static char *twa_aen_severity_lookup(unsigned char severity_code); 102 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id); 103 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg); 104 static int twa_chrdev_open(struct inode *inode, struct file *file); 105 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host); 106 static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id); 107 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id); 108 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits, 109 u32 set_features, unsigned short current_fw_srl, 110 unsigned short current_fw_arch_id, 111 unsigned short current_fw_branch, 112 unsigned short current_fw_build, 113 unsigned short *fw_on_ctlr_srl, 114 unsigned short *fw_on_ctlr_arch_id, 115 unsigned short *fw_on_ctlr_branch, 116 unsigned short *fw_on_ctlr_build, 117 u32 *init_connect_result); 118 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length); 119 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds); 120 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds); 121 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal); 122 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset); 123 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset); 124 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg); 125 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id); 126 static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code); 127 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id); 128 129 /* Functions */ 130 131 /* Show some statistics about the card */ 132 static ssize_t twa_show_stats(struct class_device *class_dev, char *buf) 133 { 134 struct Scsi_Host *host = class_to_shost(class_dev); 135 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 136 unsigned long flags = 0; 137 ssize_t len; 138 139 spin_lock_irqsave(tw_dev->host->host_lock, flags); 140 len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n" 141 "Current commands posted: %4d\n" 142 "Max commands posted: %4d\n" 143 "Current pending commands: %4d\n" 144 "Max pending commands: %4d\n" 145 "Last sgl length: %4d\n" 146 "Max sgl length: %4d\n" 147 "Last sector count: %4d\n" 148 "Max sector count: %4d\n" 149 "SCSI Host Resets: %4d\n" 150 "AEN's: %4d\n", 151 TW_DRIVER_VERSION, 152 tw_dev->posted_request_count, 153 tw_dev->max_posted_request_count, 154 tw_dev->pending_request_count, 155 tw_dev->max_pending_request_count, 156 tw_dev->sgl_entries, 157 tw_dev->max_sgl_entries, 158 tw_dev->sector_count, 159 tw_dev->max_sector_count, 160 tw_dev->num_resets, 161 tw_dev->aen_count); 162 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 163 return len; 164 } /* End twa_show_stats() */ 165 166 /* This function will set a devices queue depth */ 167 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth) 168 { 169 if (queue_depth > TW_Q_LENGTH-2) 170 queue_depth = TW_Q_LENGTH-2; 171 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth); 172 return queue_depth; 173 } /* End twa_change_queue_depth() */ 174 175 /* Create sysfs 'stats' entry */ 176 static struct class_device_attribute twa_host_stats_attr = { 177 .attr = { 178 .name = "stats", 179 .mode = S_IRUGO, 180 }, 181 .show = twa_show_stats 182 }; 183 184 /* Host attributes initializer */ 185 static struct class_device_attribute *twa_host_attrs[] = { 186 &twa_host_stats_attr, 187 NULL, 188 }; 189 190 /* File operations struct for character device */ 191 static struct file_operations twa_fops = { 192 .owner = THIS_MODULE, 193 .ioctl = twa_chrdev_ioctl, 194 .open = twa_chrdev_open, 195 .release = NULL 196 }; 197 198 /* This function will complete an aen request from the isr */ 199 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id) 200 { 201 TW_Command_Full *full_command_packet; 202 TW_Command *command_packet; 203 TW_Command_Apache_Header *header; 204 unsigned short aen; 205 int retval = 1; 206 207 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 208 tw_dev->posted_request_count--; 209 aen = header->status_block.error; 210 full_command_packet = tw_dev->command_packet_virt[request_id]; 211 command_packet = &full_command_packet->command.oldcommand; 212 213 /* First check for internal completion of set param for time sync */ 214 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) { 215 /* Keep reading the queue in case there are more aen's */ 216 if (twa_aen_read_queue(tw_dev, request_id)) 217 goto out2; 218 else { 219 retval = 0; 220 goto out; 221 } 222 } 223 224 switch (aen) { 225 case TW_AEN_QUEUE_EMPTY: 226 /* Quit reading the queue if this is the last one */ 227 break; 228 case TW_AEN_SYNC_TIME_WITH_HOST: 229 twa_aen_sync_time(tw_dev, request_id); 230 retval = 0; 231 goto out; 232 default: 233 twa_aen_queue_event(tw_dev, header); 234 235 /* If there are more aen's, keep reading the queue */ 236 if (twa_aen_read_queue(tw_dev, request_id)) 237 goto out2; 238 else { 239 retval = 0; 240 goto out; 241 } 242 } 243 retval = 0; 244 out2: 245 tw_dev->state[request_id] = TW_S_COMPLETED; 246 twa_free_request_id(tw_dev, request_id); 247 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 248 out: 249 return retval; 250 } /* End twa_aen_complete() */ 251 252 /* This function will drain aen queue */ 253 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset) 254 { 255 int request_id = 0; 256 char cdb[TW_MAX_CDB_LEN]; 257 TW_SG_Entry sglist[1]; 258 int finished = 0, count = 0; 259 TW_Command_Full *full_command_packet; 260 TW_Command_Apache_Header *header; 261 unsigned short aen; 262 int first_reset = 0, queue = 0, retval = 1; 263 264 if (no_check_reset) 265 first_reset = 0; 266 else 267 first_reset = 1; 268 269 full_command_packet = tw_dev->command_packet_virt[request_id]; 270 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 271 272 /* Initialize cdb */ 273 memset(&cdb, 0, TW_MAX_CDB_LEN); 274 cdb[0] = REQUEST_SENSE; /* opcode */ 275 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 276 277 /* Initialize sglist */ 278 memset(&sglist, 0, sizeof(TW_SG_Entry)); 279 sglist[0].length = TW_SECTOR_SIZE; 280 sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 281 282 if (sglist[0].address & TW_ALIGNMENT_9000_SGL) { 283 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain"); 284 goto out; 285 } 286 287 /* Mark internal command */ 288 tw_dev->srb[request_id] = NULL; 289 290 do { 291 /* Send command to the board */ 292 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 293 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense"); 294 goto out; 295 } 296 297 /* Now poll for completion */ 298 if (twa_poll_response(tw_dev, request_id, 30)) { 299 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue"); 300 tw_dev->posted_request_count--; 301 goto out; 302 } 303 304 tw_dev->posted_request_count--; 305 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 306 aen = header->status_block.error; 307 queue = 0; 308 count++; 309 310 switch (aen) { 311 case TW_AEN_QUEUE_EMPTY: 312 if (first_reset != 1) 313 goto out; 314 else 315 finished = 1; 316 break; 317 case TW_AEN_SOFT_RESET: 318 if (first_reset == 0) 319 first_reset = 1; 320 else 321 queue = 1; 322 break; 323 case TW_AEN_SYNC_TIME_WITH_HOST: 324 break; 325 default: 326 queue = 1; 327 } 328 329 /* Now queue an event info */ 330 if (queue) 331 twa_aen_queue_event(tw_dev, header); 332 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN)); 333 334 if (count == TW_MAX_AEN_DRAIN) 335 goto out; 336 337 retval = 0; 338 out: 339 tw_dev->state[request_id] = TW_S_INITIAL; 340 return retval; 341 } /* End twa_aen_drain_queue() */ 342 343 /* This function will queue an event */ 344 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header) 345 { 346 u32 local_time; 347 struct timeval time; 348 TW_Event *event; 349 unsigned short aen; 350 char host[16]; 351 char *error_str; 352 353 tw_dev->aen_count++; 354 355 /* Fill out event info */ 356 event = tw_dev->event_queue[tw_dev->error_index]; 357 358 /* Check for clobber */ 359 host[0] = '\0'; 360 if (tw_dev->host) { 361 sprintf(host, " scsi%d:", tw_dev->host->host_no); 362 if (event->retrieved == TW_AEN_NOT_RETRIEVED) 363 tw_dev->aen_clobber = 1; 364 } 365 366 aen = header->status_block.error; 367 memset(event, 0, sizeof(TW_Event)); 368 369 event->severity = TW_SEV_OUT(header->status_block.severity__reserved); 370 do_gettimeofday(&time); 371 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60)); 372 event->time_stamp_sec = local_time; 373 event->aen_code = aen; 374 event->retrieved = TW_AEN_NOT_RETRIEVED; 375 event->sequence_id = tw_dev->error_sequence_id; 376 tw_dev->error_sequence_id++; 377 378 /* Check for embedded error string */ 379 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]); 380 381 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0'; 382 event->parameter_len = strlen(header->err_specific_desc); 383 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len); 384 if (event->severity != TW_AEN_SEVERITY_DEBUG) 385 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n", 386 host, 387 twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)), 388 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, 389 error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str, 390 header->err_specific_desc); 391 else 392 tw_dev->aen_count--; 393 394 if ((tw_dev->error_index + 1) == TW_Q_LENGTH) 395 tw_dev->event_queue_wrapped = 1; 396 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH; 397 } /* End twa_aen_queue_event() */ 398 399 /* This function will read the aen queue from the isr */ 400 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id) 401 { 402 char cdb[TW_MAX_CDB_LEN]; 403 TW_SG_Entry sglist[1]; 404 TW_Command_Full *full_command_packet; 405 int retval = 1; 406 407 full_command_packet = tw_dev->command_packet_virt[request_id]; 408 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 409 410 /* Initialize cdb */ 411 memset(&cdb, 0, TW_MAX_CDB_LEN); 412 cdb[0] = REQUEST_SENSE; /* opcode */ 413 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 414 415 /* Initialize sglist */ 416 memset(&sglist, 0, sizeof(TW_SG_Entry)); 417 sglist[0].length = TW_SECTOR_SIZE; 418 sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 419 420 /* Mark internal command */ 421 tw_dev->srb[request_id] = NULL; 422 423 /* Now post the command packet */ 424 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 425 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue"); 426 goto out; 427 } 428 retval = 0; 429 out: 430 return retval; 431 } /* End twa_aen_read_queue() */ 432 433 /* This function will look up an AEN severity string */ 434 static char *twa_aen_severity_lookup(unsigned char severity_code) 435 { 436 char *retval = NULL; 437 438 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) || 439 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG)) 440 goto out; 441 442 retval = twa_aen_severity_table[severity_code]; 443 out: 444 return retval; 445 } /* End twa_aen_severity_lookup() */ 446 447 /* This function will sync firmware time with the host time */ 448 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id) 449 { 450 u32 schedulertime; 451 struct timeval utc; 452 TW_Command_Full *full_command_packet; 453 TW_Command *command_packet; 454 TW_Param_Apache *param; 455 u32 local_time; 456 457 /* Fill out the command packet */ 458 full_command_packet = tw_dev->command_packet_virt[request_id]; 459 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 460 command_packet = &full_command_packet->command.oldcommand; 461 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM); 462 command_packet->request_id = request_id; 463 command_packet->byte8_offset.param.sgl[0].address = tw_dev->generic_buffer_phys[request_id]; 464 command_packet->byte8_offset.param.sgl[0].length = TW_SECTOR_SIZE; 465 command_packet->size = TW_COMMAND_SIZE; 466 command_packet->byte6_offset.parameter_count = 1; 467 468 /* Setup the param */ 469 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 470 memset(param, 0, TW_SECTOR_SIZE); 471 param->table_id = TW_TIMEKEEP_TABLE | 0x8000; /* Controller time keep table */ 472 param->parameter_id = 0x3; /* SchedulerTime */ 473 param->parameter_size_bytes = 4; 474 475 /* Convert system time in UTC to local time seconds since last 476 Sunday 12:00AM */ 477 do_gettimeofday(&utc); 478 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60)); 479 schedulertime = local_time - (3 * 86400); 480 schedulertime = schedulertime % 604800; 481 482 memcpy(param->data, &schedulertime, sizeof(u32)); 483 484 /* Mark internal command */ 485 tw_dev->srb[request_id] = NULL; 486 487 /* Now post the command */ 488 twa_post_command_packet(tw_dev, request_id, 1); 489 } /* End twa_aen_sync_time() */ 490 491 /* This function will allocate memory and check if it is correctly aligned */ 492 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) 493 { 494 int i; 495 dma_addr_t dma_handle; 496 unsigned long *cpu_addr; 497 int retval = 1; 498 499 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle); 500 if (!cpu_addr) { 501 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed"); 502 goto out; 503 } 504 505 if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) { 506 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory"); 507 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle); 508 goto out; 509 } 510 511 memset(cpu_addr, 0, size*TW_Q_LENGTH); 512 513 for (i = 0; i < TW_Q_LENGTH; i++) { 514 switch(which) { 515 case 0: 516 tw_dev->command_packet_phys[i] = dma_handle+(i*size); 517 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size)); 518 break; 519 case 1: 520 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size); 521 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 522 break; 523 } 524 } 525 retval = 0; 526 out: 527 return retval; 528 } /* End twa_allocate_memory() */ 529 530 /* This function will check the status register for unexpected bits */ 531 static int twa_check_bits(u32 status_reg_value) 532 { 533 int retval = 1; 534 535 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) 536 goto out; 537 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) 538 goto out; 539 540 retval = 0; 541 out: 542 return retval; 543 } /* End twa_check_bits() */ 544 545 /* This function will check the srl and decide if we are compatible */ 546 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed) 547 { 548 int retval = 1; 549 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0; 550 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0; 551 u32 init_connect_result = 0; 552 553 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS, 554 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL, 555 TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH, 556 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl, 557 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch, 558 &fw_on_ctlr_build, &init_connect_result)) { 559 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL"); 560 goto out; 561 } 562 563 tw_dev->working_srl = fw_on_ctlr_srl; 564 tw_dev->working_branch = fw_on_ctlr_branch; 565 tw_dev->working_build = fw_on_ctlr_build; 566 567 /* Try base mode compatibility */ 568 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) { 569 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS, 570 TW_EXTENDED_INIT_CONNECT, 571 TW_BASE_FW_SRL, TW_9000_ARCH_ID, 572 TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD, 573 &fw_on_ctlr_srl, &fw_on_ctlr_arch_id, 574 &fw_on_ctlr_branch, &fw_on_ctlr_build, 575 &init_connect_result)) { 576 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL"); 577 goto out; 578 } 579 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) { 580 if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) { 581 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware"); 582 } else { 583 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver"); 584 } 585 goto out; 586 } 587 tw_dev->working_srl = TW_BASE_FW_SRL; 588 tw_dev->working_branch = TW_BASE_FW_BRANCH; 589 tw_dev->working_build = TW_BASE_FW_BUILD; 590 } 591 retval = 0; 592 out: 593 return retval; 594 } /* End twa_check_srl() */ 595 596 /* This function handles ioctl for the character device */ 597 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 598 { 599 long timeout; 600 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0; 601 dma_addr_t dma_handle; 602 int request_id = 0; 603 unsigned int sequence_id = 0; 604 unsigned char event_index, start_index; 605 TW_Ioctl_Driver_Command driver_command; 606 TW_Ioctl_Buf_Apache *tw_ioctl; 607 TW_Lock *tw_lock; 608 TW_Command_Full *full_command_packet; 609 TW_Compatibility_Info *tw_compat_info; 610 TW_Event *event; 611 struct timeval current_time; 612 u32 current_time_ms; 613 TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)]; 614 int retval = TW_IOCTL_ERROR_OS_EFAULT; 615 void __user *argp = (void __user *)arg; 616 617 /* Only let one of these through at a time */ 618 if (down_interruptible(&tw_dev->ioctl_sem)) { 619 retval = TW_IOCTL_ERROR_OS_EINTR; 620 goto out; 621 } 622 623 /* First copy down the driver command */ 624 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command))) 625 goto out2; 626 627 /* Check data buffer size */ 628 if (driver_command.buffer_length > TW_MAX_SECTORS * 512) { 629 retval = TW_IOCTL_ERROR_OS_EINVAL; 630 goto out2; 631 } 632 633 /* Hardware can only do multiple of 512 byte transfers */ 634 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511; 635 636 /* Now allocate ioctl buf memory */ 637 cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, &dma_handle, GFP_KERNEL); 638 if (!cpu_addr) { 639 retval = TW_IOCTL_ERROR_OS_ENOMEM; 640 goto out2; 641 } 642 643 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr; 644 645 /* Now copy down the entire ioctl */ 646 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1)) 647 goto out3; 648 649 /* See which ioctl we are doing */ 650 switch (cmd) { 651 case TW_IOCTL_FIRMWARE_PASS_THROUGH: 652 spin_lock_irqsave(tw_dev->host->host_lock, flags); 653 twa_get_request_id(tw_dev, &request_id); 654 655 /* Flag internal command */ 656 tw_dev->srb[request_id] = NULL; 657 658 /* Flag chrdev ioctl */ 659 tw_dev->chrdev_request_id = request_id; 660 661 full_command_packet = &tw_ioctl->firmware_command; 662 663 /* Load request id and sglist for both command types */ 664 twa_load_sgl(full_command_packet, request_id, dma_handle, data_buffer_length_adjusted); 665 666 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full)); 667 668 /* Now post the command packet to the controller */ 669 twa_post_command_packet(tw_dev, request_id, 1); 670 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 671 672 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ; 673 674 /* Now wait for command to complete */ 675 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout); 676 677 /* See if we reset while waiting for the ioctl to complete */ 678 if (test_bit(TW_IN_RESET, &tw_dev->flags)) { 679 clear_bit(TW_IN_RESET, &tw_dev->flags); 680 retval = TW_IOCTL_ERROR_OS_ERESTARTSYS; 681 goto out3; 682 } 683 684 /* We timed out, and didn't get an interrupt */ 685 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) { 686 /* Now we need to reset the board */ 687 printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n", 688 tw_dev->host->host_no, TW_DRIVER, 0xc, 689 cmd); 690 retval = TW_IOCTL_ERROR_OS_EIO; 691 spin_lock_irqsave(tw_dev->host->host_lock, flags); 692 tw_dev->state[request_id] = TW_S_COMPLETED; 693 twa_free_request_id(tw_dev, request_id); 694 tw_dev->posted_request_count--; 695 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 696 twa_reset_device_extension(tw_dev, 1); 697 goto out3; 698 } 699 700 /* Now copy in the command packet response */ 701 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full)); 702 703 /* Now complete the io */ 704 spin_lock_irqsave(tw_dev->host->host_lock, flags); 705 tw_dev->posted_request_count--; 706 tw_dev->state[request_id] = TW_S_COMPLETED; 707 twa_free_request_id(tw_dev, request_id); 708 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 709 break; 710 case TW_IOCTL_GET_COMPATIBILITY_INFO: 711 tw_ioctl->driver_command.status = 0; 712 /* Copy compatiblity struct into ioctl data buffer */ 713 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer; 714 strncpy(tw_compat_info->driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION)); 715 tw_compat_info->working_srl = tw_dev->working_srl; 716 tw_compat_info->working_branch = tw_dev->working_branch; 717 tw_compat_info->working_build = tw_dev->working_build; 718 tw_compat_info->driver_srl_high = TW_CURRENT_DRIVER_SRL; 719 tw_compat_info->driver_branch_high = TW_CURRENT_DRIVER_BRANCH; 720 tw_compat_info->driver_build_high = TW_CURRENT_DRIVER_BUILD; 721 tw_compat_info->driver_srl_low = TW_BASE_FW_SRL; 722 tw_compat_info->driver_branch_low = TW_BASE_FW_BRANCH; 723 tw_compat_info->driver_build_low = TW_BASE_FW_BUILD; 724 break; 725 case TW_IOCTL_GET_LAST_EVENT: 726 if (tw_dev->event_queue_wrapped) { 727 if (tw_dev->aen_clobber) { 728 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 729 tw_dev->aen_clobber = 0; 730 } else 731 tw_ioctl->driver_command.status = 0; 732 } else { 733 if (!tw_dev->error_index) { 734 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 735 break; 736 } 737 tw_ioctl->driver_command.status = 0; 738 } 739 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH; 740 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 741 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 742 break; 743 case TW_IOCTL_GET_FIRST_EVENT: 744 if (tw_dev->event_queue_wrapped) { 745 if (tw_dev->aen_clobber) { 746 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 747 tw_dev->aen_clobber = 0; 748 } else 749 tw_ioctl->driver_command.status = 0; 750 event_index = tw_dev->error_index; 751 } else { 752 if (!tw_dev->error_index) { 753 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 754 break; 755 } 756 tw_ioctl->driver_command.status = 0; 757 event_index = 0; 758 } 759 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 760 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 761 break; 762 case TW_IOCTL_GET_NEXT_EVENT: 763 event = (TW_Event *)tw_ioctl->data_buffer; 764 sequence_id = event->sequence_id; 765 tw_ioctl->driver_command.status = 0; 766 767 if (tw_dev->event_queue_wrapped) { 768 if (tw_dev->aen_clobber) { 769 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 770 tw_dev->aen_clobber = 0; 771 } 772 start_index = tw_dev->error_index; 773 } else { 774 if (!tw_dev->error_index) { 775 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 776 break; 777 } 778 start_index = 0; 779 } 780 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH; 781 782 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) { 783 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER) 784 tw_dev->aen_clobber = 1; 785 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 786 break; 787 } 788 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 789 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 790 break; 791 case TW_IOCTL_GET_PREVIOUS_EVENT: 792 event = (TW_Event *)tw_ioctl->data_buffer; 793 sequence_id = event->sequence_id; 794 tw_ioctl->driver_command.status = 0; 795 796 if (tw_dev->event_queue_wrapped) { 797 if (tw_dev->aen_clobber) { 798 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 799 tw_dev->aen_clobber = 0; 800 } 801 start_index = tw_dev->error_index; 802 } else { 803 if (!tw_dev->error_index) { 804 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 805 break; 806 } 807 start_index = 0; 808 } 809 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH; 810 811 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) { 812 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER) 813 tw_dev->aen_clobber = 1; 814 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 815 break; 816 } 817 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 818 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 819 break; 820 case TW_IOCTL_GET_LOCK: 821 tw_lock = (TW_Lock *)tw_ioctl->data_buffer; 822 do_gettimeofday(¤t_time); 823 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000); 824 825 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) { 826 tw_dev->ioctl_sem_lock = 1; 827 tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec; 828 tw_ioctl->driver_command.status = 0; 829 tw_lock->time_remaining_msec = tw_lock->timeout_msec; 830 } else { 831 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED; 832 tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms; 833 } 834 break; 835 case TW_IOCTL_RELEASE_LOCK: 836 if (tw_dev->ioctl_sem_lock == 1) { 837 tw_dev->ioctl_sem_lock = 0; 838 tw_ioctl->driver_command.status = 0; 839 } else { 840 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED; 841 } 842 break; 843 default: 844 retval = TW_IOCTL_ERROR_OS_ENOTTY; 845 goto out3; 846 } 847 848 /* Now copy the entire response to userspace */ 849 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0) 850 retval = 0; 851 out3: 852 /* Now free ioctl buf memory */ 853 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle); 854 out2: 855 up(&tw_dev->ioctl_sem); 856 out: 857 return retval; 858 } /* End twa_chrdev_ioctl() */ 859 860 /* This function handles open for the character device */ 861 static int twa_chrdev_open(struct inode *inode, struct file *file) 862 { 863 unsigned int minor_number; 864 int retval = TW_IOCTL_ERROR_OS_ENODEV; 865 866 minor_number = iminor(inode); 867 if (minor_number >= twa_device_extension_count) 868 goto out; 869 retval = 0; 870 out: 871 return retval; 872 } /* End twa_chrdev_open() */ 873 874 /* This function will print readable messages from status register errors */ 875 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value) 876 { 877 int retval = 1; 878 879 /* Check for various error conditions and handle them appropriately */ 880 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) { 881 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing"); 882 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 883 } 884 885 if (status_reg_value & TW_STATUS_PCI_ABORT) { 886 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing"); 887 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev)); 888 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT); 889 } 890 891 if (status_reg_value & TW_STATUS_QUEUE_ERROR) { 892 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing"); 893 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 894 } 895 896 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) { 897 if (tw_dev->reset_print == 0) { 898 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing"); 899 tw_dev->reset_print = 1; 900 } 901 goto out; 902 } 903 retval = 0; 904 out: 905 return retval; 906 } /* End twa_decode_bits() */ 907 908 /* This function will empty the response queue */ 909 static int twa_empty_response_queue(TW_Device_Extension *tw_dev) 910 { 911 u32 status_reg_value, response_que_value; 912 int count = 0, retval = 1; 913 914 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 915 916 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) { 917 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 918 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 919 count++; 920 } 921 if (count == TW_MAX_RESPONSE_DRAIN) 922 goto out; 923 924 retval = 0; 925 out: 926 return retval; 927 } /* End twa_empty_response_queue() */ 928 929 /* This function will clear the pchip/response queue on 9550SX */ 930 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev) 931 { 932 u32 status_reg_value, response_que_value; 933 int count = 0, retval = 1; 934 935 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9550SX) { 936 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 937 938 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) { 939 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev)); 940 if ((response_que_value & TW_9550SX_DRAIN_COMPLETED) == TW_9550SX_DRAIN_COMPLETED) { 941 /* P-chip settle time */ 942 msleep(500); 943 retval = 0; 944 goto out; 945 } 946 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 947 count++; 948 } 949 if (count == TW_MAX_RESPONSE_DRAIN) 950 goto out; 951 952 retval = 0; 953 } else 954 retval = 0; 955 out: 956 return retval; 957 } /* End twa_empty_response_queue_large() */ 958 959 /* This function passes sense keys from firmware to scsi layer */ 960 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host) 961 { 962 TW_Command_Full *full_command_packet; 963 unsigned short error; 964 int retval = 1; 965 char *error_str; 966 967 full_command_packet = tw_dev->command_packet_virt[request_id]; 968 969 /* Check for embedded error string */ 970 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]); 971 972 /* Don't print error for Logical unit not supported during rollcall */ 973 error = full_command_packet->header.status_block.error; 974 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) { 975 if (print_host) 976 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n", 977 tw_dev->host->host_no, 978 TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 979 full_command_packet->header.status_block.error, 980 error_str[0] == '\0' ? 981 twa_string_lookup(twa_error_table, 982 full_command_packet->header.status_block.error) : error_str, 983 full_command_packet->header.err_specific_desc); 984 else 985 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n", 986 TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 987 full_command_packet->header.status_block.error, 988 error_str[0] == '\0' ? 989 twa_string_lookup(twa_error_table, 990 full_command_packet->header.status_block.error) : error_str, 991 full_command_packet->header.err_specific_desc); 992 } 993 994 if (copy_sense) { 995 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH); 996 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1); 997 retval = TW_ISR_DONT_RESULT; 998 goto out; 999 } 1000 retval = 0; 1001 out: 1002 return retval; 1003 } /* End twa_fill_sense() */ 1004 1005 /* This function will free up device extension resources */ 1006 static void twa_free_device_extension(TW_Device_Extension *tw_dev) 1007 { 1008 if (tw_dev->command_packet_virt[0]) 1009 pci_free_consistent(tw_dev->tw_pci_dev, 1010 sizeof(TW_Command_Full)*TW_Q_LENGTH, 1011 tw_dev->command_packet_virt[0], 1012 tw_dev->command_packet_phys[0]); 1013 1014 if (tw_dev->generic_buffer_virt[0]) 1015 pci_free_consistent(tw_dev->tw_pci_dev, 1016 TW_SECTOR_SIZE*TW_Q_LENGTH, 1017 tw_dev->generic_buffer_virt[0], 1018 tw_dev->generic_buffer_phys[0]); 1019 1020 kfree(tw_dev->event_queue[0]); 1021 } /* End twa_free_device_extension() */ 1022 1023 /* This function will free a request id */ 1024 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id) 1025 { 1026 tw_dev->free_queue[tw_dev->free_tail] = request_id; 1027 tw_dev->state[request_id] = TW_S_FINISHED; 1028 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH; 1029 } /* End twa_free_request_id() */ 1030 1031 /* This function will get parameter table entires from the firmware */ 1032 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes) 1033 { 1034 TW_Command_Full *full_command_packet; 1035 TW_Command *command_packet; 1036 TW_Param_Apache *param; 1037 unsigned long param_value; 1038 void *retval = NULL; 1039 1040 /* Setup the command packet */ 1041 full_command_packet = tw_dev->command_packet_virt[request_id]; 1042 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 1043 command_packet = &full_command_packet->command.oldcommand; 1044 1045 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1046 command_packet->size = TW_COMMAND_SIZE; 1047 command_packet->request_id = request_id; 1048 command_packet->byte6_offset.block_count = 1; 1049 1050 /* Now setup the param */ 1051 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 1052 memset(param, 0, TW_SECTOR_SIZE); 1053 param->table_id = table_id | 0x8000; 1054 param->parameter_id = parameter_id; 1055 param->parameter_size_bytes = parameter_size_bytes; 1056 param_value = tw_dev->generic_buffer_phys[request_id]; 1057 1058 command_packet->byte8_offset.param.sgl[0].address = param_value; 1059 command_packet->byte8_offset.param.sgl[0].length = TW_SECTOR_SIZE; 1060 1061 /* Post the command packet to the board */ 1062 twa_post_command_packet(tw_dev, request_id, 1); 1063 1064 /* Poll for completion */ 1065 if (twa_poll_response(tw_dev, request_id, 30)) 1066 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param") 1067 else 1068 retval = (void *)&(param->data[0]); 1069 1070 tw_dev->posted_request_count--; 1071 tw_dev->state[request_id] = TW_S_INITIAL; 1072 1073 return retval; 1074 } /* End twa_get_param() */ 1075 1076 /* This function will assign an available request id */ 1077 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id) 1078 { 1079 *request_id = tw_dev->free_queue[tw_dev->free_head]; 1080 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH; 1081 tw_dev->state[*request_id] = TW_S_STARTED; 1082 } /* End twa_get_request_id() */ 1083 1084 /* This function will send an initconnection command to controller */ 1085 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits, 1086 u32 set_features, unsigned short current_fw_srl, 1087 unsigned short current_fw_arch_id, 1088 unsigned short current_fw_branch, 1089 unsigned short current_fw_build, 1090 unsigned short *fw_on_ctlr_srl, 1091 unsigned short *fw_on_ctlr_arch_id, 1092 unsigned short *fw_on_ctlr_branch, 1093 unsigned short *fw_on_ctlr_build, 1094 u32 *init_connect_result) 1095 { 1096 TW_Command_Full *full_command_packet; 1097 TW_Initconnect *tw_initconnect; 1098 int request_id = 0, retval = 1; 1099 1100 /* Initialize InitConnection command packet */ 1101 full_command_packet = tw_dev->command_packet_virt[request_id]; 1102 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 1103 full_command_packet->header.header_desc.size_header = 128; 1104 1105 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand; 1106 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION); 1107 tw_initconnect->request_id = request_id; 1108 tw_initconnect->message_credits = message_credits; 1109 tw_initconnect->features = set_features; 1110 1111 /* Turn on 64-bit sgl support if we need to */ 1112 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0; 1113 1114 if (set_features & TW_EXTENDED_INIT_CONNECT) { 1115 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED; 1116 tw_initconnect->fw_srl = current_fw_srl; 1117 tw_initconnect->fw_arch_id = current_fw_arch_id; 1118 tw_initconnect->fw_branch = current_fw_branch; 1119 tw_initconnect->fw_build = current_fw_build; 1120 } else 1121 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE; 1122 1123 /* Send command packet to the board */ 1124 twa_post_command_packet(tw_dev, request_id, 1); 1125 1126 /* Poll for completion */ 1127 if (twa_poll_response(tw_dev, request_id, 30)) { 1128 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection"); 1129 } else { 1130 if (set_features & TW_EXTENDED_INIT_CONNECT) { 1131 *fw_on_ctlr_srl = tw_initconnect->fw_srl; 1132 *fw_on_ctlr_arch_id = tw_initconnect->fw_arch_id; 1133 *fw_on_ctlr_branch = tw_initconnect->fw_branch; 1134 *fw_on_ctlr_build = tw_initconnect->fw_build; 1135 *init_connect_result = tw_initconnect->result; 1136 } 1137 retval = 0; 1138 } 1139 1140 tw_dev->posted_request_count--; 1141 tw_dev->state[request_id] = TW_S_INITIAL; 1142 1143 return retval; 1144 } /* End twa_initconnection() */ 1145 1146 /* This function will initialize the fields of a device extension */ 1147 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev) 1148 { 1149 int i, retval = 1; 1150 1151 /* Initialize command packet buffers */ 1152 if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) { 1153 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed"); 1154 goto out; 1155 } 1156 1157 /* Initialize generic buffer */ 1158 if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) { 1159 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed"); 1160 goto out; 1161 } 1162 1163 /* Allocate event info space */ 1164 tw_dev->event_queue[0] = kmalloc(sizeof(TW_Event) * TW_Q_LENGTH, GFP_KERNEL); 1165 if (!tw_dev->event_queue[0]) { 1166 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed"); 1167 goto out; 1168 } 1169 1170 memset(tw_dev->event_queue[0], 0, sizeof(TW_Event) * TW_Q_LENGTH); 1171 1172 for (i = 0; i < TW_Q_LENGTH; i++) { 1173 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event))); 1174 tw_dev->free_queue[i] = i; 1175 tw_dev->state[i] = TW_S_INITIAL; 1176 } 1177 1178 tw_dev->pending_head = TW_Q_START; 1179 tw_dev->pending_tail = TW_Q_START; 1180 tw_dev->free_head = TW_Q_START; 1181 tw_dev->free_tail = TW_Q_START; 1182 tw_dev->error_sequence_id = 1; 1183 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1184 1185 init_MUTEX(&tw_dev->ioctl_sem); 1186 init_waitqueue_head(&tw_dev->ioctl_wqueue); 1187 1188 retval = 0; 1189 out: 1190 return retval; 1191 } /* End twa_initialize_device_extension() */ 1192 1193 /* This function is the interrupt service routine */ 1194 static irqreturn_t twa_interrupt(int irq, void *dev_instance, struct pt_regs *regs) 1195 { 1196 int request_id, error = 0; 1197 u32 status_reg_value; 1198 TW_Response_Queue response_que; 1199 TW_Command_Full *full_command_packet; 1200 TW_Command *command_packet; 1201 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance; 1202 int handled = 0; 1203 1204 /* Get the per adapter lock */ 1205 spin_lock(tw_dev->host->host_lock); 1206 1207 /* Read the registers */ 1208 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 1209 1210 /* Check if this is our interrupt, otherwise bail */ 1211 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT)) 1212 goto twa_interrupt_bail; 1213 1214 handled = 1; 1215 1216 /* Check controller for errors */ 1217 if (twa_check_bits(status_reg_value)) { 1218 if (twa_decode_bits(tw_dev, status_reg_value)) { 1219 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 1220 goto twa_interrupt_bail; 1221 } 1222 } 1223 1224 /* Handle host interrupt */ 1225 if (status_reg_value & TW_STATUS_HOST_INTERRUPT) 1226 TW_CLEAR_HOST_INTERRUPT(tw_dev); 1227 1228 /* Handle attention interrupt */ 1229 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) { 1230 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 1231 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) { 1232 twa_get_request_id(tw_dev, &request_id); 1233 1234 error = twa_aen_read_queue(tw_dev, request_id); 1235 if (error) { 1236 tw_dev->state[request_id] = TW_S_COMPLETED; 1237 twa_free_request_id(tw_dev, request_id); 1238 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 1239 } 1240 } 1241 } 1242 1243 /* Handle command interrupt */ 1244 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) { 1245 TW_MASK_COMMAND_INTERRUPT(tw_dev); 1246 /* Drain as many pending commands as we can */ 1247 while (tw_dev->pending_request_count > 0) { 1248 request_id = tw_dev->pending_queue[tw_dev->pending_head]; 1249 if (tw_dev->state[request_id] != TW_S_PENDING) { 1250 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending"); 1251 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 1252 goto twa_interrupt_bail; 1253 } 1254 if (twa_post_command_packet(tw_dev, request_id, 1)==0) { 1255 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH; 1256 tw_dev->pending_request_count--; 1257 } else { 1258 /* If we get here, we will continue re-posting on the next command interrupt */ 1259 break; 1260 } 1261 } 1262 } 1263 1264 /* Handle response interrupt */ 1265 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) { 1266 1267 /* Drain the response queue from the board */ 1268 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 1269 /* Complete the response */ 1270 response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 1271 request_id = TW_RESID_OUT(response_que.response_id); 1272 full_command_packet = tw_dev->command_packet_virt[request_id]; 1273 error = 0; 1274 command_packet = &full_command_packet->command.oldcommand; 1275 /* Check for command packet errors */ 1276 if (full_command_packet->command.newcommand.status != 0) { 1277 if (tw_dev->srb[request_id] != 0) { 1278 error = twa_fill_sense(tw_dev, request_id, 1, 1); 1279 } else { 1280 /* Skip ioctl error prints */ 1281 if (request_id != tw_dev->chrdev_request_id) { 1282 error = twa_fill_sense(tw_dev, request_id, 0, 1); 1283 } 1284 } 1285 } 1286 1287 /* Check for correct state */ 1288 if (tw_dev->state[request_id] != TW_S_POSTED) { 1289 if (tw_dev->srb[request_id] != 0) { 1290 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted"); 1291 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 1292 goto twa_interrupt_bail; 1293 } 1294 } 1295 1296 /* Check for internal command completion */ 1297 if (tw_dev->srb[request_id] == 0) { 1298 if (request_id != tw_dev->chrdev_request_id) { 1299 if (twa_aen_complete(tw_dev, request_id)) 1300 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt"); 1301 } else { 1302 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1303 wake_up(&tw_dev->ioctl_wqueue); 1304 } 1305 } else { 1306 twa_scsiop_execute_scsi_complete(tw_dev, request_id); 1307 /* If no error command was a success */ 1308 if (error == 0) { 1309 tw_dev->srb[request_id]->result = (DID_OK << 16); 1310 } 1311 1312 /* If error, command failed */ 1313 if (error == 1) { 1314 /* Ask for a host reset */ 1315 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 1316 } 1317 1318 /* Report residual bytes for single sgl */ 1319 if ((tw_dev->srb[request_id]->use_sg <= 1) && (full_command_packet->command.newcommand.status == 0)) { 1320 if (full_command_packet->command.newcommand.sg_list[0].length < tw_dev->srb[request_id]->request_bufflen) 1321 tw_dev->srb[request_id]->resid = tw_dev->srb[request_id]->request_bufflen - full_command_packet->command.newcommand.sg_list[0].length; 1322 } 1323 1324 /* Now complete the io */ 1325 tw_dev->state[request_id] = TW_S_COMPLETED; 1326 twa_free_request_id(tw_dev, request_id); 1327 tw_dev->posted_request_count--; 1328 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1329 twa_unmap_scsi_data(tw_dev, request_id); 1330 } 1331 1332 /* Check for valid status after each drain */ 1333 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 1334 if (twa_check_bits(status_reg_value)) { 1335 if (twa_decode_bits(tw_dev, status_reg_value)) { 1336 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 1337 goto twa_interrupt_bail; 1338 } 1339 } 1340 } 1341 } 1342 1343 twa_interrupt_bail: 1344 spin_unlock(tw_dev->host->host_lock); 1345 return IRQ_RETVAL(handled); 1346 } /* End twa_interrupt() */ 1347 1348 /* This function will load the request id and various sgls for ioctls */ 1349 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length) 1350 { 1351 TW_Command *oldcommand; 1352 TW_Command_Apache *newcommand; 1353 TW_SG_Entry *sgl; 1354 1355 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) { 1356 newcommand = &full_command_packet->command.newcommand; 1357 newcommand->request_id__lunl = 1358 TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id); 1359 newcommand->sg_list[0].address = dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1; 1360 newcommand->sg_list[0].length = length; 1361 newcommand->sgl_entries__lunh = 1362 TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1); 1363 } else { 1364 oldcommand = &full_command_packet->command.oldcommand; 1365 oldcommand->request_id = request_id; 1366 1367 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) { 1368 /* Load the sg list */ 1369 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset)); 1370 sgl->address = dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1; 1371 sgl->length = length; 1372 1373 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4)) 1374 oldcommand->size += 1; 1375 } 1376 } 1377 } /* End twa_load_sgl() */ 1378 1379 /* This function will perform a pci-dma mapping for a scatter gather list */ 1380 static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id) 1381 { 1382 int use_sg; 1383 struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 1384 struct pci_dev *pdev = tw_dev->tw_pci_dev; 1385 int retval = 0; 1386 1387 if (cmd->use_sg == 0) 1388 goto out; 1389 1390 use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 1391 1392 if (use_sg == 0) { 1393 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list"); 1394 goto out; 1395 } 1396 1397 cmd->SCp.phase = TW_PHASE_SGLIST; 1398 cmd->SCp.have_data_in = use_sg; 1399 retval = use_sg; 1400 out: 1401 return retval; 1402 } /* End twa_map_scsi_sg_data() */ 1403 1404 /* This function will perform a pci-dma map for a single buffer */ 1405 static dma_addr_t twa_map_scsi_single_data(TW_Device_Extension *tw_dev, int request_id) 1406 { 1407 dma_addr_t mapping; 1408 struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 1409 struct pci_dev *pdev = tw_dev->tw_pci_dev; 1410 int retval = 0; 1411 1412 if (cmd->request_bufflen == 0) { 1413 retval = 0; 1414 goto out; 1415 } 1416 1417 mapping = pci_map_single(pdev, cmd->request_buffer, cmd->request_bufflen, DMA_BIDIRECTIONAL); 1418 1419 if (mapping == 0) { 1420 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Failed to map page"); 1421 goto out; 1422 } 1423 1424 cmd->SCp.phase = TW_PHASE_SINGLE; 1425 cmd->SCp.have_data_in = mapping; 1426 retval = mapping; 1427 out: 1428 return retval; 1429 } /* End twa_map_scsi_single_data() */ 1430 1431 /* This function will poll for a response interrupt of a request */ 1432 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds) 1433 { 1434 int retval = 1, found = 0, response_request_id; 1435 TW_Response_Queue response_queue; 1436 TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id]; 1437 1438 if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) { 1439 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 1440 response_request_id = TW_RESID_OUT(response_queue.response_id); 1441 if (request_id != response_request_id) { 1442 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response"); 1443 goto out; 1444 } 1445 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) { 1446 if (full_command_packet->command.newcommand.status != 0) { 1447 /* bad response */ 1448 twa_fill_sense(tw_dev, request_id, 0, 0); 1449 goto out; 1450 } 1451 found = 1; 1452 } else { 1453 if (full_command_packet->command.oldcommand.status != 0) { 1454 /* bad response */ 1455 twa_fill_sense(tw_dev, request_id, 0, 0); 1456 goto out; 1457 } 1458 found = 1; 1459 } 1460 } 1461 1462 if (found) 1463 retval = 0; 1464 out: 1465 return retval; 1466 } /* End twa_poll_response() */ 1467 1468 /* This function will poll the status register for a flag */ 1469 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds) 1470 { 1471 u32 status_reg_value; 1472 unsigned long before; 1473 int retval = 1; 1474 1475 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 1476 before = jiffies; 1477 1478 if (twa_check_bits(status_reg_value)) 1479 twa_decode_bits(tw_dev, status_reg_value); 1480 1481 while ((status_reg_value & flag) != flag) { 1482 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 1483 1484 if (twa_check_bits(status_reg_value)) 1485 twa_decode_bits(tw_dev, status_reg_value); 1486 1487 if (time_after(jiffies, before + HZ * seconds)) 1488 goto out; 1489 1490 msleep(50); 1491 } 1492 retval = 0; 1493 out: 1494 return retval; 1495 } /* End twa_poll_status() */ 1496 1497 /* This function will poll the status register for disappearance of a flag */ 1498 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds) 1499 { 1500 u32 status_reg_value; 1501 unsigned long before; 1502 int retval = 1; 1503 1504 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 1505 before = jiffies; 1506 1507 if (twa_check_bits(status_reg_value)) 1508 twa_decode_bits(tw_dev, status_reg_value); 1509 1510 while ((status_reg_value & flag) != 0) { 1511 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 1512 if (twa_check_bits(status_reg_value)) 1513 twa_decode_bits(tw_dev, status_reg_value); 1514 1515 if (time_after(jiffies, before + HZ * seconds)) 1516 goto out; 1517 1518 msleep(50); 1519 } 1520 retval = 0; 1521 out: 1522 return retval; 1523 } /* End twa_poll_status_gone() */ 1524 1525 /* This function will attempt to post a command packet to the board */ 1526 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal) 1527 { 1528 u32 status_reg_value; 1529 dma_addr_t command_que_value; 1530 int retval = 1; 1531 1532 command_que_value = tw_dev->command_packet_phys[request_id]; 1533 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 1534 1535 if (twa_check_bits(status_reg_value)) 1536 twa_decode_bits(tw_dev, status_reg_value); 1537 1538 if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) { 1539 1540 /* Only pend internal driver commands */ 1541 if (!internal) { 1542 retval = SCSI_MLQUEUE_HOST_BUSY; 1543 goto out; 1544 } 1545 1546 /* Couldn't post the command packet, so we do it later */ 1547 if (tw_dev->state[request_id] != TW_S_PENDING) { 1548 tw_dev->state[request_id] = TW_S_PENDING; 1549 tw_dev->pending_request_count++; 1550 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) { 1551 tw_dev->max_pending_request_count = tw_dev->pending_request_count; 1552 } 1553 tw_dev->pending_queue[tw_dev->pending_tail] = request_id; 1554 tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH; 1555 } 1556 TW_UNMASK_COMMAND_INTERRUPT(tw_dev); 1557 goto out; 1558 } else { 1559 /* We successfully posted the command packet */ 1560 if (sizeof(dma_addr_t) > 4) { 1561 command_que_value += TW_COMMAND_OFFSET; 1562 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 1563 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4); 1564 } else { 1565 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 1566 } 1567 tw_dev->state[request_id] = TW_S_POSTED; 1568 tw_dev->posted_request_count++; 1569 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) { 1570 tw_dev->max_posted_request_count = tw_dev->posted_request_count; 1571 } 1572 } 1573 retval = 0; 1574 out: 1575 return retval; 1576 } /* End twa_post_command_packet() */ 1577 1578 /* This function will reset a device extension */ 1579 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset) 1580 { 1581 int i = 0; 1582 int retval = 1; 1583 unsigned long flags = 0; 1584 1585 set_bit(TW_IN_RESET, &tw_dev->flags); 1586 TW_DISABLE_INTERRUPTS(tw_dev); 1587 TW_MASK_COMMAND_INTERRUPT(tw_dev); 1588 spin_lock_irqsave(tw_dev->host->host_lock, flags); 1589 1590 /* Abort all requests that are in progress */ 1591 for (i = 0; i < TW_Q_LENGTH; i++) { 1592 if ((tw_dev->state[i] != TW_S_FINISHED) && 1593 (tw_dev->state[i] != TW_S_INITIAL) && 1594 (tw_dev->state[i] != TW_S_COMPLETED)) { 1595 if (tw_dev->srb[i]) { 1596 tw_dev->srb[i]->result = (DID_RESET << 16); 1597 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]); 1598 twa_unmap_scsi_data(tw_dev, i); 1599 } 1600 } 1601 } 1602 1603 /* Reset queues and counts */ 1604 for (i = 0; i < TW_Q_LENGTH; i++) { 1605 tw_dev->free_queue[i] = i; 1606 tw_dev->state[i] = TW_S_INITIAL; 1607 } 1608 tw_dev->free_head = TW_Q_START; 1609 tw_dev->free_tail = TW_Q_START; 1610 tw_dev->posted_request_count = 0; 1611 tw_dev->pending_request_count = 0; 1612 tw_dev->pending_head = TW_Q_START; 1613 tw_dev->pending_tail = TW_Q_START; 1614 tw_dev->reset_print = 0; 1615 1616 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1617 1618 if (twa_reset_sequence(tw_dev, 1)) 1619 goto out; 1620 1621 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 1622 1623 /* Wake up any ioctl that was pending before the reset */ 1624 if ((tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE) || (ioctl_reset)) { 1625 clear_bit(TW_IN_RESET, &tw_dev->flags); 1626 } else { 1627 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1628 wake_up(&tw_dev->ioctl_wqueue); 1629 } 1630 retval = 0; 1631 out: 1632 return retval; 1633 } /* End twa_reset_device_extension() */ 1634 1635 /* This function will reset a controller */ 1636 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset) 1637 { 1638 int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset; 1639 1640 while (tries < TW_MAX_RESET_TRIES) { 1641 if (do_soft_reset) { 1642 TW_SOFT_RESET(tw_dev); 1643 /* Clear pchip/response queue on 9550SX */ 1644 if (twa_empty_response_queue_large(tw_dev)) { 1645 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence"); 1646 do_soft_reset = 1; 1647 tries++; 1648 continue; 1649 } 1650 } 1651 1652 /* Make sure controller is in a good state */ 1653 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) { 1654 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence"); 1655 do_soft_reset = 1; 1656 tries++; 1657 continue; 1658 } 1659 1660 /* Empty response queue */ 1661 if (twa_empty_response_queue(tw_dev)) { 1662 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence"); 1663 do_soft_reset = 1; 1664 tries++; 1665 continue; 1666 } 1667 1668 flashed = 0; 1669 1670 /* Check for compatibility/flash */ 1671 if (twa_check_srl(tw_dev, &flashed)) { 1672 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence"); 1673 do_soft_reset = 1; 1674 tries++; 1675 continue; 1676 } else { 1677 if (flashed) { 1678 tries++; 1679 continue; 1680 } 1681 } 1682 1683 /* Drain the AEN queue */ 1684 if (twa_aen_drain_queue(tw_dev, soft_reset)) { 1685 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence"); 1686 do_soft_reset = 1; 1687 tries++; 1688 continue; 1689 } 1690 1691 /* If we got here, controller is in a good state */ 1692 retval = 0; 1693 goto out; 1694 } 1695 out: 1696 return retval; 1697 } /* End twa_reset_sequence() */ 1698 1699 /* This funciton returns unit geometry in cylinders/heads/sectors */ 1700 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[]) 1701 { 1702 int heads, sectors, cylinders; 1703 TW_Device_Extension *tw_dev; 1704 1705 tw_dev = (TW_Device_Extension *)sdev->host->hostdata; 1706 1707 if (capacity >= 0x200000) { 1708 heads = 255; 1709 sectors = 63; 1710 cylinders = sector_div(capacity, heads * sectors); 1711 } else { 1712 heads = 64; 1713 sectors = 32; 1714 cylinders = sector_div(capacity, heads * sectors); 1715 } 1716 1717 geom[0] = heads; 1718 geom[1] = sectors; 1719 geom[2] = cylinders; 1720 1721 return 0; 1722 } /* End twa_scsi_biosparam() */ 1723 1724 /* This is the new scsi eh reset function */ 1725 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt) 1726 { 1727 TW_Device_Extension *tw_dev = NULL; 1728 int retval = FAILED; 1729 1730 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1731 1732 tw_dev->num_resets++; 1733 1734 sdev_printk(KERN_WARNING, SCpnt->device, 1735 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n", 1736 TW_DRIVER, 0x2c, SCpnt->cmnd[0]); 1737 1738 /* Now reset the card and some of the device extension data */ 1739 if (twa_reset_device_extension(tw_dev, 0)) { 1740 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset"); 1741 goto out; 1742 } 1743 1744 retval = SUCCESS; 1745 out: 1746 return retval; 1747 } /* End twa_scsi_eh_reset() */ 1748 1749 /* This is the main scsi queue function to handle scsi opcodes */ 1750 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 1751 { 1752 int request_id, retval; 1753 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1754 1755 /* Check if this FW supports luns */ 1756 if ((SCpnt->device->lun != 0) && (tw_dev->working_srl < TW_FW_SRL_LUNS_SUPPORTED)) { 1757 SCpnt->result = (DID_BAD_TARGET << 16); 1758 done(SCpnt); 1759 retval = 0; 1760 goto out; 1761 } 1762 1763 /* Save done function into scsi_cmnd struct */ 1764 SCpnt->scsi_done = done; 1765 1766 /* Get a free request id */ 1767 twa_get_request_id(tw_dev, &request_id); 1768 1769 /* Save the scsi command for use by the ISR */ 1770 tw_dev->srb[request_id] = SCpnt; 1771 1772 /* Initialize phase to zero */ 1773 SCpnt->SCp.phase = TW_PHASE_INITIAL; 1774 1775 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL); 1776 switch (retval) { 1777 case SCSI_MLQUEUE_HOST_BUSY: 1778 twa_free_request_id(tw_dev, request_id); 1779 break; 1780 case 1: 1781 tw_dev->state[request_id] = TW_S_COMPLETED; 1782 twa_free_request_id(tw_dev, request_id); 1783 SCpnt->result = (DID_ERROR << 16); 1784 done(SCpnt); 1785 retval = 0; 1786 } 1787 out: 1788 return retval; 1789 } /* End twa_scsi_queue() */ 1790 1791 /* This function hands scsi cdb's to the firmware */ 1792 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg) 1793 { 1794 TW_Command_Full *full_command_packet; 1795 TW_Command_Apache *command_packet; 1796 u32 num_sectors = 0x0; 1797 int i, sg_count; 1798 struct scsi_cmnd *srb = NULL; 1799 struct scatterlist *sglist = NULL; 1800 u32 buffaddr = 0x0; 1801 int retval = 1; 1802 1803 if (tw_dev->srb[request_id]) { 1804 if (tw_dev->srb[request_id]->request_buffer) { 1805 sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 1806 } 1807 srb = tw_dev->srb[request_id]; 1808 } 1809 1810 /* Initialize command packet */ 1811 full_command_packet = tw_dev->command_packet_virt[request_id]; 1812 full_command_packet->header.header_desc.size_header = 128; 1813 full_command_packet->header.status_block.error = 0; 1814 full_command_packet->header.status_block.severity__reserved = 0; 1815 1816 command_packet = &full_command_packet->command.newcommand; 1817 command_packet->status = 0; 1818 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI); 1819 1820 /* We forced 16 byte cdb use earlier */ 1821 if (!cdb) 1822 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN); 1823 else 1824 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN); 1825 1826 if (srb) { 1827 command_packet->unit = srb->device->id; 1828 command_packet->request_id__lunl = 1829 TW_REQ_LUN_IN(srb->device->lun, request_id); 1830 } else { 1831 command_packet->request_id__lunl = 1832 TW_REQ_LUN_IN(0, request_id); 1833 command_packet->unit = 0; 1834 } 1835 1836 command_packet->sgl_offset = 16; 1837 1838 if (!sglistarg) { 1839 /* Map sglist from scsi layer to cmd packet */ 1840 if (tw_dev->srb[request_id]->use_sg == 0) { 1841 if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH) { 1842 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id]; 1843 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH; 1844 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL) 1845 memcpy(tw_dev->generic_buffer_virt[request_id], tw_dev->srb[request_id]->request_buffer, tw_dev->srb[request_id]->request_bufflen); 1846 } else { 1847 buffaddr = twa_map_scsi_single_data(tw_dev, request_id); 1848 if (buffaddr == 0) 1849 goto out; 1850 1851 command_packet->sg_list[0].address = buffaddr; 1852 command_packet->sg_list[0].length = tw_dev->srb[request_id]->request_bufflen; 1853 } 1854 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), 1); 1855 1856 if (command_packet->sg_list[0].address & TW_ALIGNMENT_9000_SGL) { 1857 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2d, "Found unaligned address during execute scsi"); 1858 goto out; 1859 } 1860 } 1861 1862 if (tw_dev->srb[request_id]->use_sg > 0) { 1863 if ((tw_dev->srb[request_id]->use_sg == 1) && (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH)) { 1864 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL) { 1865 struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 1866 char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 1867 memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length); 1868 kunmap_atomic(buf - sg->offset, KM_IRQ0); 1869 } 1870 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id]; 1871 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH; 1872 } else { 1873 sg_count = twa_map_scsi_sg_data(tw_dev, request_id); 1874 if (sg_count == 0) 1875 goto out; 1876 1877 for (i = 0; i < sg_count; i++) { 1878 command_packet->sg_list[i].address = sg_dma_address(&sglist[i]); 1879 command_packet->sg_list[i].length = sg_dma_len(&sglist[i]); 1880 if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) { 1881 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi"); 1882 goto out; 1883 } 1884 } 1885 } 1886 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), tw_dev->srb[request_id]->use_sg); 1887 } 1888 } else { 1889 /* Internal cdb post */ 1890 for (i = 0; i < use_sg; i++) { 1891 command_packet->sg_list[i].address = sglistarg[i].address; 1892 command_packet->sg_list[i].length = sglistarg[i].length; 1893 if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) { 1894 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post"); 1895 goto out; 1896 } 1897 } 1898 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN(0, use_sg); 1899 } 1900 1901 if (srb) { 1902 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) 1903 num_sectors = (u32)srb->cmnd[4]; 1904 1905 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10) 1906 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8); 1907 } 1908 1909 /* Update sector statistic */ 1910 tw_dev->sector_count = num_sectors; 1911 if (tw_dev->sector_count > tw_dev->max_sector_count) 1912 tw_dev->max_sector_count = tw_dev->sector_count; 1913 1914 /* Update SG statistics */ 1915 if (srb) { 1916 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg; 1917 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries) 1918 tw_dev->max_sgl_entries = tw_dev->sgl_entries; 1919 } 1920 1921 /* Now post the command to the board */ 1922 if (srb) { 1923 retval = twa_post_command_packet(tw_dev, request_id, 0); 1924 } else { 1925 twa_post_command_packet(tw_dev, request_id, 1); 1926 retval = 0; 1927 } 1928 out: 1929 return retval; 1930 } /* End twa_scsiop_execute_scsi() */ 1931 1932 /* This function completes an execute scsi operation */ 1933 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id) 1934 { 1935 if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH && 1936 (tw_dev->srb[request_id]->sc_data_direction == DMA_FROM_DEVICE || 1937 tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)) { 1938 if (tw_dev->srb[request_id]->use_sg == 0) { 1939 memcpy(tw_dev->srb[request_id]->request_buffer, 1940 tw_dev->generic_buffer_virt[request_id], 1941 tw_dev->srb[request_id]->request_bufflen); 1942 } 1943 if (tw_dev->srb[request_id]->use_sg == 1) { 1944 struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 1945 char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 1946 memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length); 1947 kunmap_atomic(buf - sg->offset, KM_IRQ0); 1948 } 1949 } 1950 } /* End twa_scsiop_execute_scsi_complete() */ 1951 1952 /* This function tells the controller to shut down */ 1953 static void __twa_shutdown(TW_Device_Extension *tw_dev) 1954 { 1955 /* Disable interrupts */ 1956 TW_DISABLE_INTERRUPTS(tw_dev); 1957 1958 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no); 1959 1960 /* Tell the card we are shutting down */ 1961 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) { 1962 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed"); 1963 } else { 1964 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n"); 1965 } 1966 1967 /* Clear all interrupts just before exit */ 1968 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 1969 } /* End __twa_shutdown() */ 1970 1971 /* Wrapper for __twa_shutdown */ 1972 static void twa_shutdown(struct pci_dev *pdev) 1973 { 1974 struct Scsi_Host *host = pci_get_drvdata(pdev); 1975 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 1976 1977 __twa_shutdown(tw_dev); 1978 } /* End twa_shutdown() */ 1979 1980 /* This function will look up a string */ 1981 static char *twa_string_lookup(twa_message_type *table, unsigned int code) 1982 { 1983 int index; 1984 1985 for (index = 0; ((code != table[index].code) && 1986 (table[index].text != (char *)0)); index++); 1987 return(table[index].text); 1988 } /* End twa_string_lookup() */ 1989 1990 /* This function will perform a pci-dma unmap */ 1991 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id) 1992 { 1993 struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 1994 struct pci_dev *pdev = tw_dev->tw_pci_dev; 1995 1996 switch(cmd->SCp.phase) { 1997 case TW_PHASE_SINGLE: 1998 pci_unmap_single(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL); 1999 break; 2000 case TW_PHASE_SGLIST: 2001 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 2002 break; 2003 } 2004 } /* End twa_unmap_scsi_data() */ 2005 2006 /* scsi_host_template initializer */ 2007 static struct scsi_host_template driver_template = { 2008 .module = THIS_MODULE, 2009 .name = "3ware 9000 Storage Controller", 2010 .queuecommand = twa_scsi_queue, 2011 .eh_host_reset_handler = twa_scsi_eh_reset, 2012 .bios_param = twa_scsi_biosparam, 2013 .change_queue_depth = twa_change_queue_depth, 2014 .can_queue = TW_Q_LENGTH-2, 2015 .this_id = -1, 2016 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH, 2017 .max_sectors = TW_MAX_SECTORS, 2018 .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 2019 .use_clustering = ENABLE_CLUSTERING, 2020 .shost_attrs = twa_host_attrs, 2021 .emulated = 1 2022 }; 2023 2024 /* This function will probe and initialize a card */ 2025 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 2026 { 2027 struct Scsi_Host *host = NULL; 2028 TW_Device_Extension *tw_dev; 2029 u32 mem_addr; 2030 int retval = -ENODEV; 2031 2032 retval = pci_enable_device(pdev); 2033 if (retval) { 2034 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device"); 2035 goto out_disable_device; 2036 } 2037 2038 pci_set_master(pdev); 2039 2040 retval = pci_set_dma_mask(pdev, sizeof(dma_addr_t) > 4 ? DMA_64BIT_MASK : DMA_32BIT_MASK); 2041 if (retval) { 2042 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask"); 2043 goto out_disable_device; 2044 } 2045 2046 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension)); 2047 if (!host) { 2048 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension"); 2049 retval = -ENOMEM; 2050 goto out_disable_device; 2051 } 2052 tw_dev = (TW_Device_Extension *)host->hostdata; 2053 2054 memset(tw_dev, 0, sizeof(TW_Device_Extension)); 2055 2056 /* Save values to device extension */ 2057 tw_dev->host = host; 2058 tw_dev->tw_pci_dev = pdev; 2059 2060 if (twa_initialize_device_extension(tw_dev)) { 2061 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension"); 2062 goto out_free_device_extension; 2063 } 2064 2065 /* Request IO regions */ 2066 retval = pci_request_regions(pdev, "3w-9xxx"); 2067 if (retval) { 2068 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region"); 2069 goto out_free_device_extension; 2070 } 2071 2072 if (pdev->device == PCI_DEVICE_ID_3WARE_9000) 2073 mem_addr = pci_resource_start(pdev, 1); 2074 else 2075 mem_addr = pci_resource_start(pdev, 2); 2076 2077 /* Save base address */ 2078 tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE); 2079 if (!tw_dev->base_addr) { 2080 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap"); 2081 goto out_release_mem_region; 2082 } 2083 2084 /* Disable interrupts on the card */ 2085 TW_DISABLE_INTERRUPTS(tw_dev); 2086 2087 /* Initialize the card */ 2088 if (twa_reset_sequence(tw_dev, 0)) 2089 goto out_release_mem_region; 2090 2091 /* Set host specific parameters */ 2092 host->max_id = TW_MAX_UNITS; 2093 host->max_cmd_len = TW_MAX_CDB_LEN; 2094 2095 /* Channels aren't supported by adapter */ 2096 host->max_lun = TW_MAX_LUNS(tw_dev->working_srl); 2097 host->max_channel = 0; 2098 2099 /* Register the card with the kernel SCSI layer */ 2100 retval = scsi_add_host(host, &pdev->dev); 2101 if (retval) { 2102 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed"); 2103 goto out_release_mem_region; 2104 } 2105 2106 pci_set_drvdata(pdev, host); 2107 2108 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n", 2109 host->host_no, mem_addr, pdev->irq); 2110 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n", 2111 host->host_no, 2112 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE, 2113 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH), 2114 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE, 2115 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH), 2116 *(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE, 2117 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)); 2118 2119 /* Now setup the interrupt handler */ 2120 retval = request_irq(pdev->irq, twa_interrupt, SA_SHIRQ, "3w-9xxx", tw_dev); 2121 if (retval) { 2122 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ"); 2123 goto out_remove_host; 2124 } 2125 2126 twa_device_extension_list[twa_device_extension_count] = tw_dev; 2127 twa_device_extension_count++; 2128 2129 /* Re-enable interrupts on the card */ 2130 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 2131 2132 /* Finally, scan the host */ 2133 scsi_scan_host(host); 2134 2135 if (twa_major == -1) { 2136 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0) 2137 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device"); 2138 } 2139 return 0; 2140 2141 out_remove_host: 2142 scsi_remove_host(host); 2143 out_release_mem_region: 2144 pci_release_regions(pdev); 2145 out_free_device_extension: 2146 twa_free_device_extension(tw_dev); 2147 scsi_host_put(host); 2148 out_disable_device: 2149 pci_disable_device(pdev); 2150 2151 return retval; 2152 } /* End twa_probe() */ 2153 2154 /* This function is called to remove a device */ 2155 static void twa_remove(struct pci_dev *pdev) 2156 { 2157 struct Scsi_Host *host = pci_get_drvdata(pdev); 2158 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 2159 2160 scsi_remove_host(tw_dev->host); 2161 2162 /* Unregister character device */ 2163 if (twa_major >= 0) { 2164 unregister_chrdev(twa_major, "twa"); 2165 twa_major = -1; 2166 } 2167 2168 /* Free up the IRQ */ 2169 free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 2170 2171 /* Shutdown the card */ 2172 __twa_shutdown(tw_dev); 2173 2174 /* Free up the mem region */ 2175 pci_release_regions(pdev); 2176 2177 /* Free up device extension resources */ 2178 twa_free_device_extension(tw_dev); 2179 2180 scsi_host_put(tw_dev->host); 2181 pci_disable_device(pdev); 2182 twa_device_extension_count--; 2183 } /* End twa_remove() */ 2184 2185 /* PCI Devices supported by this driver */ 2186 static struct pci_device_id twa_pci_tbl[] __devinitdata = { 2187 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000, 2188 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2189 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX, 2190 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2191 { } 2192 }; 2193 MODULE_DEVICE_TABLE(pci, twa_pci_tbl); 2194 2195 /* pci_driver initializer */ 2196 static struct pci_driver twa_driver = { 2197 .name = "3w-9xxx", 2198 .id_table = twa_pci_tbl, 2199 .probe = twa_probe, 2200 .remove = twa_remove, 2201 .shutdown = twa_shutdown 2202 }; 2203 2204 /* This function is called on driver initialization */ 2205 static int __init twa_init(void) 2206 { 2207 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION); 2208 2209 return pci_module_init(&twa_driver); 2210 } /* End twa_init() */ 2211 2212 /* This function is called on driver exit */ 2213 static void __exit twa_exit(void) 2214 { 2215 pci_unregister_driver(&twa_driver); 2216 } /* End twa_exit() */ 2217 2218 module_init(twa_init); 2219 module_exit(twa_exit); 2220 2221