2 3w-sas.c -- LSI 3ware SAS/SATA-RAID Controller device driver for Linux.
4 Written By: Adam Radford <aradford@gmail.com>
6 Copyright (C) 2009 LSI Corporation.
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.
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.
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.
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
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
41 Controllers supported by this driver:
43 LSI 3ware 9750 6Gb/s SAS/SATA-RAID
45 Bugs/Comments/Suggestions should be mailed to:
50 3.26.02.000 - Initial driver release.
53 #include <linux/module.h>
54 #include <linux/reboot.h>
55 #include <linux/spinlock.h>
56 #include <linux/interrupt.h>
57 #include <linux/moduleparam.h>
58 #include <linux/errno.h>
59 #include <linux/types.h>
60 #include <linux/delay.h>
61 #include <linux/pci.h>
62 #include <linux/time.h>
63 #include <linux/mutex.h>
64 #include <linux/slab.h>
67 #include <linux/uaccess.h>
68 #include <scsi/scsi.h>
69 #include <scsi/scsi_host.h>
70 #include <scsi/scsi_tcq.h>
71 #include <scsi/scsi_cmnd.h>
75 #define TW_DRIVER_VERSION "3.26.02.000"
76 static DEFINE_MUTEX(twl_chrdev_mutex);
77 static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT];
78 static unsigned int twl_device_extension_count;
79 static int twl_major = -1;
80 extern struct timezone sys_tz;
82 /* Module parameters */
83 MODULE_AUTHOR ("LSI");
84 MODULE_DESCRIPTION ("LSI 3ware SAS/SATA-RAID Linux Driver");
85 MODULE_LICENSE("GPL");
86 MODULE_VERSION(TW_DRIVER_VERSION);
89 module_param(use_msi, int, S_IRUGO);
90 MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0");
92 /* Function prototypes */
93 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
97 /* This function returns AENs through sysfs */
98 static ssize_t twl_sysfs_aen_read(struct file *filp, struct kobject *kobj,
99 struct bin_attribute *bin_attr,
100 char *outbuf, loff_t offset, size_t count)
102 struct device *dev = container_of(kobj, struct device, kobj);
103 struct Scsi_Host *shost = class_to_shost(dev);
104 TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
105 unsigned long flags = 0;
108 if (!capable(CAP_SYS_ADMIN))
111 spin_lock_irqsave(tw_dev->host->host_lock, flags);
112 ret = memory_read_from_buffer(outbuf, count, &offset, tw_dev->event_queue[0], sizeof(TW_Event) * TW_Q_LENGTH);
113 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
116 } /* End twl_sysfs_aen_read() */
118 /* aen_read sysfs attribute initializer */
119 static struct bin_attribute twl_sysfs_aen_read_attr = {
121 .name = "3ware_aen_read",
125 .read = twl_sysfs_aen_read
128 /* This function returns driver compatibility info through sysfs */
129 static ssize_t twl_sysfs_compat_info(struct file *filp, struct kobject *kobj,
130 struct bin_attribute *bin_attr,
131 char *outbuf, loff_t offset, size_t count)
133 struct device *dev = container_of(kobj, struct device, kobj);
134 struct Scsi_Host *shost = class_to_shost(dev);
135 TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
136 unsigned long flags = 0;
139 if (!capable(CAP_SYS_ADMIN))
142 spin_lock_irqsave(tw_dev->host->host_lock, flags);
143 ret = memory_read_from_buffer(outbuf, count, &offset, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
144 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
147 } /* End twl_sysfs_compat_info() */
149 /* compat_info sysfs attribute initializer */
150 static struct bin_attribute twl_sysfs_compat_info_attr = {
152 .name = "3ware_compat_info",
156 .read = twl_sysfs_compat_info
159 /* Show some statistics about the card */
160 static ssize_t twl_show_stats(struct device *dev,
161 struct device_attribute *attr, char *buf)
163 struct Scsi_Host *host = class_to_shost(dev);
164 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
165 unsigned long flags = 0;
168 spin_lock_irqsave(tw_dev->host->host_lock, flags);
169 len = snprintf(buf, PAGE_SIZE, "3w-sas Driver version: %s\n"
170 "Current commands posted: %4d\n"
171 "Max commands posted: %4d\n"
172 "Last sgl length: %4d\n"
173 "Max sgl length: %4d\n"
174 "Last sector count: %4d\n"
175 "Max sector count: %4d\n"
176 "SCSI Host Resets: %4d\n"
179 tw_dev->posted_request_count,
180 tw_dev->max_posted_request_count,
182 tw_dev->max_sgl_entries,
183 tw_dev->sector_count,
184 tw_dev->max_sector_count,
187 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
189 } /* End twl_show_stats() */
191 /* stats sysfs attribute initializer */
192 static struct device_attribute twl_host_stats_attr = {
194 .name = "3ware_stats",
197 .show = twl_show_stats
200 /* Host attributes initializer */
201 static struct device_attribute *twl_host_attrs[] = {
202 &twl_host_stats_attr,
206 /* This function will look up an AEN severity string */
207 static char *twl_aen_severity_lookup(unsigned char severity_code)
211 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
212 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
215 retval = twl_aen_severity_table[severity_code];
218 } /* End twl_aen_severity_lookup() */
220 /* This function will queue an event */
221 static void twl_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
231 /* Fill out event info */
232 event = tw_dev->event_queue[tw_dev->error_index];
236 sprintf(host, " scsi%d:", tw_dev->host->host_no);
238 aen = le16_to_cpu(header->status_block.error);
239 memset(event, 0, sizeof(TW_Event));
241 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
242 /* event->time_stamp_sec overflows in y2106 */
243 local_time = (u32)(ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
244 event->time_stamp_sec = local_time;
245 event->aen_code = aen;
246 event->retrieved = TW_AEN_NOT_RETRIEVED;
247 event->sequence_id = tw_dev->error_sequence_id;
248 tw_dev->error_sequence_id++;
250 /* Check for embedded error string */
251 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
253 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
254 event->parameter_len = strlen(header->err_specific_desc);
255 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + 1 + strlen(error_str));
256 if (event->severity != TW_AEN_SEVERITY_DEBUG)
257 printk(KERN_WARNING "3w-sas:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
259 twl_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
260 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, error_str,
261 header->err_specific_desc);
265 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
266 } /* End twl_aen_queue_event() */
268 /* This function will attempt to post a command packet to the board */
269 static int twl_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
271 dma_addr_t command_que_value;
273 command_que_value = tw_dev->command_packet_phys[request_id];
274 command_que_value += TW_COMMAND_OFFSET;
276 /* First write upper 4 bytes */
277 writel((u32)((u64)command_que_value >> 32), TWL_HIBQPH_REG_ADDR(tw_dev));
278 /* Then the lower 4 bytes */
279 writel((u32)(command_que_value | TWL_PULL_MODE), TWL_HIBQPL_REG_ADDR(tw_dev));
281 tw_dev->state[request_id] = TW_S_POSTED;
282 tw_dev->posted_request_count++;
283 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count)
284 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
287 } /* End twl_post_command_packet() */
289 /* This function hands scsi cdb's to the firmware */
290 static int twl_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id,
291 unsigned char *cdb, int use_sg,
292 TW_SG_Entry_ISO *sglistarg)
294 TW_Command_Full *full_command_packet;
295 TW_Command_Apache *command_packet;
297 struct scsi_cmnd *srb = NULL;
298 struct scatterlist *sglist = NULL, *sg;
301 if (tw_dev->srb[request_id]) {
302 srb = tw_dev->srb[request_id];
303 if (scsi_sglist(srb))
304 sglist = scsi_sglist(srb);
307 /* Initialize command packet */
308 full_command_packet = tw_dev->command_packet_virt[request_id];
309 full_command_packet->header.header_desc.size_header = 128;
310 full_command_packet->header.status_block.error = 0;
311 full_command_packet->header.status_block.severity__reserved = 0;
313 command_packet = &full_command_packet->command.newcommand;
314 command_packet->status = 0;
315 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
317 /* We forced 16 byte cdb use earlier */
319 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
321 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
324 command_packet->unit = srb->device->id;
325 command_packet->request_id__lunl =
326 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
328 command_packet->request_id__lunl =
329 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
330 command_packet->unit = 0;
333 command_packet->sgl_offset = 16;
336 /* Map sglist from scsi layer to cmd packet */
337 if (scsi_sg_count(srb)) {
338 sg_count = scsi_dma_map(srb);
342 scsi_for_each_sg(srb, sg, sg_count, i) {
343 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
344 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg));
346 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
349 /* Internal cdb post */
350 for (i = 0; i < use_sg; i++) {
351 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
352 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sglistarg[i].length);
354 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
357 /* Update some stats */
359 tw_dev->sector_count = scsi_bufflen(srb) / 512;
360 if (tw_dev->sector_count > tw_dev->max_sector_count)
361 tw_dev->max_sector_count = tw_dev->sector_count;
362 tw_dev->sgl_entries = scsi_sg_count(srb);
363 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
364 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
367 /* Now post the command to the board */
368 retval = twl_post_command_packet(tw_dev, request_id);
372 } /* End twl_scsiop_execute_scsi() */
374 /* This function will read the aen queue from the isr */
375 static int twl_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
377 unsigned char cdb[TW_MAX_CDB_LEN];
378 TW_SG_Entry_ISO sglist[1];
379 TW_Command_Full *full_command_packet;
382 full_command_packet = tw_dev->command_packet_virt[request_id];
383 memset(full_command_packet, 0, sizeof(TW_Command_Full));
386 memset(&cdb, 0, TW_MAX_CDB_LEN);
387 cdb[0] = REQUEST_SENSE; /* opcode */
388 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
390 /* Initialize sglist */
391 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
392 sglist[0].length = TW_SECTOR_SIZE;
393 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
395 /* Mark internal command */
396 tw_dev->srb[request_id] = NULL;
398 /* Now post the command packet */
399 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
400 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Post failed while reading AEN queue");
406 } /* End twl_aen_read_queue() */
408 /* This function will sync firmware time with the host time */
409 static void twl_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
412 TW_Command_Full *full_command_packet;
413 TW_Command *command_packet;
414 TW_Param_Apache *param;
417 /* Fill out the command packet */
418 full_command_packet = tw_dev->command_packet_virt[request_id];
419 memset(full_command_packet, 0, sizeof(TW_Command_Full));
420 command_packet = &full_command_packet->command.oldcommand;
421 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
422 command_packet->request_id = request_id;
423 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
424 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
425 command_packet->size = TW_COMMAND_SIZE;
426 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
428 /* Setup the param */
429 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
430 memset(param, 0, TW_SECTOR_SIZE);
431 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
432 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
433 param->parameter_size_bytes = cpu_to_le16(4);
435 /* Convert system time in UTC to local time seconds since last
437 local_time = (ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
438 div_u64_rem(local_time - (3 * 86400), 604800, &schedulertime);
439 schedulertime = cpu_to_le32(schedulertime);
441 memcpy(param->data, &schedulertime, sizeof(u32));
443 /* Mark internal command */
444 tw_dev->srb[request_id] = NULL;
446 /* Now post the command */
447 twl_post_command_packet(tw_dev, request_id);
448 } /* End twl_aen_sync_time() */
450 /* This function will assign an available request id */
451 static void twl_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
453 *request_id = tw_dev->free_queue[tw_dev->free_head];
454 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
455 tw_dev->state[*request_id] = TW_S_STARTED;
456 } /* End twl_get_request_id() */
458 /* This function will free a request id */
459 static void twl_free_request_id(TW_Device_Extension *tw_dev, int request_id)
461 tw_dev->free_queue[tw_dev->free_tail] = request_id;
462 tw_dev->state[request_id] = TW_S_FINISHED;
463 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
464 } /* End twl_free_request_id() */
466 /* This function will complete an aen request from the isr */
467 static int twl_aen_complete(TW_Device_Extension *tw_dev, int request_id)
469 TW_Command_Full *full_command_packet;
470 TW_Command *command_packet;
471 TW_Command_Apache_Header *header;
475 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
476 tw_dev->posted_request_count--;
477 aen = le16_to_cpu(header->status_block.error);
478 full_command_packet = tw_dev->command_packet_virt[request_id];
479 command_packet = &full_command_packet->command.oldcommand;
481 /* First check for internal completion of set param for time sync */
482 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
483 /* Keep reading the queue in case there are more aen's */
484 if (twl_aen_read_queue(tw_dev, request_id))
493 case TW_AEN_QUEUE_EMPTY:
494 /* Quit reading the queue if this is the last one */
496 case TW_AEN_SYNC_TIME_WITH_HOST:
497 twl_aen_sync_time(tw_dev, request_id);
501 twl_aen_queue_event(tw_dev, header);
503 /* If there are more aen's, keep reading the queue */
504 if (twl_aen_read_queue(tw_dev, request_id))
513 tw_dev->state[request_id] = TW_S_COMPLETED;
514 twl_free_request_id(tw_dev, request_id);
515 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
518 } /* End twl_aen_complete() */
520 /* This function will poll for a response */
521 static int twl_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
523 unsigned long before;
533 if (sizeof(dma_addr_t) > 4) {
534 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
535 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
536 mfa = ((u64)regh << 32) | regl;
538 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
542 if (TW_RESID_OUT(response) == request_id)
545 if (time_after(jiffies, before + HZ * seconds))
553 } /* End twl_poll_response() */
555 /* This function will drain the aen queue */
556 static int twl_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
559 unsigned char cdb[TW_MAX_CDB_LEN];
560 TW_SG_Entry_ISO sglist[1];
561 int finished = 0, count = 0;
562 TW_Command_Full *full_command_packet;
563 TW_Command_Apache_Header *header;
565 int first_reset = 0, queue = 0, retval = 1;
572 full_command_packet = tw_dev->command_packet_virt[request_id];
573 memset(full_command_packet, 0, sizeof(TW_Command_Full));
576 memset(&cdb, 0, TW_MAX_CDB_LEN);
577 cdb[0] = REQUEST_SENSE; /* opcode */
578 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
580 /* Initialize sglist */
581 memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
582 sglist[0].length = TW_SECTOR_SIZE;
583 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
585 /* Mark internal command */
586 tw_dev->srb[request_id] = NULL;
589 /* Send command to the board */
590 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
591 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "Error posting request sense");
595 /* Now poll for completion */
596 if (twl_poll_response(tw_dev, request_id, 30)) {
597 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "No valid response while draining AEN queue");
598 tw_dev->posted_request_count--;
602 tw_dev->posted_request_count--;
603 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
604 aen = le16_to_cpu(header->status_block.error);
609 case TW_AEN_QUEUE_EMPTY:
610 if (first_reset != 1)
615 case TW_AEN_SOFT_RESET:
616 if (first_reset == 0)
621 case TW_AEN_SYNC_TIME_WITH_HOST:
627 /* Now queue an event info */
629 twl_aen_queue_event(tw_dev, header);
630 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
632 if (count == TW_MAX_AEN_DRAIN)
637 tw_dev->state[request_id] = TW_S_INITIAL;
639 } /* End twl_aen_drain_queue() */
641 /* This function will allocate memory and check if it is correctly aligned */
642 static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
645 dma_addr_t dma_handle;
646 unsigned long *cpu_addr;
649 cpu_addr = dma_zalloc_coherent(&tw_dev->tw_pci_dev->dev,
650 size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
652 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
656 for (i = 0; i < TW_Q_LENGTH; i++) {
659 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
660 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
663 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
664 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
667 tw_dev->sense_buffer_phys[i] = dma_handle+(i*size);
668 tw_dev->sense_buffer_virt[i] = (TW_Command_Apache_Header *)((unsigned char *)cpu_addr + (i*size));
675 } /* End twl_allocate_memory() */
677 /* This function will load the request id and various sgls for ioctls */
678 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)
680 TW_Command *oldcommand;
681 TW_Command_Apache *newcommand;
682 TW_SG_Entry_ISO *sgl;
683 unsigned int pae = 0;
685 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
688 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
689 newcommand = &full_command_packet->command.newcommand;
690 newcommand->request_id__lunl =
691 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
693 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
694 newcommand->sg_list[0].length = TW_CPU_TO_SGL(length);
696 newcommand->sgl_entries__lunh =
697 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
699 oldcommand = &full_command_packet->command.oldcommand;
700 oldcommand->request_id = request_id;
702 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
703 /* Load the sg list */
704 sgl = (TW_SG_Entry_ISO *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry_ISO)/4) + pae + (sizeof(dma_addr_t) > 4 ? 1 : 0));
705 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
706 sgl->length = TW_CPU_TO_SGL(length);
707 oldcommand->size += pae;
708 oldcommand->size += sizeof(dma_addr_t) > 4 ? 1 : 0;
711 } /* End twl_load_sgl() */
713 /* This function handles ioctl for the character device
714 This interface is used by smartmontools open source software */
715 static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
718 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
719 dma_addr_t dma_handle;
721 TW_Ioctl_Driver_Command driver_command;
722 struct inode *inode = file_inode(file);
723 TW_Ioctl_Buf_Apache *tw_ioctl;
724 TW_Command_Full *full_command_packet;
725 TW_Device_Extension *tw_dev = twl_device_extension_list[iminor(inode)];
726 int retval = -EFAULT;
727 void __user *argp = (void __user *)arg;
729 mutex_lock(&twl_chrdev_mutex);
731 /* Only let one of these through at a time */
732 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
737 /* First copy down the driver command */
738 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
741 /* Check data buffer size */
742 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
747 /* Hardware can only do multiple of 512 byte transfers */
748 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
750 /* Now allocate ioctl buf memory */
751 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);
757 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
759 /* Now copy down the entire ioctl */
760 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
763 /* See which ioctl we are doing */
765 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
766 spin_lock_irqsave(tw_dev->host->host_lock, flags);
767 twl_get_request_id(tw_dev, &request_id);
769 /* Flag internal command */
770 tw_dev->srb[request_id] = NULL;
772 /* Flag chrdev ioctl */
773 tw_dev->chrdev_request_id = request_id;
775 full_command_packet = (TW_Command_Full *)&tw_ioctl->firmware_command;
777 /* Load request id and sglist for both command types */
778 twl_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
780 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
782 /* Now post the command packet to the controller */
783 twl_post_command_packet(tw_dev, request_id);
784 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
786 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
788 /* Now wait for command to complete */
789 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
791 /* We timed out, and didn't get an interrupt */
792 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
793 /* Now we need to reset the board */
794 printk(KERN_WARNING "3w-sas: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
795 tw_dev->host->host_no, TW_DRIVER, 0x6,
798 twl_reset_device_extension(tw_dev, 1);
802 /* Now copy in the command packet response */
803 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
805 /* Now complete the io */
806 spin_lock_irqsave(tw_dev->host->host_lock, flags);
807 tw_dev->posted_request_count--;
808 tw_dev->state[request_id] = TW_S_COMPLETED;
809 twl_free_request_id(tw_dev, request_id);
810 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
817 /* Now copy the entire response to userspace */
818 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
821 /* Now free ioctl buf memory */
822 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
824 mutex_unlock(&tw_dev->ioctl_lock);
826 mutex_unlock(&twl_chrdev_mutex);
828 } /* End twl_chrdev_ioctl() */
830 /* This function handles open for the character device */
831 static int twl_chrdev_open(struct inode *inode, struct file *file)
833 unsigned int minor_number;
834 int retval = -ENODEV;
836 if (!capable(CAP_SYS_ADMIN)) {
841 minor_number = iminor(inode);
842 if (minor_number >= twl_device_extension_count)
847 } /* End twl_chrdev_open() */
849 /* File operations struct for character device */
850 static const struct file_operations twl_fops = {
851 .owner = THIS_MODULE,
852 .unlocked_ioctl = twl_chrdev_ioctl,
853 .open = twl_chrdev_open,
855 .llseek = noop_llseek,
858 /* This function passes sense data from firmware to scsi layer */
859 static int twl_fill_sense(TW_Device_Extension *tw_dev, int i, int request_id, int copy_sense, int print_host)
861 TW_Command_Apache_Header *header;
862 TW_Command_Full *full_command_packet;
863 unsigned short error;
867 header = tw_dev->sense_buffer_virt[i];
868 full_command_packet = tw_dev->command_packet_virt[request_id];
870 /* Get embedded firmware error string */
871 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc) + 1]);
873 /* Don't print error for Logical unit not supported during rollcall */
874 error = le16_to_cpu(header->status_block.error);
875 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE) && (error != TW_ERROR_INVALID_FIELD_IN_CDB)) {
877 printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
878 tw_dev->host->host_no,
879 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
880 header->status_block.error,
882 header->err_specific_desc);
884 printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s:%s.\n",
885 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
886 header->status_block.error,
888 header->err_specific_desc);
892 memcpy(tw_dev->srb[request_id]->sense_buffer, header->sense_data, TW_SENSE_DATA_LENGTH);
893 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
898 } /* End twl_fill_sense() */
900 /* This function will free up device extension resources */
901 static void twl_free_device_extension(TW_Device_Extension *tw_dev)
903 if (tw_dev->command_packet_virt[0])
904 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
905 sizeof(TW_Command_Full)*TW_Q_LENGTH,
906 tw_dev->command_packet_virt[0],
907 tw_dev->command_packet_phys[0]);
909 if (tw_dev->generic_buffer_virt[0])
910 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
911 TW_SECTOR_SIZE*TW_Q_LENGTH,
912 tw_dev->generic_buffer_virt[0],
913 tw_dev->generic_buffer_phys[0]);
915 if (tw_dev->sense_buffer_virt[0])
916 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
917 sizeof(TW_Command_Apache_Header)*
919 tw_dev->sense_buffer_virt[0],
920 tw_dev->sense_buffer_phys[0]);
922 kfree(tw_dev->event_queue[0]);
923 } /* End twl_free_device_extension() */
925 /* This function will get parameter table entries from the firmware */
926 static void *twl_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
928 TW_Command_Full *full_command_packet;
929 TW_Command *command_packet;
930 TW_Param_Apache *param;
933 /* Setup the command packet */
934 full_command_packet = tw_dev->command_packet_virt[request_id];
935 memset(full_command_packet, 0, sizeof(TW_Command_Full));
936 command_packet = &full_command_packet->command.oldcommand;
938 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
939 command_packet->size = TW_COMMAND_SIZE;
940 command_packet->request_id = request_id;
941 command_packet->byte6_offset.block_count = cpu_to_le16(1);
943 /* Now setup the param */
944 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
945 memset(param, 0, TW_SECTOR_SIZE);
946 param->table_id = cpu_to_le16(table_id | 0x8000);
947 param->parameter_id = cpu_to_le16(parameter_id);
948 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
950 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
951 command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
953 /* Post the command packet to the board */
954 twl_post_command_packet(tw_dev, request_id);
956 /* Poll for completion */
957 if (twl_poll_response(tw_dev, request_id, 30))
958 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "No valid response during get param")
960 retval = (void *)&(param->data[0]);
962 tw_dev->posted_request_count--;
963 tw_dev->state[request_id] = TW_S_INITIAL;
966 } /* End twl_get_param() */
968 /* This function will send an initconnection command to controller */
969 static int twl_initconnection(TW_Device_Extension *tw_dev, int message_credits,
970 u32 set_features, unsigned short current_fw_srl,
971 unsigned short current_fw_arch_id,
972 unsigned short current_fw_branch,
973 unsigned short current_fw_build,
974 unsigned short *fw_on_ctlr_srl,
975 unsigned short *fw_on_ctlr_arch_id,
976 unsigned short *fw_on_ctlr_branch,
977 unsigned short *fw_on_ctlr_build,
978 u32 *init_connect_result)
980 TW_Command_Full *full_command_packet;
981 TW_Initconnect *tw_initconnect;
982 int request_id = 0, retval = 1;
984 /* Initialize InitConnection command packet */
985 full_command_packet = tw_dev->command_packet_virt[request_id];
986 memset(full_command_packet, 0, sizeof(TW_Command_Full));
987 full_command_packet->header.header_desc.size_header = 128;
989 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
990 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
991 tw_initconnect->request_id = request_id;
992 tw_initconnect->message_credits = cpu_to_le16(message_credits);
993 tw_initconnect->features = set_features;
995 /* Turn on 64-bit sgl support if we need to */
996 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
998 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1000 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1001 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1002 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1003 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1004 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1005 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1007 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1009 /* Send command packet to the board */
1010 twl_post_command_packet(tw_dev, request_id);
1012 /* Poll for completion */
1013 if (twl_poll_response(tw_dev, request_id, 30)) {
1014 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x8, "No valid response during init connection");
1016 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1017 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1018 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1019 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1020 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1021 *init_connect_result = le32_to_cpu(tw_initconnect->result);
1026 tw_dev->posted_request_count--;
1027 tw_dev->state[request_id] = TW_S_INITIAL;
1030 } /* End twl_initconnection() */
1032 /* This function will initialize the fields of a device extension */
1033 static int twl_initialize_device_extension(TW_Device_Extension *tw_dev)
1037 /* Initialize command packet buffers */
1038 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1039 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x9, "Command packet memory allocation failed");
1043 /* Initialize generic buffer */
1044 if (twl_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1045 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Generic memory allocation failed");
1049 /* Allocate sense buffers */
1050 if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Apache_Header), 2)) {
1051 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xb, "Sense buffer allocation failed");
1055 /* Allocate event info space */
1056 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1057 if (!tw_dev->event_queue[0]) {
1058 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "Event info memory allocation failed");
1062 for (i = 0; i < TW_Q_LENGTH; i++) {
1063 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1064 tw_dev->free_queue[i] = i;
1065 tw_dev->state[i] = TW_S_INITIAL;
1068 tw_dev->free_head = TW_Q_START;
1069 tw_dev->free_tail = TW_Q_START;
1070 tw_dev->error_sequence_id = 1;
1071 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1073 mutex_init(&tw_dev->ioctl_lock);
1074 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1079 } /* End twl_initialize_device_extension() */
1081 /* This function will handle attention interrupts */
1082 static int twl_handle_attention_interrupt(TW_Device_Extension *tw_dev)
1085 u32 request_id, doorbell;
1087 /* Read doorbell status */
1088 doorbell = readl(TWL_HOBDB_REG_ADDR(tw_dev));
1090 /* Check for controller errors */
1091 if (doorbell & TWL_DOORBELL_CONTROLLER_ERROR) {
1092 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "Microcontroller Error: clearing");
1096 /* Check if we need to perform an AEN drain */
1097 if (doorbell & TWL_DOORBELL_ATTENTION_INTERRUPT) {
1098 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1099 twl_get_request_id(tw_dev, &request_id);
1100 if (twl_aen_read_queue(tw_dev, request_id)) {
1101 tw_dev->state[request_id] = TW_S_COMPLETED;
1102 twl_free_request_id(tw_dev, request_id);
1103 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1110 /* Clear doorbell interrupt */
1111 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1113 /* Make sure the clear was flushed by reading it back */
1114 readl(TWL_HOBDBC_REG_ADDR(tw_dev));
1117 } /* End twl_handle_attention_interrupt() */
1119 /* Interrupt service routine */
1120 static irqreturn_t twl_interrupt(int irq, void *dev_instance)
1122 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1123 int i, handled = 0, error = 0;
1125 u32 reg, regl, regh, response, request_id = 0;
1126 struct scsi_cmnd *cmd;
1127 TW_Command_Full *full_command_packet;
1129 spin_lock(tw_dev->host->host_lock);
1131 /* Read host interrupt status */
1132 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1134 /* Check if this is our interrupt, otherwise bail */
1135 if (!(reg & TWL_HISTATUS_VALID_INTERRUPT))
1136 goto twl_interrupt_bail;
1140 /* If we are resetting, bail */
1141 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1142 goto twl_interrupt_bail;
1144 /* Attention interrupt */
1145 if (reg & TWL_HISTATUS_ATTENTION_INTERRUPT) {
1146 if (twl_handle_attention_interrupt(tw_dev)) {
1147 TWL_MASK_INTERRUPTS(tw_dev);
1148 goto twl_interrupt_bail;
1152 /* Response interrupt */
1153 while (reg & TWL_HISTATUS_RESPONSE_INTERRUPT) {
1154 if (sizeof(dma_addr_t) > 4) {
1155 regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
1156 regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1157 mfa = ((u64)regh << 32) | regl;
1159 mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1162 response = (u32)mfa;
1164 /* Check for command packet error */
1165 if (!TW_NOTMFA_OUT(response)) {
1166 for (i=0;i<TW_Q_LENGTH;i++) {
1167 if (tw_dev->sense_buffer_phys[i] == mfa) {
1168 request_id = le16_to_cpu(tw_dev->sense_buffer_virt[i]->header_desc.request_id);
1169 if (tw_dev->srb[request_id] != NULL)
1170 error = twl_fill_sense(tw_dev, i, request_id, 1, 1);
1172 /* Skip ioctl error prints */
1173 if (request_id != tw_dev->chrdev_request_id)
1174 error = twl_fill_sense(tw_dev, i, request_id, 0, 1);
1176 memcpy(tw_dev->command_packet_virt[request_id], tw_dev->sense_buffer_virt[i], sizeof(TW_Command_Apache_Header));
1179 /* Now re-post the sense buffer */
1180 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1181 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1186 request_id = TW_RESID_OUT(response);
1188 full_command_packet = tw_dev->command_packet_virt[request_id];
1190 /* Check for correct state */
1191 if (tw_dev->state[request_id] != TW_S_POSTED) {
1192 if (tw_dev->srb[request_id] != NULL) {
1193 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Received a request id that wasn't posted");
1194 TWL_MASK_INTERRUPTS(tw_dev);
1195 goto twl_interrupt_bail;
1199 /* Check for internal command completion */
1200 if (tw_dev->srb[request_id] == NULL) {
1201 if (request_id != tw_dev->chrdev_request_id) {
1202 if (twl_aen_complete(tw_dev, request_id))
1203 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xf, "Error completing AEN during attention interrupt");
1205 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1206 wake_up(&tw_dev->ioctl_wqueue);
1209 cmd = tw_dev->srb[request_id];
1212 cmd->result = (DID_OK << 16);
1214 /* Report residual bytes for single sgl */
1215 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1216 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1217 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1220 /* Now complete the io */
1221 scsi_dma_unmap(cmd);
1222 cmd->scsi_done(cmd);
1223 tw_dev->state[request_id] = TW_S_COMPLETED;
1224 twl_free_request_id(tw_dev, request_id);
1225 tw_dev->posted_request_count--;
1228 /* Check for another response interrupt */
1229 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1233 spin_unlock(tw_dev->host->host_lock);
1234 return IRQ_RETVAL(handled);
1235 } /* End twl_interrupt() */
1237 /* This function will poll for a register change */
1238 static int twl_poll_register(TW_Device_Extension *tw_dev, void *reg, u32 value, u32 result, int seconds)
1240 unsigned long before;
1244 reg_value = readl(reg);
1247 while ((reg_value & value) != result) {
1248 reg_value = readl(reg);
1249 if (time_after(jiffies, before + HZ * seconds))
1256 } /* End twl_poll_register() */
1258 /* This function will reset a controller */
1259 static int twl_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1264 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
1265 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
1266 u32 init_connect_result = 0;
1268 int do_soft_reset = soft_reset;
1270 while (tries < TW_MAX_RESET_TRIES) {
1271 /* Do a soft reset if one is needed */
1272 if (do_soft_reset) {
1273 TWL_SOFT_RESET(tw_dev);
1275 /* Make sure controller is in a good state */
1276 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, 0x0, 30)) {
1277 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Controller never went non-ready during reset sequence");
1281 if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, TWL_CONTROLLER_READY, 60)) {
1282 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x11, "Controller not ready during reset sequence");
1289 if (twl_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
1290 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
1291 TW_9750_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
1292 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
1293 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
1294 &fw_on_ctlr_build, &init_connect_result)) {
1295 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x12, "Initconnection failed while checking SRL");
1301 /* Load sense buffers */
1302 while (i < TW_Q_LENGTH) {
1303 writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1304 writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1306 /* Check status for over-run after each write */
1307 status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1308 if (!(status & TWL_STATUS_OVERRUN_SUBMIT))
1312 /* Now check status */
1313 status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1315 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "Bad controller status after loading sense buffers");
1321 /* Drain the AEN queue */
1322 if (twl_aen_drain_queue(tw_dev, soft_reset)) {
1323 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x14, "AEN drain failed during reset sequence");
1329 /* Load rest of compatibility struct */
1330 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
1331 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
1332 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
1333 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
1334 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
1335 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
1336 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
1337 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
1338 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
1339 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
1341 /* If we got here, controller is in a good state */
1347 } /* End twl_reset_sequence() */
1349 /* This function will reset a device extension */
1350 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1352 int i = 0, retval = 1;
1353 unsigned long flags = 0;
1355 /* Block SCSI requests while we are resetting */
1357 scsi_block_requests(tw_dev->host);
1359 set_bit(TW_IN_RESET, &tw_dev->flags);
1360 TWL_MASK_INTERRUPTS(tw_dev);
1361 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1363 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1365 /* Abort all requests that are in progress */
1366 for (i = 0; i < TW_Q_LENGTH; i++) {
1367 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1368 (tw_dev->state[i] != TW_S_INITIAL) &&
1369 (tw_dev->state[i] != TW_S_COMPLETED)) {
1370 struct scsi_cmnd *cmd = tw_dev->srb[i];
1373 cmd->result = (DID_RESET << 16);
1374 scsi_dma_unmap(cmd);
1375 cmd->scsi_done(cmd);
1380 /* Reset queues and counts */
1381 for (i = 0; i < TW_Q_LENGTH; i++) {
1382 tw_dev->free_queue[i] = i;
1383 tw_dev->state[i] = TW_S_INITIAL;
1385 tw_dev->free_head = TW_Q_START;
1386 tw_dev->free_tail = TW_Q_START;
1387 tw_dev->posted_request_count = 0;
1389 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1391 if (twl_reset_sequence(tw_dev, 1))
1394 TWL_UNMASK_INTERRUPTS(tw_dev);
1396 clear_bit(TW_IN_RESET, &tw_dev->flags);
1397 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1402 scsi_unblock_requests(tw_dev->host);
1404 } /* End twl_reset_device_extension() */
1406 /* This funciton returns unit geometry in cylinders/heads/sectors */
1407 static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1410 TW_Device_Extension *tw_dev;
1412 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1414 if (capacity >= 0x200000) {
1424 geom[2] = sector_div(capacity, heads * sectors); /* cylinders */
1427 } /* End twl_scsi_biosparam() */
1429 /* This is the new scsi eh reset function */
1430 static int twl_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1432 TW_Device_Extension *tw_dev = NULL;
1433 int retval = FAILED;
1435 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1437 tw_dev->num_resets++;
1439 sdev_printk(KERN_WARNING, SCpnt->device,
1440 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1441 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1443 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1444 mutex_lock(&tw_dev->ioctl_lock);
1446 /* Now reset the card and some of the device extension data */
1447 if (twl_reset_device_extension(tw_dev, 0)) {
1448 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "Controller reset failed during scsi host reset");
1454 mutex_unlock(&tw_dev->ioctl_lock);
1456 } /* End twl_scsi_eh_reset() */
1458 /* This is the main scsi queue function to handle scsi opcodes */
1459 static int twl_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1461 int request_id, retval;
1462 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1464 /* If we are resetting due to timed out ioctl, report as busy */
1465 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1466 retval = SCSI_MLQUEUE_HOST_BUSY;
1470 /* Save done function into scsi_cmnd struct */
1471 SCpnt->scsi_done = done;
1473 /* Get a free request id */
1474 twl_get_request_id(tw_dev, &request_id);
1476 /* Save the scsi command for use by the ISR */
1477 tw_dev->srb[request_id] = SCpnt;
1479 retval = twl_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1481 tw_dev->state[request_id] = TW_S_COMPLETED;
1482 twl_free_request_id(tw_dev, request_id);
1483 SCpnt->result = (DID_ERROR << 16);
1489 } /* End twl_scsi_queue() */
1491 static DEF_SCSI_QCMD(twl_scsi_queue)
1493 /* This function tells the controller to shut down */
1494 static void __twl_shutdown(TW_Device_Extension *tw_dev)
1496 /* Disable interrupts */
1497 TWL_MASK_INTERRUPTS(tw_dev);
1499 /* Free up the IRQ */
1500 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1502 printk(KERN_WARNING "3w-sas: Shutting down host %d.\n", tw_dev->host->host_no);
1504 /* Tell the card we are shutting down */
1505 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1506 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Connection shutdown failed");
1508 printk(KERN_WARNING "3w-sas: Shutdown complete.\n");
1511 /* Clear doorbell interrupt just before exit */
1512 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1513 } /* End __twl_shutdown() */
1515 /* Wrapper for __twl_shutdown */
1516 static void twl_shutdown(struct pci_dev *pdev)
1518 struct Scsi_Host *host = pci_get_drvdata(pdev);
1519 TW_Device_Extension *tw_dev;
1524 tw_dev = (TW_Device_Extension *)host->hostdata;
1527 __twl_shutdown(tw_dev);
1528 } /* End twl_shutdown() */
1530 /* This function configures unit settings when a unit is coming on-line */
1531 static int twl_slave_configure(struct scsi_device *sdev)
1533 /* Force 60 second timeout */
1534 blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
1537 } /* End twl_slave_configure() */
1539 /* scsi_host_template initializer */
1540 static struct scsi_host_template driver_template = {
1541 .module = THIS_MODULE,
1543 .queuecommand = twl_scsi_queue,
1544 .eh_host_reset_handler = twl_scsi_eh_reset,
1545 .bios_param = twl_scsi_biosparam,
1546 .change_queue_depth = scsi_change_queue_depth,
1547 .can_queue = TW_Q_LENGTH-2,
1548 .slave_configure = twl_slave_configure,
1550 .sg_tablesize = TW_LIBERATOR_MAX_SGL_LENGTH,
1551 .max_sectors = TW_MAX_SECTORS,
1552 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
1553 .shost_attrs = twl_host_attrs,
1558 /* This function will probe and initialize a card */
1559 static int twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1561 struct Scsi_Host *host = NULL;
1562 TW_Device_Extension *tw_dev;
1563 int retval = -ENODEV;
1564 int *ptr_phycount, phycount=0;
1566 retval = pci_enable_device(pdev);
1568 TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device");
1569 goto out_disable_device;
1572 pci_set_master(pdev);
1573 pci_try_set_mwi(pdev);
1575 if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) ||
1576 dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32))) {
1577 TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
1579 goto out_disable_device;
1582 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
1584 TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension");
1586 goto out_disable_device;
1588 tw_dev = shost_priv(host);
1590 /* Save values to device extension */
1591 tw_dev->host = host;
1592 tw_dev->tw_pci_dev = pdev;
1594 if (twl_initialize_device_extension(tw_dev)) {
1595 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension");
1597 goto out_free_device_extension;
1600 /* Request IO regions */
1601 retval = pci_request_regions(pdev, "3w-sas");
1603 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region");
1604 goto out_free_device_extension;
1607 /* Save base address, use region 1 */
1608 tw_dev->base_addr = pci_iomap(pdev, 1, 0);
1609 if (!tw_dev->base_addr) {
1610 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap");
1612 goto out_release_mem_region;
1615 /* Disable interrupts on the card */
1616 TWL_MASK_INTERRUPTS(tw_dev);
1618 /* Initialize the card */
1619 if (twl_reset_sequence(tw_dev, 0)) {
1620 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe");
1625 /* Set host specific parameters */
1626 host->max_id = TW_MAX_UNITS;
1627 host->max_cmd_len = TW_MAX_CDB_LEN;
1628 host->max_lun = TW_MAX_LUNS;
1629 host->max_channel = 0;
1631 /* Register the card with the kernel SCSI layer */
1632 retval = scsi_add_host(host, &pdev->dev);
1634 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed");
1638 pci_set_drvdata(pdev, host);
1640 printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n",
1642 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1643 TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH),
1644 (u64)pci_resource_start(pdev, 1), pdev->irq);
1646 ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE,
1647 TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH);
1649 phycount = le32_to_cpu(*(int *)ptr_phycount);
1651 printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n",
1653 (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1654 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
1655 (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE,
1656 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
1659 /* Try to enable MSI */
1660 if (use_msi && !pci_enable_msi(pdev))
1661 set_bit(TW_USING_MSI, &tw_dev->flags);
1663 /* Now setup the interrupt handler */
1664 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1666 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ");
1667 goto out_remove_host;
1670 twl_device_extension_list[twl_device_extension_count] = tw_dev;
1671 twl_device_extension_count++;
1673 /* Re-enable interrupts on the card */
1674 TWL_UNMASK_INTERRUPTS(tw_dev);
1676 /* Finally, scan the host */
1677 scsi_scan_host(host);
1679 /* Add sysfs binary files */
1680 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr))
1681 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read");
1682 if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr))
1683 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info");
1685 if (twl_major == -1) {
1686 if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0)
1687 TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device");
1693 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1694 pci_disable_msi(pdev);
1695 scsi_remove_host(host);
1697 iounmap(tw_dev->base_addr);
1698 out_release_mem_region:
1699 pci_release_regions(pdev);
1700 out_free_device_extension:
1701 twl_free_device_extension(tw_dev);
1702 scsi_host_put(host);
1704 pci_disable_device(pdev);
1707 } /* End twl_probe() */
1709 /* This function is called to remove a device */
1710 static void twl_remove(struct pci_dev *pdev)
1712 struct Scsi_Host *host = pci_get_drvdata(pdev);
1713 TW_Device_Extension *tw_dev;
1718 tw_dev = (TW_Device_Extension *)host->hostdata;
1720 if (!tw_dev->online)
1723 /* Remove sysfs binary files */
1724 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr);
1725 sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr);
1727 scsi_remove_host(tw_dev->host);
1729 /* Unregister character device */
1730 if (twl_major >= 0) {
1731 unregister_chrdev(twl_major, "twl");
1735 /* Shutdown the card */
1736 __twl_shutdown(tw_dev);
1738 /* Disable MSI if enabled */
1739 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1740 pci_disable_msi(pdev);
1742 /* Free IO remapping */
1743 iounmap(tw_dev->base_addr);
1745 /* Free up the mem region */
1746 pci_release_regions(pdev);
1748 /* Free up device extension resources */
1749 twl_free_device_extension(tw_dev);
1751 scsi_host_put(tw_dev->host);
1752 pci_disable_device(pdev);
1753 twl_device_extension_count--;
1754 } /* End twl_remove() */
1757 /* This function is called on PCI suspend */
1758 static int twl_suspend(struct pci_dev *pdev, pm_message_t state)
1760 struct Scsi_Host *host = pci_get_drvdata(pdev);
1761 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1763 printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no);
1764 /* Disable interrupts */
1765 TWL_MASK_INTERRUPTS(tw_dev);
1767 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1769 /* Tell the card we are shutting down */
1770 if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1771 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend");
1773 printk(KERN_WARNING "3w-sas: Suspend complete.\n");
1776 /* Clear doorbell interrupt */
1777 TWL_CLEAR_DB_INTERRUPT(tw_dev);
1779 pci_save_state(pdev);
1780 pci_disable_device(pdev);
1781 pci_set_power_state(pdev, pci_choose_state(pdev, state));
1784 } /* End twl_suspend() */
1786 /* This function is called on PCI resume */
1787 static int twl_resume(struct pci_dev *pdev)
1790 struct Scsi_Host *host = pci_get_drvdata(pdev);
1791 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1793 printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no);
1794 pci_set_power_state(pdev, PCI_D0);
1795 pci_enable_wake(pdev, PCI_D0, 0);
1796 pci_restore_state(pdev);
1798 retval = pci_enable_device(pdev);
1800 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x24, "Enable device failed during resume");
1804 pci_set_master(pdev);
1805 pci_try_set_mwi(pdev);
1807 if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) ||
1808 dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32))) {
1809 TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
1811 goto out_disable_device;
1814 /* Initialize the card */
1815 if (twl_reset_sequence(tw_dev, 0)) {
1817 goto out_disable_device;
1820 /* Now setup the interrupt handler */
1821 retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1823 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume");
1825 goto out_disable_device;
1828 /* Now enable MSI if enabled */
1829 if (test_bit(TW_USING_MSI, &tw_dev->flags))
1830 pci_enable_msi(pdev);
1832 /* Re-enable interrupts on the card */
1833 TWL_UNMASK_INTERRUPTS(tw_dev);
1835 printk(KERN_WARNING "3w-sas: Resume complete.\n");
1839 scsi_remove_host(host);
1840 pci_disable_device(pdev);
1843 } /* End twl_resume() */
1846 /* PCI Devices supported by this driver */
1847 static struct pci_device_id twl_pci_tbl[] = {
1848 { PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) },
1851 MODULE_DEVICE_TABLE(pci, twl_pci_tbl);
1853 /* pci_driver initializer */
1854 static struct pci_driver twl_driver = {
1856 .id_table = twl_pci_tbl,
1858 .remove = twl_remove,
1860 .suspend = twl_suspend,
1861 .resume = twl_resume,
1863 .shutdown = twl_shutdown
1866 /* This function is called on driver initialization */
1867 static int __init twl_init(void)
1869 printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
1871 return pci_register_driver(&twl_driver);
1872 } /* End twl_init() */
1874 /* This function is called on driver exit */
1875 static void __exit twl_exit(void)
1877 pci_unregister_driver(&twl_driver);
1878 } /* End twl_exit() */
1880 module_init(twl_init);
1881 module_exit(twl_exit);