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