1 /* 2 3w-sas.c -- LSI 3ware SAS/SATA-RAID Controller device driver for Linux. 3 4 Written By: Adam Radford <linuxraid@lsi.com> 5 6 Copyright (C) 2009 LSI 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 Controllers supported by this driver: 42 43 LSI 3ware 9750 6Gb/s SAS/SATA-RAID 44 45 Bugs/Comments/Suggestions should be mailed to: 46 linuxraid@lsi.com 47 48 For more information, goto: 49 http://www.lsi.com 50 51 History 52 ------- 53 3.26.02.000 - Initial driver release. 54 */ 55 56 #include <linux/module.h> 57 #include <linux/reboot.h> 58 #include <linux/spinlock.h> 59 #include <linux/interrupt.h> 60 #include <linux/moduleparam.h> 61 #include <linux/errno.h> 62 #include <linux/types.h> 63 #include <linux/delay.h> 64 #include <linux/pci.h> 65 #include <linux/time.h> 66 #include <linux/mutex.h> 67 #include <linux/slab.h> 68 #include <asm/io.h> 69 #include <asm/irq.h> 70 #include <asm/uaccess.h> 71 #include <scsi/scsi.h> 72 #include <scsi/scsi_host.h> 73 #include <scsi/scsi_tcq.h> 74 #include <scsi/scsi_cmnd.h> 75 #include "3w-sas.h" 76 77 /* Globals */ 78 #define TW_DRIVER_VERSION "3.26.02.000" 79 static DEFINE_MUTEX(twl_chrdev_mutex); 80 static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT]; 81 static unsigned int twl_device_extension_count; 82 static int twl_major = -1; 83 extern struct timezone sys_tz; 84 85 /* Module parameters */ 86 MODULE_AUTHOR ("LSI"); 87 MODULE_DESCRIPTION ("LSI 3ware SAS/SATA-RAID Linux Driver"); 88 MODULE_LICENSE("GPL"); 89 MODULE_VERSION(TW_DRIVER_VERSION); 90 91 static int use_msi; 92 module_param(use_msi, int, S_IRUGO); 93 MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0"); 94 95 /* Function prototypes */ 96 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset); 97 98 /* Functions */ 99 100 /* This function returns AENs through sysfs */ 101 static ssize_t twl_sysfs_aen_read(struct file *filp, struct kobject *kobj, 102 struct bin_attribute *bin_attr, 103 char *outbuf, loff_t offset, size_t count) 104 { 105 struct device *dev = container_of(kobj, struct device, kobj); 106 struct Scsi_Host *shost = class_to_shost(dev); 107 TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata; 108 unsigned long flags = 0; 109 ssize_t ret; 110 111 if (!capable(CAP_SYS_ADMIN)) 112 return -EACCES; 113 114 spin_lock_irqsave(tw_dev->host->host_lock, flags); 115 ret = memory_read_from_buffer(outbuf, count, &offset, tw_dev->event_queue[0], sizeof(TW_Event) * TW_Q_LENGTH); 116 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 117 118 return ret; 119 } /* End twl_sysfs_aen_read() */ 120 121 /* aen_read sysfs attribute initializer */ 122 static struct bin_attribute twl_sysfs_aen_read_attr = { 123 .attr = { 124 .name = "3ware_aen_read", 125 .mode = S_IRUSR, 126 }, 127 .size = 0, 128 .read = twl_sysfs_aen_read 129 }; 130 131 /* This function returns driver compatibility info through sysfs */ 132 static ssize_t twl_sysfs_compat_info(struct file *filp, struct kobject *kobj, 133 struct bin_attribute *bin_attr, 134 char *outbuf, loff_t offset, size_t count) 135 { 136 struct device *dev = container_of(kobj, struct device, kobj); 137 struct Scsi_Host *shost = class_to_shost(dev); 138 TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata; 139 unsigned long flags = 0; 140 ssize_t ret; 141 142 if (!capable(CAP_SYS_ADMIN)) 143 return -EACCES; 144 145 spin_lock_irqsave(tw_dev->host->host_lock, flags); 146 ret = memory_read_from_buffer(outbuf, count, &offset, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info)); 147 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 148 149 return ret; 150 } /* End twl_sysfs_compat_info() */ 151 152 /* compat_info sysfs attribute initializer */ 153 static struct bin_attribute twl_sysfs_compat_info_attr = { 154 .attr = { 155 .name = "3ware_compat_info", 156 .mode = S_IRUSR, 157 }, 158 .size = 0, 159 .read = twl_sysfs_compat_info 160 }; 161 162 /* Show some statistics about the card */ 163 static ssize_t twl_show_stats(struct device *dev, 164 struct device_attribute *attr, char *buf) 165 { 166 struct Scsi_Host *host = class_to_shost(dev); 167 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 168 unsigned long flags = 0; 169 ssize_t len; 170 171 spin_lock_irqsave(tw_dev->host->host_lock, flags); 172 len = snprintf(buf, PAGE_SIZE, "3w-sas Driver version: %s\n" 173 "Current commands posted: %4d\n" 174 "Max commands posted: %4d\n" 175 "Last sgl length: %4d\n" 176 "Max sgl length: %4d\n" 177 "Last sector count: %4d\n" 178 "Max sector count: %4d\n" 179 "SCSI Host Resets: %4d\n" 180 "AEN's: %4d\n", 181 TW_DRIVER_VERSION, 182 tw_dev->posted_request_count, 183 tw_dev->max_posted_request_count, 184 tw_dev->sgl_entries, 185 tw_dev->max_sgl_entries, 186 tw_dev->sector_count, 187 tw_dev->max_sector_count, 188 tw_dev->num_resets, 189 tw_dev->aen_count); 190 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 191 return len; 192 } /* End twl_show_stats() */ 193 194 /* This function will set a devices queue depth */ 195 static int twl_change_queue_depth(struct scsi_device *sdev, int queue_depth, 196 int reason) 197 { 198 if (reason != SCSI_QDEPTH_DEFAULT) 199 return -EOPNOTSUPP; 200 201 if (queue_depth > TW_Q_LENGTH-2) 202 queue_depth = TW_Q_LENGTH-2; 203 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth); 204 return queue_depth; 205 } /* End twl_change_queue_depth() */ 206 207 /* stats sysfs attribute initializer */ 208 static struct device_attribute twl_host_stats_attr = { 209 .attr = { 210 .name = "3ware_stats", 211 .mode = S_IRUGO, 212 }, 213 .show = twl_show_stats 214 }; 215 216 /* Host attributes initializer */ 217 static struct device_attribute *twl_host_attrs[] = { 218 &twl_host_stats_attr, 219 NULL, 220 }; 221 222 /* This function will look up an AEN severity string */ 223 static char *twl_aen_severity_lookup(unsigned char severity_code) 224 { 225 char *retval = NULL; 226 227 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) || 228 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG)) 229 goto out; 230 231 retval = twl_aen_severity_table[severity_code]; 232 out: 233 return retval; 234 } /* End twl_aen_severity_lookup() */ 235 236 /* This function will queue an event */ 237 static void twl_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header) 238 { 239 u32 local_time; 240 struct timeval time; 241 TW_Event *event; 242 unsigned short aen; 243 char host[16]; 244 char *error_str; 245 246 tw_dev->aen_count++; 247 248 /* Fill out event info */ 249 event = tw_dev->event_queue[tw_dev->error_index]; 250 251 host[0] = '\0'; 252 if (tw_dev->host) 253 sprintf(host, " scsi%d:", tw_dev->host->host_no); 254 255 aen = le16_to_cpu(header->status_block.error); 256 memset(event, 0, sizeof(TW_Event)); 257 258 event->severity = TW_SEV_OUT(header->status_block.severity__reserved); 259 do_gettimeofday(&time); 260 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60)); 261 event->time_stamp_sec = local_time; 262 event->aen_code = aen; 263 event->retrieved = TW_AEN_NOT_RETRIEVED; 264 event->sequence_id = tw_dev->error_sequence_id; 265 tw_dev->error_sequence_id++; 266 267 /* Check for embedded error string */ 268 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]); 269 270 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0'; 271 event->parameter_len = strlen(header->err_specific_desc); 272 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + 1 + strlen(error_str)); 273 if (event->severity != TW_AEN_SEVERITY_DEBUG) 274 printk(KERN_WARNING "3w-sas:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n", 275 host, 276 twl_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)), 277 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, error_str, 278 header->err_specific_desc); 279 else 280 tw_dev->aen_count--; 281 282 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH; 283 } /* End twl_aen_queue_event() */ 284 285 /* This function will attempt to post a command packet to the board */ 286 static int twl_post_command_packet(TW_Device_Extension *tw_dev, int request_id) 287 { 288 dma_addr_t command_que_value; 289 290 command_que_value = tw_dev->command_packet_phys[request_id]; 291 command_que_value += TW_COMMAND_OFFSET; 292 293 /* First write upper 4 bytes */ 294 writel((u32)((u64)command_que_value >> 32), TWL_HIBQPH_REG_ADDR(tw_dev)); 295 /* Then the lower 4 bytes */ 296 writel((u32)(command_que_value | TWL_PULL_MODE), TWL_HIBQPL_REG_ADDR(tw_dev)); 297 298 tw_dev->state[request_id] = TW_S_POSTED; 299 tw_dev->posted_request_count++; 300 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) 301 tw_dev->max_posted_request_count = tw_dev->posted_request_count; 302 303 return 0; 304 } /* End twl_post_command_packet() */ 305 306 /* This function will perform a pci-dma mapping for a scatter gather list */ 307 static int twl_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id) 308 { 309 int use_sg; 310 struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 311 312 use_sg = scsi_dma_map(cmd); 313 if (!use_sg) 314 return 0; 315 else if (use_sg < 0) { 316 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Failed to map scatter gather list"); 317 return 0; 318 } 319 320 cmd->SCp.phase = TW_PHASE_SGLIST; 321 cmd->SCp.have_data_in = use_sg; 322 323 return use_sg; 324 } /* End twl_map_scsi_sg_data() */ 325 326 /* This function hands scsi cdb's to the firmware */ 327 static int twl_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry_ISO *sglistarg) 328 { 329 TW_Command_Full *full_command_packet; 330 TW_Command_Apache *command_packet; 331 int i, sg_count; 332 struct scsi_cmnd *srb = NULL; 333 struct scatterlist *sglist = NULL, *sg; 334 int retval = 1; 335 336 if (tw_dev->srb[request_id]) { 337 srb = tw_dev->srb[request_id]; 338 if (scsi_sglist(srb)) 339 sglist = scsi_sglist(srb); 340 } 341 342 /* Initialize command packet */ 343 full_command_packet = tw_dev->command_packet_virt[request_id]; 344 full_command_packet->header.header_desc.size_header = 128; 345 full_command_packet->header.status_block.error = 0; 346 full_command_packet->header.status_block.severity__reserved = 0; 347 348 command_packet = &full_command_packet->command.newcommand; 349 command_packet->status = 0; 350 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI); 351 352 /* We forced 16 byte cdb use earlier */ 353 if (!cdb) 354 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN); 355 else 356 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN); 357 358 if (srb) { 359 command_packet->unit = srb->device->id; 360 command_packet->request_id__lunl = 361 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id)); 362 } else { 363 command_packet->request_id__lunl = 364 cpu_to_le16(TW_REQ_LUN_IN(0, request_id)); 365 command_packet->unit = 0; 366 } 367 368 command_packet->sgl_offset = 16; 369 370 if (!sglistarg) { 371 /* Map sglist from scsi layer to cmd packet */ 372 if (scsi_sg_count(srb)) { 373 sg_count = twl_map_scsi_sg_data(tw_dev, request_id); 374 if (sg_count == 0) 375 goto out; 376 377 scsi_for_each_sg(srb, sg, sg_count, i) { 378 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg)); 379 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg)); 380 } 381 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id]))); 382 } 383 } else { 384 /* Internal cdb post */ 385 for (i = 0; i < use_sg; i++) { 386 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address); 387 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sglistarg[i].length); 388 } 389 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg)); 390 } 391 392 /* Update some stats */ 393 if (srb) { 394 tw_dev->sector_count = scsi_bufflen(srb) / 512; 395 if (tw_dev->sector_count > tw_dev->max_sector_count) 396 tw_dev->max_sector_count = tw_dev->sector_count; 397 tw_dev->sgl_entries = scsi_sg_count(srb); 398 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries) 399 tw_dev->max_sgl_entries = tw_dev->sgl_entries; 400 } 401 402 /* Now post the command to the board */ 403 retval = twl_post_command_packet(tw_dev, request_id); 404 405 out: 406 return retval; 407 } /* End twl_scsiop_execute_scsi() */ 408 409 /* This function will read the aen queue from the isr */ 410 static int twl_aen_read_queue(TW_Device_Extension *tw_dev, int request_id) 411 { 412 char cdb[TW_MAX_CDB_LEN]; 413 TW_SG_Entry_ISO sglist[1]; 414 TW_Command_Full *full_command_packet; 415 int retval = 1; 416 417 full_command_packet = tw_dev->command_packet_virt[request_id]; 418 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 419 420 /* Initialize cdb */ 421 memset(&cdb, 0, TW_MAX_CDB_LEN); 422 cdb[0] = REQUEST_SENSE; /* opcode */ 423 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 424 425 /* Initialize sglist */ 426 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO)); 427 sglist[0].length = TW_SECTOR_SIZE; 428 sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 429 430 /* Mark internal command */ 431 tw_dev->srb[request_id] = NULL; 432 433 /* Now post the command packet */ 434 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 435 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Post failed while reading AEN queue"); 436 goto out; 437 } 438 retval = 0; 439 out: 440 return retval; 441 } /* End twl_aen_read_queue() */ 442 443 /* This function will sync firmware time with the host time */ 444 static void twl_aen_sync_time(TW_Device_Extension *tw_dev, int request_id) 445 { 446 u32 schedulertime; 447 struct timeval utc; 448 TW_Command_Full *full_command_packet; 449 TW_Command *command_packet; 450 TW_Param_Apache *param; 451 u32 local_time; 452 453 /* Fill out the command packet */ 454 full_command_packet = tw_dev->command_packet_virt[request_id]; 455 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 456 command_packet = &full_command_packet->command.oldcommand; 457 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM); 458 command_packet->request_id = request_id; 459 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]); 460 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE); 461 command_packet->size = TW_COMMAND_SIZE; 462 command_packet->byte6_offset.parameter_count = cpu_to_le16(1); 463 464 /* Setup the param */ 465 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 466 memset(param, 0, TW_SECTOR_SIZE); 467 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */ 468 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */ 469 param->parameter_size_bytes = cpu_to_le16(4); 470 471 /* Convert system time in UTC to local time seconds since last 472 Sunday 12:00AM */ 473 do_gettimeofday(&utc); 474 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60)); 475 schedulertime = local_time - (3 * 86400); 476 schedulertime = cpu_to_le32(schedulertime % 604800); 477 478 memcpy(param->data, &schedulertime, sizeof(u32)); 479 480 /* Mark internal command */ 481 tw_dev->srb[request_id] = NULL; 482 483 /* Now post the command */ 484 twl_post_command_packet(tw_dev, request_id); 485 } /* End twl_aen_sync_time() */ 486 487 /* This function will assign an available request id */ 488 static void twl_get_request_id(TW_Device_Extension *tw_dev, int *request_id) 489 { 490 *request_id = tw_dev->free_queue[tw_dev->free_head]; 491 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH; 492 tw_dev->state[*request_id] = TW_S_STARTED; 493 } /* End twl_get_request_id() */ 494 495 /* This function will free a request id */ 496 static void twl_free_request_id(TW_Device_Extension *tw_dev, int request_id) 497 { 498 tw_dev->free_queue[tw_dev->free_tail] = request_id; 499 tw_dev->state[request_id] = TW_S_FINISHED; 500 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH; 501 } /* End twl_free_request_id() */ 502 503 /* This function will complete an aen request from the isr */ 504 static int twl_aen_complete(TW_Device_Extension *tw_dev, int request_id) 505 { 506 TW_Command_Full *full_command_packet; 507 TW_Command *command_packet; 508 TW_Command_Apache_Header *header; 509 unsigned short aen; 510 int retval = 1; 511 512 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 513 tw_dev->posted_request_count--; 514 aen = le16_to_cpu(header->status_block.error); 515 full_command_packet = tw_dev->command_packet_virt[request_id]; 516 command_packet = &full_command_packet->command.oldcommand; 517 518 /* First check for internal completion of set param for time sync */ 519 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) { 520 /* Keep reading the queue in case there are more aen's */ 521 if (twl_aen_read_queue(tw_dev, request_id)) 522 goto out2; 523 else { 524 retval = 0; 525 goto out; 526 } 527 } 528 529 switch (aen) { 530 case TW_AEN_QUEUE_EMPTY: 531 /* Quit reading the queue if this is the last one */ 532 break; 533 case TW_AEN_SYNC_TIME_WITH_HOST: 534 twl_aen_sync_time(tw_dev, request_id); 535 retval = 0; 536 goto out; 537 default: 538 twl_aen_queue_event(tw_dev, header); 539 540 /* If there are more aen's, keep reading the queue */ 541 if (twl_aen_read_queue(tw_dev, request_id)) 542 goto out2; 543 else { 544 retval = 0; 545 goto out; 546 } 547 } 548 retval = 0; 549 out2: 550 tw_dev->state[request_id] = TW_S_COMPLETED; 551 twl_free_request_id(tw_dev, request_id); 552 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 553 out: 554 return retval; 555 } /* End twl_aen_complete() */ 556 557 /* This function will poll for a response */ 558 static int twl_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds) 559 { 560 unsigned long before; 561 dma_addr_t mfa; 562 u32 regh, regl; 563 u32 response; 564 int retval = 1; 565 int found = 0; 566 567 before = jiffies; 568 569 while (!found) { 570 if (sizeof(dma_addr_t) > 4) { 571 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev)); 572 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev)); 573 mfa = ((u64)regh << 32) | regl; 574 } else 575 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev)); 576 577 response = (u32)mfa; 578 579 if (TW_RESID_OUT(response) == request_id) 580 found = 1; 581 582 if (time_after(jiffies, before + HZ * seconds)) 583 goto out; 584 585 msleep(50); 586 } 587 retval = 0; 588 out: 589 return retval; 590 } /* End twl_poll_response() */ 591 592 /* This function will drain the aen queue */ 593 static int twl_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset) 594 { 595 int request_id = 0; 596 char cdb[TW_MAX_CDB_LEN]; 597 TW_SG_Entry_ISO sglist[1]; 598 int finished = 0, count = 0; 599 TW_Command_Full *full_command_packet; 600 TW_Command_Apache_Header *header; 601 unsigned short aen; 602 int first_reset = 0, queue = 0, retval = 1; 603 604 if (no_check_reset) 605 first_reset = 0; 606 else 607 first_reset = 1; 608 609 full_command_packet = tw_dev->command_packet_virt[request_id]; 610 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 611 612 /* Initialize cdb */ 613 memset(&cdb, 0, TW_MAX_CDB_LEN); 614 cdb[0] = REQUEST_SENSE; /* opcode */ 615 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 616 617 /* Initialize sglist */ 618 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO)); 619 sglist[0].length = TW_SECTOR_SIZE; 620 sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 621 622 /* Mark internal command */ 623 tw_dev->srb[request_id] = NULL; 624 625 do { 626 /* Send command to the board */ 627 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 628 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "Error posting request sense"); 629 goto out; 630 } 631 632 /* Now poll for completion */ 633 if (twl_poll_response(tw_dev, request_id, 30)) { 634 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "No valid response while draining AEN queue"); 635 tw_dev->posted_request_count--; 636 goto out; 637 } 638 639 tw_dev->posted_request_count--; 640 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 641 aen = le16_to_cpu(header->status_block.error); 642 queue = 0; 643 count++; 644 645 switch (aen) { 646 case TW_AEN_QUEUE_EMPTY: 647 if (first_reset != 1) 648 goto out; 649 else 650 finished = 1; 651 break; 652 case TW_AEN_SOFT_RESET: 653 if (first_reset == 0) 654 first_reset = 1; 655 else 656 queue = 1; 657 break; 658 case TW_AEN_SYNC_TIME_WITH_HOST: 659 break; 660 default: 661 queue = 1; 662 } 663 664 /* Now queue an event info */ 665 if (queue) 666 twl_aen_queue_event(tw_dev, header); 667 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN)); 668 669 if (count == TW_MAX_AEN_DRAIN) 670 goto out; 671 672 retval = 0; 673 out: 674 tw_dev->state[request_id] = TW_S_INITIAL; 675 return retval; 676 } /* End twl_aen_drain_queue() */ 677 678 /* This function will allocate memory and check if it is correctly aligned */ 679 static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) 680 { 681 int i; 682 dma_addr_t dma_handle; 683 unsigned long *cpu_addr; 684 int retval = 1; 685 686 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle); 687 if (!cpu_addr) { 688 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed"); 689 goto out; 690 } 691 692 memset(cpu_addr, 0, size*TW_Q_LENGTH); 693 694 for (i = 0; i < TW_Q_LENGTH; i++) { 695 switch(which) { 696 case 0: 697 tw_dev->command_packet_phys[i] = dma_handle+(i*size); 698 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size)); 699 break; 700 case 1: 701 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size); 702 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 703 break; 704 case 2: 705 tw_dev->sense_buffer_phys[i] = dma_handle+(i*size); 706 tw_dev->sense_buffer_virt[i] = (TW_Command_Apache_Header *)((unsigned char *)cpu_addr + (i*size)); 707 break; 708 } 709 } 710 retval = 0; 711 out: 712 return retval; 713 } /* End twl_allocate_memory() */ 714 715 /* This function will load the request id and various sgls for ioctls */ 716 static void twl_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length) 717 { 718 TW_Command *oldcommand; 719 TW_Command_Apache *newcommand; 720 TW_SG_Entry_ISO *sgl; 721 unsigned int pae = 0; 722 723 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4)) 724 pae = 1; 725 726 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) { 727 newcommand = &full_command_packet->command.newcommand; 728 newcommand->request_id__lunl = 729 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id)); 730 if (length) { 731 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1); 732 newcommand->sg_list[0].length = TW_CPU_TO_SGL(length); 733 } 734 newcommand->sgl_entries__lunh = 735 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0)); 736 } else { 737 oldcommand = &full_command_packet->command.oldcommand; 738 oldcommand->request_id = request_id; 739 740 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) { 741 /* Load the sg list */ 742 sgl = (TW_SG_Entry_ISO *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry_ISO)/4) + pae + (sizeof(dma_addr_t) > 4 ? 1 : 0)); 743 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1); 744 sgl->length = TW_CPU_TO_SGL(length); 745 oldcommand->size += pae; 746 oldcommand->size += sizeof(dma_addr_t) > 4 ? 1 : 0; 747 } 748 } 749 } /* End twl_load_sgl() */ 750 751 /* This function handles ioctl for the character device 752 This interface is used by smartmontools open source software */ 753 static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 754 { 755 long timeout; 756 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0; 757 dma_addr_t dma_handle; 758 int request_id = 0; 759 TW_Ioctl_Driver_Command driver_command; 760 struct inode *inode = file->f_dentry->d_inode; 761 TW_Ioctl_Buf_Apache *tw_ioctl; 762 TW_Command_Full *full_command_packet; 763 TW_Device_Extension *tw_dev = twl_device_extension_list[iminor(inode)]; 764 int retval = -EFAULT; 765 void __user *argp = (void __user *)arg; 766 767 mutex_lock(&twl_chrdev_mutex); 768 769 /* Only let one of these through at a time */ 770 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) { 771 retval = -EINTR; 772 goto out; 773 } 774 775 /* First copy down the driver command */ 776 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command))) 777 goto out2; 778 779 /* Check data buffer size */ 780 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) { 781 retval = -EINVAL; 782 goto out2; 783 } 784 785 /* Hardware can only do multiple of 512 byte transfers */ 786 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511; 787 788 /* Now allocate ioctl buf memory */ 789 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); 790 if (!cpu_addr) { 791 retval = -ENOMEM; 792 goto out2; 793 } 794 795 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr; 796 797 /* Now copy down the entire ioctl */ 798 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1)) 799 goto out3; 800 801 /* See which ioctl we are doing */ 802 switch (cmd) { 803 case TW_IOCTL_FIRMWARE_PASS_THROUGH: 804 spin_lock_irqsave(tw_dev->host->host_lock, flags); 805 twl_get_request_id(tw_dev, &request_id); 806 807 /* Flag internal command */ 808 tw_dev->srb[request_id] = NULL; 809 810 /* Flag chrdev ioctl */ 811 tw_dev->chrdev_request_id = request_id; 812 813 full_command_packet = (TW_Command_Full *)&tw_ioctl->firmware_command; 814 815 /* Load request id and sglist for both command types */ 816 twl_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted); 817 818 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full)); 819 820 /* Now post the command packet to the controller */ 821 twl_post_command_packet(tw_dev, request_id); 822 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 823 824 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ; 825 826 /* Now wait for command to complete */ 827 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout); 828 829 /* We timed out, and didn't get an interrupt */ 830 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) { 831 /* Now we need to reset the board */ 832 printk(KERN_WARNING "3w-sas: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n", 833 tw_dev->host->host_no, TW_DRIVER, 0x6, 834 cmd); 835 retval = -EIO; 836 twl_reset_device_extension(tw_dev, 1); 837 goto out3; 838 } 839 840 /* Now copy in the command packet response */ 841 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full)); 842 843 /* Now complete the io */ 844 spin_lock_irqsave(tw_dev->host->host_lock, flags); 845 tw_dev->posted_request_count--; 846 tw_dev->state[request_id] = TW_S_COMPLETED; 847 twl_free_request_id(tw_dev, request_id); 848 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 849 break; 850 default: 851 retval = -ENOTTY; 852 goto out3; 853 } 854 855 /* Now copy the entire response to userspace */ 856 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0) 857 retval = 0; 858 out3: 859 /* Now free ioctl buf memory */ 860 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle); 861 out2: 862 mutex_unlock(&tw_dev->ioctl_lock); 863 out: 864 mutex_unlock(&twl_chrdev_mutex); 865 return retval; 866 } /* End twl_chrdev_ioctl() */ 867 868 /* This function handles open for the character device */ 869 static int twl_chrdev_open(struct inode *inode, struct file *file) 870 { 871 unsigned int minor_number; 872 int retval = -ENODEV; 873 874 if (!capable(CAP_SYS_ADMIN)) { 875 retval = -EACCES; 876 goto out; 877 } 878 879 minor_number = iminor(inode); 880 if (minor_number >= twl_device_extension_count) 881 goto out; 882 retval = 0; 883 out: 884 return retval; 885 } /* End twl_chrdev_open() */ 886 887 /* File operations struct for character device */ 888 static const struct file_operations twl_fops = { 889 .owner = THIS_MODULE, 890 .unlocked_ioctl = twl_chrdev_ioctl, 891 .open = twl_chrdev_open, 892 .release = NULL, 893 .llseek = noop_llseek, 894 }; 895 896 /* This function passes sense data from firmware to scsi layer */ 897 static int twl_fill_sense(TW_Device_Extension *tw_dev, int i, int request_id, int copy_sense, int print_host) 898 { 899 TW_Command_Apache_Header *header; 900 TW_Command_Full *full_command_packet; 901 unsigned short error; 902 char *error_str; 903 int retval = 1; 904 905 header = tw_dev->sense_buffer_virt[i]; 906 full_command_packet = tw_dev->command_packet_virt[request_id]; 907 908 /* Get embedded firmware error string */ 909 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc) + 1]); 910 911 /* Don't print error for Logical unit not supported during rollcall */ 912 error = le16_to_cpu(header->status_block.error); 913 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE) && (error != TW_ERROR_INVALID_FIELD_IN_CDB)) { 914 if (print_host) 915 printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n", 916 tw_dev->host->host_no, 917 TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 918 header->status_block.error, 919 error_str, 920 header->err_specific_desc); 921 else 922 printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s:%s.\n", 923 TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 924 header->status_block.error, 925 error_str, 926 header->err_specific_desc); 927 } 928 929 if (copy_sense) { 930 memcpy(tw_dev->srb[request_id]->sense_buffer, header->sense_data, TW_SENSE_DATA_LENGTH); 931 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1); 932 goto out; 933 } 934 out: 935 return retval; 936 } /* End twl_fill_sense() */ 937 938 /* This function will free up device extension resources */ 939 static void twl_free_device_extension(TW_Device_Extension *tw_dev) 940 { 941 if (tw_dev->command_packet_virt[0]) 942 pci_free_consistent(tw_dev->tw_pci_dev, 943 sizeof(TW_Command_Full)*TW_Q_LENGTH, 944 tw_dev->command_packet_virt[0], 945 tw_dev->command_packet_phys[0]); 946 947 if (tw_dev->generic_buffer_virt[0]) 948 pci_free_consistent(tw_dev->tw_pci_dev, 949 TW_SECTOR_SIZE*TW_Q_LENGTH, 950 tw_dev->generic_buffer_virt[0], 951 tw_dev->generic_buffer_phys[0]); 952 953 if (tw_dev->sense_buffer_virt[0]) 954 pci_free_consistent(tw_dev->tw_pci_dev, 955 sizeof(TW_Command_Apache_Header)* 956 TW_Q_LENGTH, 957 tw_dev->sense_buffer_virt[0], 958 tw_dev->sense_buffer_phys[0]); 959 960 kfree(tw_dev->event_queue[0]); 961 } /* End twl_free_device_extension() */ 962 963 /* This function will get parameter table entries from the firmware */ 964 static void *twl_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes) 965 { 966 TW_Command_Full *full_command_packet; 967 TW_Command *command_packet; 968 TW_Param_Apache *param; 969 void *retval = NULL; 970 971 /* Setup the command packet */ 972 full_command_packet = tw_dev->command_packet_virt[request_id]; 973 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 974 command_packet = &full_command_packet->command.oldcommand; 975 976 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 977 command_packet->size = TW_COMMAND_SIZE; 978 command_packet->request_id = request_id; 979 command_packet->byte6_offset.block_count = cpu_to_le16(1); 980 981 /* Now setup the param */ 982 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 983 memset(param, 0, TW_SECTOR_SIZE); 984 param->table_id = cpu_to_le16(table_id | 0x8000); 985 param->parameter_id = cpu_to_le16(parameter_id); 986 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes); 987 988 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]); 989 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE); 990 991 /* Post the command packet to the board */ 992 twl_post_command_packet(tw_dev, request_id); 993 994 /* Poll for completion */ 995 if (twl_poll_response(tw_dev, request_id, 30)) 996 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "No valid response during get param") 997 else 998 retval = (void *)&(param->data[0]); 999 1000 tw_dev->posted_request_count--; 1001 tw_dev->state[request_id] = TW_S_INITIAL; 1002 1003 return retval; 1004 } /* End twl_get_param() */ 1005 1006 /* This function will send an initconnection command to controller */ 1007 static int twl_initconnection(TW_Device_Extension *tw_dev, int message_credits, 1008 u32 set_features, unsigned short current_fw_srl, 1009 unsigned short current_fw_arch_id, 1010 unsigned short current_fw_branch, 1011 unsigned short current_fw_build, 1012 unsigned short *fw_on_ctlr_srl, 1013 unsigned short *fw_on_ctlr_arch_id, 1014 unsigned short *fw_on_ctlr_branch, 1015 unsigned short *fw_on_ctlr_build, 1016 u32 *init_connect_result) 1017 { 1018 TW_Command_Full *full_command_packet; 1019 TW_Initconnect *tw_initconnect; 1020 int request_id = 0, retval = 1; 1021 1022 /* Initialize InitConnection command packet */ 1023 full_command_packet = tw_dev->command_packet_virt[request_id]; 1024 memset(full_command_packet, 0, sizeof(TW_Command_Full)); 1025 full_command_packet->header.header_desc.size_header = 128; 1026 1027 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand; 1028 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION); 1029 tw_initconnect->request_id = request_id; 1030 tw_initconnect->message_credits = cpu_to_le16(message_credits); 1031 tw_initconnect->features = set_features; 1032 1033 /* Turn on 64-bit sgl support if we need to */ 1034 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0; 1035 1036 tw_initconnect->features = cpu_to_le32(tw_initconnect->features); 1037 1038 if (set_features & TW_EXTENDED_INIT_CONNECT) { 1039 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED; 1040 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl); 1041 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id); 1042 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch); 1043 tw_initconnect->fw_build = cpu_to_le16(current_fw_build); 1044 } else 1045 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE; 1046 1047 /* Send command packet to the board */ 1048 twl_post_command_packet(tw_dev, request_id); 1049 1050 /* Poll for completion */ 1051 if (twl_poll_response(tw_dev, request_id, 30)) { 1052 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x8, "No valid response during init connection"); 1053 } else { 1054 if (set_features & TW_EXTENDED_INIT_CONNECT) { 1055 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl); 1056 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id); 1057 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch); 1058 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build); 1059 *init_connect_result = le32_to_cpu(tw_initconnect->result); 1060 } 1061 retval = 0; 1062 } 1063 1064 tw_dev->posted_request_count--; 1065 tw_dev->state[request_id] = TW_S_INITIAL; 1066 1067 return retval; 1068 } /* End twl_initconnection() */ 1069 1070 /* This function will initialize the fields of a device extension */ 1071 static int twl_initialize_device_extension(TW_Device_Extension *tw_dev) 1072 { 1073 int i, retval = 1; 1074 1075 /* Initialize command packet buffers */ 1076 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) { 1077 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x9, "Command packet memory allocation failed"); 1078 goto out; 1079 } 1080 1081 /* Initialize generic buffer */ 1082 if (twl_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) { 1083 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Generic memory allocation failed"); 1084 goto out; 1085 } 1086 1087 /* Allocate sense buffers */ 1088 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Apache_Header), 2)) { 1089 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xb, "Sense buffer allocation failed"); 1090 goto out; 1091 } 1092 1093 /* Allocate event info space */ 1094 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL); 1095 if (!tw_dev->event_queue[0]) { 1096 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "Event info memory allocation failed"); 1097 goto out; 1098 } 1099 1100 for (i = 0; i < TW_Q_LENGTH; i++) { 1101 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event))); 1102 tw_dev->free_queue[i] = i; 1103 tw_dev->state[i] = TW_S_INITIAL; 1104 } 1105 1106 tw_dev->free_head = TW_Q_START; 1107 tw_dev->free_tail = TW_Q_START; 1108 tw_dev->error_sequence_id = 1; 1109 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1110 1111 mutex_init(&tw_dev->ioctl_lock); 1112 init_waitqueue_head(&tw_dev->ioctl_wqueue); 1113 1114 retval = 0; 1115 out: 1116 return retval; 1117 } /* End twl_initialize_device_extension() */ 1118 1119 /* This function will perform a pci-dma unmap */ 1120 static void twl_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id) 1121 { 1122 struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 1123 1124 if (cmd->SCp.phase == TW_PHASE_SGLIST) 1125 scsi_dma_unmap(cmd); 1126 } /* End twl_unmap_scsi_data() */ 1127 1128 /* This function will handle attention interrupts */ 1129 static int twl_handle_attention_interrupt(TW_Device_Extension *tw_dev) 1130 { 1131 int retval = 1; 1132 u32 request_id, doorbell; 1133 1134 /* Read doorbell status */ 1135 doorbell = readl(TWL_HOBDB_REG_ADDR(tw_dev)); 1136 1137 /* Check for controller errors */ 1138 if (doorbell & TWL_DOORBELL_CONTROLLER_ERROR) { 1139 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "Microcontroller Error: clearing"); 1140 goto out; 1141 } 1142 1143 /* Check if we need to perform an AEN drain */ 1144 if (doorbell & TWL_DOORBELL_ATTENTION_INTERRUPT) { 1145 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) { 1146 twl_get_request_id(tw_dev, &request_id); 1147 if (twl_aen_read_queue(tw_dev, request_id)) { 1148 tw_dev->state[request_id] = TW_S_COMPLETED; 1149 twl_free_request_id(tw_dev, request_id); 1150 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 1151 } 1152 } 1153 } 1154 1155 retval = 0; 1156 out: 1157 /* Clear doorbell interrupt */ 1158 TWL_CLEAR_DB_INTERRUPT(tw_dev); 1159 1160 /* Make sure the clear was flushed by reading it back */ 1161 readl(TWL_HOBDBC_REG_ADDR(tw_dev)); 1162 1163 return retval; 1164 } /* End twl_handle_attention_interrupt() */ 1165 1166 /* Interrupt service routine */ 1167 static irqreturn_t twl_interrupt(int irq, void *dev_instance) 1168 { 1169 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance; 1170 int i, handled = 0, error = 0; 1171 dma_addr_t mfa = 0; 1172 u32 reg, regl, regh, response, request_id = 0; 1173 struct scsi_cmnd *cmd; 1174 TW_Command_Full *full_command_packet; 1175 1176 spin_lock(tw_dev->host->host_lock); 1177 1178 /* Read host interrupt status */ 1179 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev)); 1180 1181 /* Check if this is our interrupt, otherwise bail */ 1182 if (!(reg & TWL_HISTATUS_VALID_INTERRUPT)) 1183 goto twl_interrupt_bail; 1184 1185 handled = 1; 1186 1187 /* If we are resetting, bail */ 1188 if (test_bit(TW_IN_RESET, &tw_dev->flags)) 1189 goto twl_interrupt_bail; 1190 1191 /* Attention interrupt */ 1192 if (reg & TWL_HISTATUS_ATTENTION_INTERRUPT) { 1193 if (twl_handle_attention_interrupt(tw_dev)) { 1194 TWL_MASK_INTERRUPTS(tw_dev); 1195 goto twl_interrupt_bail; 1196 } 1197 } 1198 1199 /* Response interrupt */ 1200 while (reg & TWL_HISTATUS_RESPONSE_INTERRUPT) { 1201 if (sizeof(dma_addr_t) > 4) { 1202 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev)); 1203 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev)); 1204 mfa = ((u64)regh << 32) | regl; 1205 } else 1206 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev)); 1207 1208 error = 0; 1209 response = (u32)mfa; 1210 1211 /* Check for command packet error */ 1212 if (!TW_NOTMFA_OUT(response)) { 1213 for (i=0;i<TW_Q_LENGTH;i++) { 1214 if (tw_dev->sense_buffer_phys[i] == mfa) { 1215 request_id = le16_to_cpu(tw_dev->sense_buffer_virt[i]->header_desc.request_id); 1216 if (tw_dev->srb[request_id] != NULL) 1217 error = twl_fill_sense(tw_dev, i, request_id, 1, 1); 1218 else { 1219 /* Skip ioctl error prints */ 1220 if (request_id != tw_dev->chrdev_request_id) 1221 error = twl_fill_sense(tw_dev, i, request_id, 0, 1); 1222 else 1223 memcpy(tw_dev->command_packet_virt[request_id], tw_dev->sense_buffer_virt[i], sizeof(TW_Command_Apache_Header)); 1224 } 1225 1226 /* Now re-post the sense buffer */ 1227 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev)); 1228 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev)); 1229 break; 1230 } 1231 } 1232 } else 1233 request_id = TW_RESID_OUT(response); 1234 1235 full_command_packet = tw_dev->command_packet_virt[request_id]; 1236 1237 /* Check for correct state */ 1238 if (tw_dev->state[request_id] != TW_S_POSTED) { 1239 if (tw_dev->srb[request_id] != NULL) { 1240 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Received a request id that wasn't posted"); 1241 TWL_MASK_INTERRUPTS(tw_dev); 1242 goto twl_interrupt_bail; 1243 } 1244 } 1245 1246 /* Check for internal command completion */ 1247 if (tw_dev->srb[request_id] == NULL) { 1248 if (request_id != tw_dev->chrdev_request_id) { 1249 if (twl_aen_complete(tw_dev, request_id)) 1250 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xf, "Error completing AEN during attention interrupt"); 1251 } else { 1252 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1253 wake_up(&tw_dev->ioctl_wqueue); 1254 } 1255 } else { 1256 cmd = tw_dev->srb[request_id]; 1257 1258 if (!error) 1259 cmd->result = (DID_OK << 16); 1260 1261 /* Report residual bytes for single sgl */ 1262 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) { 1263 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id])) 1264 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length); 1265 } 1266 1267 /* Now complete the io */ 1268 tw_dev->state[request_id] = TW_S_COMPLETED; 1269 twl_free_request_id(tw_dev, request_id); 1270 tw_dev->posted_request_count--; 1271 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1272 twl_unmap_scsi_data(tw_dev, request_id); 1273 } 1274 1275 /* Check for another response interrupt */ 1276 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev)); 1277 } 1278 1279 twl_interrupt_bail: 1280 spin_unlock(tw_dev->host->host_lock); 1281 return IRQ_RETVAL(handled); 1282 } /* End twl_interrupt() */ 1283 1284 /* This function will poll for a register change */ 1285 static int twl_poll_register(TW_Device_Extension *tw_dev, void *reg, u32 value, u32 result, int seconds) 1286 { 1287 unsigned long before; 1288 int retval = 1; 1289 u32 reg_value; 1290 1291 reg_value = readl(reg); 1292 before = jiffies; 1293 1294 while ((reg_value & value) != result) { 1295 reg_value = readl(reg); 1296 if (time_after(jiffies, before + HZ * seconds)) 1297 goto out; 1298 msleep(50); 1299 } 1300 retval = 0; 1301 out: 1302 return retval; 1303 } /* End twl_poll_register() */ 1304 1305 /* This function will reset a controller */ 1306 static int twl_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset) 1307 { 1308 int retval = 1; 1309 int i = 0; 1310 u32 status = 0; 1311 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0; 1312 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0; 1313 u32 init_connect_result = 0; 1314 int tries = 0; 1315 int do_soft_reset = soft_reset; 1316 1317 while (tries < TW_MAX_RESET_TRIES) { 1318 /* Do a soft reset if one is needed */ 1319 if (do_soft_reset) { 1320 TWL_SOFT_RESET(tw_dev); 1321 1322 /* Make sure controller is in a good state */ 1323 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, 0x0, 30)) { 1324 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Controller never went non-ready during reset sequence"); 1325 tries++; 1326 continue; 1327 } 1328 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, TWL_CONTROLLER_READY, 60)) { 1329 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x11, "Controller not ready during reset sequence"); 1330 tries++; 1331 continue; 1332 } 1333 } 1334 1335 /* Initconnect */ 1336 if (twl_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS, 1337 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL, 1338 TW_9750_ARCH_ID, TW_CURRENT_DRIVER_BRANCH, 1339 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl, 1340 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch, 1341 &fw_on_ctlr_build, &init_connect_result)) { 1342 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x12, "Initconnection failed while checking SRL"); 1343 do_soft_reset = 1; 1344 tries++; 1345 continue; 1346 } 1347 1348 /* Load sense buffers */ 1349 while (i < TW_Q_LENGTH) { 1350 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev)); 1351 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev)); 1352 1353 /* Check status for over-run after each write */ 1354 status = readl(TWL_STATUS_REG_ADDR(tw_dev)); 1355 if (!(status & TWL_STATUS_OVERRUN_SUBMIT)) 1356 i++; 1357 } 1358 1359 /* Now check status */ 1360 status = readl(TWL_STATUS_REG_ADDR(tw_dev)); 1361 if (status) { 1362 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "Bad controller status after loading sense buffers"); 1363 do_soft_reset = 1; 1364 tries++; 1365 continue; 1366 } 1367 1368 /* Drain the AEN queue */ 1369 if (twl_aen_drain_queue(tw_dev, soft_reset)) { 1370 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x14, "AEN drain failed during reset sequence"); 1371 do_soft_reset = 1; 1372 tries++; 1373 continue; 1374 } 1375 1376 /* Load rest of compatibility struct */ 1377 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION)); 1378 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL; 1379 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH; 1380 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD; 1381 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL; 1382 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH; 1383 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD; 1384 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl; 1385 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch; 1386 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build; 1387 1388 /* If we got here, controller is in a good state */ 1389 retval = 0; 1390 goto out; 1391 } 1392 out: 1393 return retval; 1394 } /* End twl_reset_sequence() */ 1395 1396 /* This function will reset a device extension */ 1397 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset) 1398 { 1399 int i = 0, retval = 1; 1400 unsigned long flags = 0; 1401 1402 /* Block SCSI requests while we are resetting */ 1403 if (ioctl_reset) 1404 scsi_block_requests(tw_dev->host); 1405 1406 set_bit(TW_IN_RESET, &tw_dev->flags); 1407 TWL_MASK_INTERRUPTS(tw_dev); 1408 TWL_CLEAR_DB_INTERRUPT(tw_dev); 1409 1410 spin_lock_irqsave(tw_dev->host->host_lock, flags); 1411 1412 /* Abort all requests that are in progress */ 1413 for (i = 0; i < TW_Q_LENGTH; i++) { 1414 if ((tw_dev->state[i] != TW_S_FINISHED) && 1415 (tw_dev->state[i] != TW_S_INITIAL) && 1416 (tw_dev->state[i] != TW_S_COMPLETED)) { 1417 if (tw_dev->srb[i]) { 1418 tw_dev->srb[i]->result = (DID_RESET << 16); 1419 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]); 1420 twl_unmap_scsi_data(tw_dev, i); 1421 } 1422 } 1423 } 1424 1425 /* Reset queues and counts */ 1426 for (i = 0; i < TW_Q_LENGTH; i++) { 1427 tw_dev->free_queue[i] = i; 1428 tw_dev->state[i] = TW_S_INITIAL; 1429 } 1430 tw_dev->free_head = TW_Q_START; 1431 tw_dev->free_tail = TW_Q_START; 1432 tw_dev->posted_request_count = 0; 1433 1434 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1435 1436 if (twl_reset_sequence(tw_dev, 1)) 1437 goto out; 1438 1439 TWL_UNMASK_INTERRUPTS(tw_dev); 1440 1441 clear_bit(TW_IN_RESET, &tw_dev->flags); 1442 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1443 1444 retval = 0; 1445 out: 1446 if (ioctl_reset) 1447 scsi_unblock_requests(tw_dev->host); 1448 return retval; 1449 } /* End twl_reset_device_extension() */ 1450 1451 /* This funciton returns unit geometry in cylinders/heads/sectors */ 1452 static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[]) 1453 { 1454 int heads, sectors; 1455 TW_Device_Extension *tw_dev; 1456 1457 tw_dev = (TW_Device_Extension *)sdev->host->hostdata; 1458 1459 if (capacity >= 0x200000) { 1460 heads = 255; 1461 sectors = 63; 1462 } else { 1463 heads = 64; 1464 sectors = 32; 1465 } 1466 1467 geom[0] = heads; 1468 geom[1] = sectors; 1469 geom[2] = sector_div(capacity, heads * sectors); /* cylinders */ 1470 1471 return 0; 1472 } /* End twl_scsi_biosparam() */ 1473 1474 /* This is the new scsi eh reset function */ 1475 static int twl_scsi_eh_reset(struct scsi_cmnd *SCpnt) 1476 { 1477 TW_Device_Extension *tw_dev = NULL; 1478 int retval = FAILED; 1479 1480 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1481 1482 tw_dev->num_resets++; 1483 1484 sdev_printk(KERN_WARNING, SCpnt->device, 1485 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n", 1486 TW_DRIVER, 0x2c, SCpnt->cmnd[0]); 1487 1488 /* Make sure we are not issuing an ioctl or resetting from ioctl */ 1489 mutex_lock(&tw_dev->ioctl_lock); 1490 1491 /* Now reset the card and some of the device extension data */ 1492 if (twl_reset_device_extension(tw_dev, 0)) { 1493 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "Controller reset failed during scsi host reset"); 1494 goto out; 1495 } 1496 1497 retval = SUCCESS; 1498 out: 1499 mutex_unlock(&tw_dev->ioctl_lock); 1500 return retval; 1501 } /* End twl_scsi_eh_reset() */ 1502 1503 /* This is the main scsi queue function to handle scsi opcodes */ 1504 static int twl_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 1505 { 1506 int request_id, retval; 1507 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1508 1509 /* If we are resetting due to timed out ioctl, report as busy */ 1510 if (test_bit(TW_IN_RESET, &tw_dev->flags)) { 1511 retval = SCSI_MLQUEUE_HOST_BUSY; 1512 goto out; 1513 } 1514 1515 /* Save done function into scsi_cmnd struct */ 1516 SCpnt->scsi_done = done; 1517 1518 /* Get a free request id */ 1519 twl_get_request_id(tw_dev, &request_id); 1520 1521 /* Save the scsi command for use by the ISR */ 1522 tw_dev->srb[request_id] = SCpnt; 1523 1524 /* Initialize phase to zero */ 1525 SCpnt->SCp.phase = TW_PHASE_INITIAL; 1526 1527 retval = twl_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL); 1528 if (retval) { 1529 tw_dev->state[request_id] = TW_S_COMPLETED; 1530 twl_free_request_id(tw_dev, request_id); 1531 SCpnt->result = (DID_ERROR << 16); 1532 done(SCpnt); 1533 retval = 0; 1534 } 1535 out: 1536 return retval; 1537 } /* End twl_scsi_queue() */ 1538 1539 static DEF_SCSI_QCMD(twl_scsi_queue) 1540 1541 /* This function tells the controller to shut down */ 1542 static void __twl_shutdown(TW_Device_Extension *tw_dev) 1543 { 1544 /* Disable interrupts */ 1545 TWL_MASK_INTERRUPTS(tw_dev); 1546 1547 /* Free up the IRQ */ 1548 free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 1549 1550 printk(KERN_WARNING "3w-sas: Shutting down host %d.\n", tw_dev->host->host_no); 1551 1552 /* Tell the card we are shutting down */ 1553 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) { 1554 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Connection shutdown failed"); 1555 } else { 1556 printk(KERN_WARNING "3w-sas: Shutdown complete.\n"); 1557 } 1558 1559 /* Clear doorbell interrupt just before exit */ 1560 TWL_CLEAR_DB_INTERRUPT(tw_dev); 1561 } /* End __twl_shutdown() */ 1562 1563 /* Wrapper for __twl_shutdown */ 1564 static void twl_shutdown(struct pci_dev *pdev) 1565 { 1566 struct Scsi_Host *host = pci_get_drvdata(pdev); 1567 TW_Device_Extension *tw_dev; 1568 1569 if (!host) 1570 return; 1571 1572 tw_dev = (TW_Device_Extension *)host->hostdata; 1573 1574 if (tw_dev->online) 1575 __twl_shutdown(tw_dev); 1576 } /* End twl_shutdown() */ 1577 1578 /* This function configures unit settings when a unit is coming on-line */ 1579 static int twl_slave_configure(struct scsi_device *sdev) 1580 { 1581 /* Force 60 second timeout */ 1582 blk_queue_rq_timeout(sdev->request_queue, 60 * HZ); 1583 1584 return 0; 1585 } /* End twl_slave_configure() */ 1586 1587 /* scsi_host_template initializer */ 1588 static struct scsi_host_template driver_template = { 1589 .module = THIS_MODULE, 1590 .name = "3w-sas", 1591 .queuecommand = twl_scsi_queue, 1592 .eh_host_reset_handler = twl_scsi_eh_reset, 1593 .bios_param = twl_scsi_biosparam, 1594 .change_queue_depth = twl_change_queue_depth, 1595 .can_queue = TW_Q_LENGTH-2, 1596 .slave_configure = twl_slave_configure, 1597 .this_id = -1, 1598 .sg_tablesize = TW_LIBERATOR_MAX_SGL_LENGTH, 1599 .max_sectors = TW_MAX_SECTORS, 1600 .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 1601 .use_clustering = ENABLE_CLUSTERING, 1602 .shost_attrs = twl_host_attrs, 1603 .emulated = 1 1604 }; 1605 1606 /* This function will probe and initialize a card */ 1607 static int __devinit twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 1608 { 1609 struct Scsi_Host *host = NULL; 1610 TW_Device_Extension *tw_dev; 1611 int retval = -ENODEV; 1612 int *ptr_phycount, phycount=0; 1613 1614 retval = pci_enable_device(pdev); 1615 if (retval) { 1616 TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device"); 1617 goto out_disable_device; 1618 } 1619 1620 pci_set_master(pdev); 1621 pci_try_set_mwi(pdev); 1622 1623 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) 1624 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) 1625 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) 1626 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) { 1627 TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask"); 1628 retval = -ENODEV; 1629 goto out_disable_device; 1630 } 1631 1632 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension)); 1633 if (!host) { 1634 TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension"); 1635 retval = -ENOMEM; 1636 goto out_disable_device; 1637 } 1638 tw_dev = shost_priv(host); 1639 1640 /* Save values to device extension */ 1641 tw_dev->host = host; 1642 tw_dev->tw_pci_dev = pdev; 1643 1644 if (twl_initialize_device_extension(tw_dev)) { 1645 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension"); 1646 goto out_free_device_extension; 1647 } 1648 1649 /* Request IO regions */ 1650 retval = pci_request_regions(pdev, "3w-sas"); 1651 if (retval) { 1652 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region"); 1653 goto out_free_device_extension; 1654 } 1655 1656 /* Save base address, use region 1 */ 1657 tw_dev->base_addr = pci_iomap(pdev, 1, 0); 1658 if (!tw_dev->base_addr) { 1659 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap"); 1660 goto out_release_mem_region; 1661 } 1662 1663 /* Disable interrupts on the card */ 1664 TWL_MASK_INTERRUPTS(tw_dev); 1665 1666 /* Initialize the card */ 1667 if (twl_reset_sequence(tw_dev, 0)) { 1668 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe"); 1669 goto out_iounmap; 1670 } 1671 1672 /* Set host specific parameters */ 1673 host->max_id = TW_MAX_UNITS; 1674 host->max_cmd_len = TW_MAX_CDB_LEN; 1675 host->max_lun = TW_MAX_LUNS; 1676 host->max_channel = 0; 1677 1678 /* Register the card with the kernel SCSI layer */ 1679 retval = scsi_add_host(host, &pdev->dev); 1680 if (retval) { 1681 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed"); 1682 goto out_iounmap; 1683 } 1684 1685 pci_set_drvdata(pdev, host); 1686 1687 printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n", 1688 host->host_no, 1689 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE, 1690 TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH), 1691 (u64)pci_resource_start(pdev, 1), pdev->irq); 1692 1693 ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE, 1694 TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH); 1695 if (ptr_phycount) 1696 phycount = le32_to_cpu(*(int *)ptr_phycount); 1697 1698 printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n", 1699 host->host_no, 1700 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE, 1701 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH), 1702 (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE, 1703 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH), 1704 phycount); 1705 1706 /* Try to enable MSI */ 1707 if (use_msi && !pci_enable_msi(pdev)) 1708 set_bit(TW_USING_MSI, &tw_dev->flags); 1709 1710 /* Now setup the interrupt handler */ 1711 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev); 1712 if (retval) { 1713 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ"); 1714 goto out_remove_host; 1715 } 1716 1717 twl_device_extension_list[twl_device_extension_count] = tw_dev; 1718 twl_device_extension_count++; 1719 1720 /* Re-enable interrupts on the card */ 1721 TWL_UNMASK_INTERRUPTS(tw_dev); 1722 1723 /* Finally, scan the host */ 1724 scsi_scan_host(host); 1725 1726 /* Add sysfs binary files */ 1727 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr)) 1728 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read"); 1729 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr)) 1730 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info"); 1731 1732 if (twl_major == -1) { 1733 if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0) 1734 TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device"); 1735 } 1736 tw_dev->online = 1; 1737 return 0; 1738 1739 out_remove_host: 1740 if (test_bit(TW_USING_MSI, &tw_dev->flags)) 1741 pci_disable_msi(pdev); 1742 scsi_remove_host(host); 1743 out_iounmap: 1744 iounmap(tw_dev->base_addr); 1745 out_release_mem_region: 1746 pci_release_regions(pdev); 1747 out_free_device_extension: 1748 twl_free_device_extension(tw_dev); 1749 scsi_host_put(host); 1750 out_disable_device: 1751 pci_disable_device(pdev); 1752 1753 return retval; 1754 } /* End twl_probe() */ 1755 1756 /* This function is called to remove a device */ 1757 static void twl_remove(struct pci_dev *pdev) 1758 { 1759 struct Scsi_Host *host = pci_get_drvdata(pdev); 1760 TW_Device_Extension *tw_dev; 1761 1762 if (!host) 1763 return; 1764 1765 tw_dev = (TW_Device_Extension *)host->hostdata; 1766 1767 if (!tw_dev->online) 1768 return; 1769 1770 /* Remove sysfs binary files */ 1771 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr); 1772 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr); 1773 1774 scsi_remove_host(tw_dev->host); 1775 1776 /* Unregister character device */ 1777 if (twl_major >= 0) { 1778 unregister_chrdev(twl_major, "twl"); 1779 twl_major = -1; 1780 } 1781 1782 /* Shutdown the card */ 1783 __twl_shutdown(tw_dev); 1784 1785 /* Disable MSI if enabled */ 1786 if (test_bit(TW_USING_MSI, &tw_dev->flags)) 1787 pci_disable_msi(pdev); 1788 1789 /* Free IO remapping */ 1790 iounmap(tw_dev->base_addr); 1791 1792 /* Free up the mem region */ 1793 pci_release_regions(pdev); 1794 1795 /* Free up device extension resources */ 1796 twl_free_device_extension(tw_dev); 1797 1798 scsi_host_put(tw_dev->host); 1799 pci_disable_device(pdev); 1800 twl_device_extension_count--; 1801 } /* End twl_remove() */ 1802 1803 #ifdef CONFIG_PM 1804 /* This function is called on PCI suspend */ 1805 static int twl_suspend(struct pci_dev *pdev, pm_message_t state) 1806 { 1807 struct Scsi_Host *host = pci_get_drvdata(pdev); 1808 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 1809 1810 printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no); 1811 /* Disable interrupts */ 1812 TWL_MASK_INTERRUPTS(tw_dev); 1813 1814 free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 1815 1816 /* Tell the card we are shutting down */ 1817 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) { 1818 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend"); 1819 } else { 1820 printk(KERN_WARNING "3w-sas: Suspend complete.\n"); 1821 } 1822 1823 /* Clear doorbell interrupt */ 1824 TWL_CLEAR_DB_INTERRUPT(tw_dev); 1825 1826 pci_save_state(pdev); 1827 pci_disable_device(pdev); 1828 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 1829 1830 return 0; 1831 } /* End twl_suspend() */ 1832 1833 /* This function is called on PCI resume */ 1834 static int twl_resume(struct pci_dev *pdev) 1835 { 1836 int retval = 0; 1837 struct Scsi_Host *host = pci_get_drvdata(pdev); 1838 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 1839 1840 printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no); 1841 pci_set_power_state(pdev, PCI_D0); 1842 pci_enable_wake(pdev, PCI_D0, 0); 1843 pci_restore_state(pdev); 1844 1845 retval = pci_enable_device(pdev); 1846 if (retval) { 1847 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x24, "Enable device failed during resume"); 1848 return retval; 1849 } 1850 1851 pci_set_master(pdev); 1852 pci_try_set_mwi(pdev); 1853 1854 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) 1855 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) 1856 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) 1857 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) { 1858 TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume"); 1859 retval = -ENODEV; 1860 goto out_disable_device; 1861 } 1862 1863 /* Initialize the card */ 1864 if (twl_reset_sequence(tw_dev, 0)) { 1865 retval = -ENODEV; 1866 goto out_disable_device; 1867 } 1868 1869 /* Now setup the interrupt handler */ 1870 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev); 1871 if (retval) { 1872 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume"); 1873 retval = -ENODEV; 1874 goto out_disable_device; 1875 } 1876 1877 /* Now enable MSI if enabled */ 1878 if (test_bit(TW_USING_MSI, &tw_dev->flags)) 1879 pci_enable_msi(pdev); 1880 1881 /* Re-enable interrupts on the card */ 1882 TWL_UNMASK_INTERRUPTS(tw_dev); 1883 1884 printk(KERN_WARNING "3w-sas: Resume complete.\n"); 1885 return 0; 1886 1887 out_disable_device: 1888 scsi_remove_host(host); 1889 pci_disable_device(pdev); 1890 1891 return retval; 1892 } /* End twl_resume() */ 1893 #endif 1894 1895 /* PCI Devices supported by this driver */ 1896 static struct pci_device_id twl_pci_tbl[] __devinitdata = { 1897 { PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) }, 1898 { } 1899 }; 1900 MODULE_DEVICE_TABLE(pci, twl_pci_tbl); 1901 1902 /* pci_driver initializer */ 1903 static struct pci_driver twl_driver = { 1904 .name = "3w-sas", 1905 .id_table = twl_pci_tbl, 1906 .probe = twl_probe, 1907 .remove = twl_remove, 1908 #ifdef CONFIG_PM 1909 .suspend = twl_suspend, 1910 .resume = twl_resume, 1911 #endif 1912 .shutdown = twl_shutdown 1913 }; 1914 1915 /* This function is called on driver initialization */ 1916 static int __init twl_init(void) 1917 { 1918 printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION); 1919 1920 return pci_register_driver(&twl_driver); 1921 } /* End twl_init() */ 1922 1923 /* This function is called on driver exit */ 1924 static void __exit twl_exit(void) 1925 { 1926 pci_unregister_driver(&twl_driver); 1927 } /* End twl_exit() */ 1928 1929 module_init(twl_init); 1930 module_exit(twl_exit); 1931 1932