Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/scsi/3w-sas.c

  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_inode(file);
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         .no_write_same          = 1,
1605 };
1606 
1607 /* This function will probe and initialize a card */
1608 static int twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1609 {
1610         struct Scsi_Host *host = NULL;
1611         TW_Device_Extension *tw_dev;
1612         int retval = -ENODEV;
1613         int *ptr_phycount, phycount=0;
1614 
1615         retval = pci_enable_device(pdev);
1616         if (retval) {
1617                 TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device");
1618                 goto out_disable_device;
1619         }
1620 
1621         pci_set_master(pdev);
1622         pci_try_set_mwi(pdev);
1623 
1624         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
1625             || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1626                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
1627                     || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
1628                         TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
1629                         retval = -ENODEV;
1630                         goto out_disable_device;
1631                 }
1632 
1633         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
1634         if (!host) {
1635                 TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension");
1636                 retval = -ENOMEM;
1637                 goto out_disable_device;
1638         }
1639         tw_dev = shost_priv(host);
1640 
1641         /* Save values to device extension */
1642         tw_dev->host = host;
1643         tw_dev->tw_pci_dev = pdev;
1644 
1645         if (twl_initialize_device_extension(tw_dev)) {
1646                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension");
1647                 goto out_free_device_extension;
1648         }
1649 
1650         /* Request IO regions */
1651         retval = pci_request_regions(pdev, "3w-sas");
1652         if (retval) {
1653                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region");
1654                 goto out_free_device_extension;
1655         }
1656 
1657         /* Save base address, use region 1 */
1658         tw_dev->base_addr = pci_iomap(pdev, 1, 0);
1659         if (!tw_dev->base_addr) {
1660                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap");
1661                 goto out_release_mem_region;
1662         }
1663 
1664         /* Disable interrupts on the card */
1665         TWL_MASK_INTERRUPTS(tw_dev);
1666 
1667         /* Initialize the card */
1668         if (twl_reset_sequence(tw_dev, 0)) {
1669                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe");
1670                 goto out_iounmap;
1671         }
1672 
1673         /* Set host specific parameters */
1674         host->max_id = TW_MAX_UNITS;
1675         host->max_cmd_len = TW_MAX_CDB_LEN;
1676         host->max_lun = TW_MAX_LUNS;
1677         host->max_channel = 0;
1678 
1679         /* Register the card with the kernel SCSI layer */
1680         retval = scsi_add_host(host, &pdev->dev);
1681         if (retval) {
1682                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed");
1683                 goto out_iounmap;
1684         }
1685 
1686         pci_set_drvdata(pdev, host);
1687 
1688         printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n",
1689                host->host_no,
1690                (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1691                                      TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH),
1692                (u64)pci_resource_start(pdev, 1), pdev->irq);
1693 
1694         ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE,
1695                                      TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH);
1696         if (ptr_phycount)
1697                 phycount = le32_to_cpu(*(int *)ptr_phycount);
1698 
1699         printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n",
1700                host->host_no,
1701                (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1702                                      TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
1703                (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE,
1704                                      TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
1705                phycount);
1706 
1707         /* Try to enable MSI */
1708         if (use_msi && !pci_enable_msi(pdev))
1709                 set_bit(TW_USING_MSI, &tw_dev->flags);
1710 
1711         /* Now setup the interrupt handler */
1712         retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1713         if (retval) {
1714                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ");
1715                 goto out_remove_host;
1716         }
1717 
1718         twl_device_extension_list[twl_device_extension_count] = tw_dev;
1719         twl_device_extension_count++;
1720 
1721         /* Re-enable interrupts on the card */
1722         TWL_UNMASK_INTERRUPTS(tw_dev);
1723         
1724         /* Finally, scan the host */
1725         scsi_scan_host(host);
1726 
1727         /* Add sysfs binary files */
1728         if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr))
1729                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read");
1730         if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr))
1731                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info");
1732 
1733         if (twl_major == -1) {
1734                 if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0)
1735                         TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device");
1736         }
1737         tw_dev->online = 1;
1738         return 0;
1739 
1740 out_remove_host:
1741         if (test_bit(TW_USING_MSI, &tw_dev->flags))
1742                 pci_disable_msi(pdev);
1743         scsi_remove_host(host);
1744 out_iounmap:
1745         iounmap(tw_dev->base_addr);
1746 out_release_mem_region:
1747         pci_release_regions(pdev);
1748 out_free_device_extension:
1749         twl_free_device_extension(tw_dev);
1750         scsi_host_put(host);
1751 out_disable_device:
1752         pci_disable_device(pdev);
1753 
1754         return retval;
1755 } /* End twl_probe() */
1756 
1757 /* This function is called to remove a device */
1758 static void twl_remove(struct pci_dev *pdev)
1759 {
1760         struct Scsi_Host *host = pci_get_drvdata(pdev);
1761         TW_Device_Extension *tw_dev;
1762 
1763         if (!host)
1764                 return;
1765 
1766         tw_dev = (TW_Device_Extension *)host->hostdata;
1767 
1768         if (!tw_dev->online)
1769                 return;
1770 
1771         /* Remove sysfs binary files */
1772         sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr);
1773         sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr);
1774 
1775         scsi_remove_host(tw_dev->host);
1776 
1777         /* Unregister character device */
1778         if (twl_major >= 0) {
1779                 unregister_chrdev(twl_major, "twl");
1780                 twl_major = -1;
1781         }
1782 
1783         /* Shutdown the card */
1784         __twl_shutdown(tw_dev);
1785 
1786         /* Disable MSI if enabled */
1787         if (test_bit(TW_USING_MSI, &tw_dev->flags))
1788                 pci_disable_msi(pdev);
1789 
1790         /* Free IO remapping */
1791         iounmap(tw_dev->base_addr);
1792 
1793         /* Free up the mem region */
1794         pci_release_regions(pdev);
1795 
1796         /* Free up device extension resources */
1797         twl_free_device_extension(tw_dev);
1798 
1799         scsi_host_put(tw_dev->host);
1800         pci_disable_device(pdev);
1801         twl_device_extension_count--;
1802 } /* End twl_remove() */
1803 
1804 #ifdef CONFIG_PM
1805 /* This function is called on PCI suspend */
1806 static int twl_suspend(struct pci_dev *pdev, pm_message_t state)
1807 {
1808         struct Scsi_Host *host = pci_get_drvdata(pdev);
1809         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1810 
1811         printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no);
1812         /* Disable interrupts */
1813         TWL_MASK_INTERRUPTS(tw_dev);
1814 
1815         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1816 
1817         /* Tell the card we are shutting down */
1818         if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1819                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend");
1820         } else {
1821                 printk(KERN_WARNING "3w-sas: Suspend complete.\n");
1822         }
1823 
1824         /* Clear doorbell interrupt */
1825         TWL_CLEAR_DB_INTERRUPT(tw_dev);
1826 
1827         pci_save_state(pdev);
1828         pci_disable_device(pdev);
1829         pci_set_power_state(pdev, pci_choose_state(pdev, state));
1830 
1831         return 0;
1832 } /* End twl_suspend() */
1833 
1834 /* This function is called on PCI resume */
1835 static int twl_resume(struct pci_dev *pdev)
1836 {
1837         int retval = 0;
1838         struct Scsi_Host *host = pci_get_drvdata(pdev);
1839         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1840 
1841         printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no);
1842         pci_set_power_state(pdev, PCI_D0);
1843         pci_enable_wake(pdev, PCI_D0, 0);
1844         pci_restore_state(pdev);
1845 
1846         retval = pci_enable_device(pdev);
1847         if (retval) {
1848                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x24, "Enable device failed during resume");
1849                 return retval;
1850         }
1851 
1852         pci_set_master(pdev);
1853         pci_try_set_mwi(pdev);
1854 
1855         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
1856             || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1857                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
1858                     || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
1859                         TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
1860                         retval = -ENODEV;
1861                         goto out_disable_device;
1862                 }
1863 
1864         /* Initialize the card */
1865         if (twl_reset_sequence(tw_dev, 0)) {
1866                 retval = -ENODEV;
1867                 goto out_disable_device;
1868         }
1869 
1870         /* Now setup the interrupt handler */
1871         retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1872         if (retval) {
1873                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume");
1874                 retval = -ENODEV;
1875                 goto out_disable_device;
1876         }
1877 
1878         /* Now enable MSI if enabled */
1879         if (test_bit(TW_USING_MSI, &tw_dev->flags))
1880                 pci_enable_msi(pdev);
1881 
1882         /* Re-enable interrupts on the card */
1883         TWL_UNMASK_INTERRUPTS(tw_dev);
1884 
1885         printk(KERN_WARNING "3w-sas: Resume complete.\n");
1886         return 0;
1887 
1888 out_disable_device:
1889         scsi_remove_host(host);
1890         pci_disable_device(pdev);
1891 
1892         return retval;
1893 } /* End twl_resume() */
1894 #endif
1895 
1896 /* PCI Devices supported by this driver */
1897 static struct pci_device_id twl_pci_tbl[] = {
1898         { PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) },
1899         { }
1900 };
1901 MODULE_DEVICE_TABLE(pci, twl_pci_tbl);
1902 
1903 /* pci_driver initializer */
1904 static struct pci_driver twl_driver = {
1905         .name           = "3w-sas",
1906         .id_table       = twl_pci_tbl,
1907         .probe          = twl_probe,
1908         .remove         = twl_remove,
1909 #ifdef CONFIG_PM
1910         .suspend        = twl_suspend,
1911         .resume         = twl_resume,
1912 #endif
1913         .shutdown       = twl_shutdown
1914 };
1915 
1916 /* This function is called on driver initialization */
1917 static int __init twl_init(void)
1918 {
1919         printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
1920 
1921         return pci_register_driver(&twl_driver);
1922 } /* End twl_init() */
1923 
1924 /* This function is called on driver exit */
1925 static void __exit twl_exit(void)
1926 {
1927         pci_unregister_driver(&twl_driver);
1928 } /* End twl_exit() */
1929 
1930 module_init(twl_init);
1931 module_exit(twl_exit);
1932 
1933 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us