Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/scsi/3w-9xxx.c

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

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