[SCSI] fcoe: fix fcoe module ref counting
[linux-2.6.git] / drivers / scsi / 3w-xxxx.c
1 /* 
2    3w-xxxx.c -- 3ware Storage Controller device driver for Linux.
3
4    Written By: Adam Radford <linuxraid@lsi.com>
5    Modifications By: Joel Jacobson <linux@3ware.com>
6                      Arnaldo Carvalho de Melo <acme@conectiva.com.br>
7                      Brad Strand <linux@3ware.com>
8
9    Copyright (C) 1999-2010 3ware Inc.
10
11    Kernel compatibility By:     Andre Hedrick <andre@suse.com>
12    Non-Copyright (C) 2000       Andre Hedrick <andre@suse.com>
13    
14    Further tiny build fixes and trivial hoovering    Alan Cox
15
16    This program is free software; you can redistribute it and/or modify
17    it under the terms of the GNU General Public License as published by
18    the Free Software Foundation; version 2 of the License.
19
20    This program is distributed in the hope that it will be useful,           
21    but WITHOUT ANY WARRANTY; without even the implied warranty of            
22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             
23    GNU General Public License for more details.                              
24
25    NO WARRANTY                                                               
26    THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR        
27    CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT      
28    LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,      
29    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is    
30    solely responsible for determining the appropriateness of using and       
31    distributing the Program and assumes all risks associated with its        
32    exercise of rights under this Agreement, including but not limited to     
33    the risks and costs of program errors, damage to or loss of data,         
34    programs or equipment, and unavailability or interruption of operations.  
35
36    DISCLAIMER OF LIABILITY                                                   
37    NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY   
38    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL        
39    DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND   
40    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR     
41    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE    
42    USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED  
43    HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES             
44
45    You should have received a copy of the GNU General Public License         
46    along with this program; if not, write to the Free Software               
47    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
48
49    Bugs/Comments/Suggestions should be mailed to:                            
50    linuxraid@lsi.com
51
52    For more information, goto:
53    http://www.lsi.com
54
55    History
56    -------
57    0.1.000 -     Initial release.
58    0.4.000 -     Added support for Asynchronous Event Notification through
59                  ioctls for 3DM.
60    1.0.000 -     Added DPO & FUA bit support for WRITE_10 & WRITE_6 cdb
61                  to disable drive write-cache before writes.
62    1.1.000 -     Fixed performance bug with DPO & FUA not existing for WRITE_6.
63    1.2.000 -     Added support for clean shutdown notification/feature table.
64    1.02.00.001 - Added support for full command packet posts through ioctls
65                  for 3DM.
66                  Bug fix so hot spare drives don't show up.
67    1.02.00.002 - Fix bug with tw_setfeature() call that caused oops on some
68                  systems.
69    08/21/00    - release previously allocated resources on failure at
70                  tw_allocate_memory (acme)
71    1.02.00.003 - Fix tw_interrupt() to report error to scsi layer when
72                  controller status is non-zero.
73                  Added handling of request_sense opcode.
74                  Fix possible null pointer dereference in 
75                  tw_reset_device_extension()
76    1.02.00.004 - Add support for device id of 3ware 7000 series controllers.
77                  Make tw_setfeature() call with interrupts disabled.
78                  Register interrupt handler before enabling interrupts.
79                  Clear attention interrupt before draining aen queue.
80    1.02.00.005 - Allocate bounce buffers and custom queue depth for raid5 for
81                  6000 and 5000 series controllers.
82                  Reduce polling mdelays causing problems on some systems.
83                  Fix use_sg = 1 calculation bug.
84                  Check for scsi_register returning NULL.
85                  Add aen count to /proc/scsi/3w-xxxx.
86                  Remove aen code unit masking in tw_aen_complete().
87    1.02.00.006 - Remove unit from printk in tw_scsi_eh_abort(), causing
88                  possible oops.
89                  Fix possible null pointer dereference in tw_scsi_queue()
90                  if done function pointer was invalid.
91    1.02.00.007 - Fix possible null pointer dereferences in tw_ioctl().
92                  Remove check for invalid done function pointer from
93                  tw_scsi_queue().
94    1.02.00.008 - Set max sectors per io to TW_MAX_SECTORS in tw_findcards().
95                  Add tw_decode_error() for printing readable error messages.
96                  Print some useful information on certain aen codes.
97                  Add tw_decode_bits() for interpreting status register output.
98                  Make scsi_set_pci_device() for kernels >= 2.4.4
99                  Fix bug where aen's could be lost before a reset.
100                  Re-add spinlocks in tw_scsi_detect().
101                  Fix possible null pointer dereference in tw_aen_drain_queue()
102                  during initialization.
103                  Clear pci parity errors during initialization and during io.
104    1.02.00.009 - Remove redundant increment in tw_state_request_start().
105                  Add ioctl support for direct ATA command passthru.
106                  Add entire aen code string list.
107    1.02.00.010 - Cleanup queueing code, fix jbod thoughput.
108                  Fix get_param for specific units.
109    1.02.00.011 - Fix bug in tw_aen_complete() where aen's could be lost.
110                  Fix tw_aen_drain_queue() to display useful info at init.
111                  Set tw_host->max_id for 12 port cards.
112                  Add ioctl support for raw command packet post from userspace
113                  with sglist fragments (parameter and io).
114    1.02.00.012 - Fix read capacity to under report by 1 sector to fix get
115                  last sector ioctl.
116    1.02.00.013 - Fix bug where more AEN codes weren't coming out during
117                  driver initialization.
118                  Improved handling of PCI aborts.
119    1.02.00.014 - Fix bug in tw_findcards() where AEN code could be lost.
120                  Increase timeout in tw_aen_drain_queue() to 30 seconds.
121    1.02.00.015 - Re-write raw command post with data ioctl method.
122                  Remove raid5 bounce buffers for raid5 for 6XXX for kernel 2.5
123                  Add tw_map/unmap_scsi_sg/single_data() for kernel 2.5
124                  Replace io_request_lock with host_lock for kernel 2.5
125                  Set max_cmd_len to 16 for 3dm for kernel 2.5
126    1.02.00.016 - Set host->max_sectors back up to 256.
127    1.02.00.017 - Modified pci parity error handling/clearing from config space
128                  during initialization.
129    1.02.00.018 - Better handling of request sense opcode and sense information
130                  for failed commands.  Add tw_decode_sense().
131                  Replace all mdelay()'s with scsi_sleep().
132    1.02.00.019 - Revert mdelay's and scsi_sleep's, this caused problems on
133                  some SMP systems.
134    1.02.00.020 - Add pci_set_dma_mask(), rewrite kmalloc()/virt_to_bus() to
135                  pci_alloc/free_consistent().
136                  Better alignment checking in tw_allocate_memory().
137                  Cleanup tw_initialize_device_extension().
138    1.02.00.021 - Bump cmd_per_lun in SHT to 255 for better jbod performance.
139                  Improve handling of errors in tw_interrupt().
140                  Add handling/clearing of controller queue error.
141                  Empty stale responses before draining aen queue.
142                  Fix tw_scsi_eh_abort() to not reset on every io abort.
143                  Set can_queue in SHT to 255 to prevent hang from AEN.
144    1.02.00.022 - Fix possible null pointer dereference in tw_scsi_release().
145    1.02.00.023 - Fix bug in tw_aen_drain_queue() where unit # was always zero.
146    1.02.00.024 - Add severity levels to AEN strings.
147    1.02.00.025 - Fix command interrupt spurious error messages.
148                  Fix bug in raw command post with data ioctl method.
149                  Fix bug where rollcall sometimes failed with cable errors.
150                  Print unit # on all command timeouts.
151    1.02.00.026 - Fix possible infinite retry bug with power glitch induced
152                  drive timeouts.
153                  Cleanup some AEN severity levels.
154    1.02.00.027 - Add drive not supported AEN code for SATA controllers.
155                  Remove spurious unknown ioctl error message.
156    1.02.00.028 - Fix bug where multiple controllers with no units were the
157                  same card number.
158                  Fix bug where cards were being shut down more than once.
159    1.02.00.029 - Add missing pci_free_consistent() in tw_allocate_memory().
160                  Replace pci_map_single() with pci_map_page() for highmem.
161                  Check for tw_setfeature() failure.
162    1.02.00.030 - Make driver 64-bit clean.
163    1.02.00.031 - Cleanup polling timeouts/routines in several places.
164                  Add support for mode sense opcode.
165                  Add support for cache mode page.
166                  Add support for synchronize cache opcode.
167    1.02.00.032 - Fix small multicard rollcall bug.
168                  Make driver stay loaded with no units for hot add/swap.
169                  Add support for "twe" character device for ioctls.
170                  Clean up request_id queueing code.
171                  Fix tw_scsi_queue() spinlocks.
172    1.02.00.033 - Fix tw_aen_complete() to not queue 'queue empty' AEN's.
173                  Initialize queues correctly when loading with no valid units.
174    1.02.00.034 - Fix tw_decode_bits() to handle multiple errors.
175                  Add support for user configurable cmd_per_lun.
176                  Add support for sht->slave_configure().
177    1.02.00.035 - Improve tw_allocate_memory() memory allocation.
178                  Fix tw_chrdev_ioctl() to sleep correctly.
179    1.02.00.036 - Increase character ioctl timeout to 60 seconds.
180    1.02.00.037 - Fix tw_ioctl() to handle all non-data ATA passthru cmds
181                  for 'smartmontools' support.
182    1.26.00.038 - Roll driver minor version to 26 to denote kernel 2.6.
183                  Add support for cmds_per_lun module parameter.
184    1.26.00.039 - Fix bug in tw_chrdev_ioctl() polling code.
185                  Fix data_buffer_length usage in tw_chrdev_ioctl().
186                  Update contact information.
187    1.26.02.000 - Convert driver to pci_driver format.
188    1.26.02.001 - Increase max ioctl buffer size to 512 sectors.
189                  Make tw_scsi_queue() return 0 for 'Unknown scsi opcode'.
190                  Fix tw_remove() to free irq handler/unregister_chrdev()
191                  before shutting down card.
192                  Change to new 'change_queue_depth' api.
193                  Fix 'handled=1' ISR usage, remove bogus IRQ check.
194    1.26.02.002 - Free irq handler in __tw_shutdown().
195                  Turn on RCD bit for caching mode page.
196                  Serialize reset code.
197    1.26.02.003 - Force 60 second timeout default.
198 */
199
200 #include <linux/module.h>
201 #include <linux/reboot.h>
202 #include <linux/smp_lock.h>
203 #include <linux/spinlock.h>
204 #include <linux/interrupt.h>
205 #include <linux/moduleparam.h>
206 #include <linux/errno.h>
207 #include <linux/types.h>
208 #include <linux/delay.h>
209 #include <linux/gfp.h>
210 #include <linux/pci.h>
211 #include <linux/time.h>
212 #include <linux/mutex.h>
213 #include <asm/io.h>
214 #include <asm/irq.h>
215 #include <asm/uaccess.h>
216 #include <scsi/scsi.h>
217 #include <scsi/scsi_host.h>
218 #include <scsi/scsi_tcq.h>
219 #include <scsi/scsi_cmnd.h>
220 #include "3w-xxxx.h"
221
222 /* Globals */
223 #define TW_DRIVER_VERSION "1.26.02.003"
224 static TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT];
225 static int tw_device_extension_count = 0;
226 static int twe_major = -1;
227
228 /* Module parameters */
229 MODULE_AUTHOR("LSI");
230 MODULE_DESCRIPTION("3ware Storage Controller Linux Driver");
231 MODULE_LICENSE("GPL");
232 MODULE_VERSION(TW_DRIVER_VERSION);
233
234 /* Function prototypes */
235 static int tw_reset_device_extension(TW_Device_Extension *tw_dev);
236
237 /* Functions */
238
239 /* This function will check the status register for unexpected bits */
240 static int tw_check_bits(u32 status_reg_value)
241 {
242         if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) {  
243                 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value);
244                 return 1;
245         }
246         if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) {
247                 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value);
248                 return 1;
249         }
250
251         return 0;
252 } /* End tw_check_bits() */
253
254 /* This function will print readable messages from status register errors */
255 static int tw_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value, int print_host)
256 {
257         char host[16];
258
259         dprintk(KERN_WARNING "3w-xxxx: tw_decode_bits()\n");
260
261         if (print_host)
262                 sprintf(host, " scsi%d:", tw_dev->host->host_no);
263         else
264                 host[0] = '\0';
265
266         if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
267                 printk(KERN_WARNING "3w-xxxx:%s PCI Parity Error: clearing.\n", host);
268                 outl(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
269         }
270
271         if (status_reg_value & TW_STATUS_PCI_ABORT) {
272                 printk(KERN_WARNING "3w-xxxx:%s PCI Abort: clearing.\n", host);
273                 outl(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
274                 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
275         }
276
277         if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
278                 printk(KERN_WARNING "3w-xxxx:%s Controller Queue Error: clearing.\n", host);
279                 outl(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
280         }
281
282         if (status_reg_value & TW_STATUS_SBUF_WRITE_ERROR) {
283                 printk(KERN_WARNING "3w-xxxx:%s SBUF Write Error: clearing.\n", host);
284                 outl(TW_CONTROL_CLEAR_SBUF_WRITE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
285         }
286
287         if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
288                 if (tw_dev->reset_print == 0) {
289                         printk(KERN_WARNING "3w-xxxx:%s Microcontroller Error: clearing.\n", host);
290                         tw_dev->reset_print = 1;
291                 }
292                 return 1;
293         }
294         
295         return 0;
296 } /* End tw_decode_bits() */
297
298 /* This function will poll the status register for a flag */
299 static int tw_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
300 {
301         u32 status_reg_value;
302         unsigned long before;
303         int retval = 1;
304
305         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
306         before = jiffies;
307
308         if (tw_check_bits(status_reg_value))
309                 tw_decode_bits(tw_dev, status_reg_value, 0);
310
311         while ((status_reg_value & flag) != flag) {
312                 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
313
314                 if (tw_check_bits(status_reg_value))
315                         tw_decode_bits(tw_dev, status_reg_value, 0);
316
317                 if (time_after(jiffies, before + HZ * seconds))
318                         goto out;
319
320                 msleep(50);
321         }
322         retval = 0;
323 out:
324         return retval;
325 } /* End tw_poll_status() */
326
327 /* This function will poll the status register for disappearance of a flag */
328 static int tw_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
329 {
330         u32 status_reg_value;
331         unsigned long before;
332         int retval = 1;
333
334         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
335         before = jiffies;
336
337         if (tw_check_bits(status_reg_value))
338                 tw_decode_bits(tw_dev, status_reg_value, 0);
339
340         while ((status_reg_value & flag) != 0) {
341                 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
342
343                 if (tw_check_bits(status_reg_value))
344                         tw_decode_bits(tw_dev, status_reg_value, 0);
345
346                 if (time_after(jiffies, before + HZ * seconds))
347                         goto out;
348
349                 msleep(50);
350         }
351         retval = 0;
352 out:
353         return retval;
354 } /* End tw_poll_status_gone() */
355
356 /* This function will attempt to post a command packet to the board */
357 static int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
358 {
359         u32 status_reg_value;
360         unsigned long command_que_value;
361
362         dprintk(KERN_NOTICE "3w-xxxx: tw_post_command_packet()\n");
363         command_que_value = tw_dev->command_packet_physical_address[request_id];
364         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
365
366         if (tw_check_bits(status_reg_value)) {
367                 dprintk(KERN_WARNING "3w-xxxx: tw_post_command_packet(): Unexpected bits.\n");
368                 tw_decode_bits(tw_dev, status_reg_value, 1);
369         }
370
371         if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
372                 /* We successfully posted the command packet */
373                 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
374                 tw_dev->state[request_id] = TW_S_POSTED;
375                 tw_dev->posted_request_count++;
376                 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
377                         tw_dev->max_posted_request_count = tw_dev->posted_request_count;
378                 }
379         } else {
380                 /* Couldn't post the command packet, so we do it in the isr */
381                 if (tw_dev->state[request_id] != TW_S_PENDING) {
382                         tw_dev->state[request_id] = TW_S_PENDING;
383                         tw_dev->pending_request_count++;
384                         if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
385                                 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
386                         }
387                         tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
388                         if (tw_dev->pending_tail == TW_Q_LENGTH-1) {
389                                 tw_dev->pending_tail = TW_Q_START;
390                         } else {
391                                 tw_dev->pending_tail = tw_dev->pending_tail + 1;
392                         }
393                 } 
394                 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
395                 return 1;
396         }
397         return 0;
398 } /* End tw_post_command_packet() */
399
400 /* This function will return valid sense buffer information for failed cmds */
401 static int tw_decode_sense(TW_Device_Extension *tw_dev, int request_id, int fill_sense)
402 {
403         int i;
404         TW_Command *command;
405
406         dprintk(KERN_WARNING "3w-xxxx: tw_decode_sense()\n");
407         command = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
408
409         printk(KERN_WARNING "3w-xxxx: scsi%d: Command failed: status = 0x%x, flags = 0x%x, unit #%d.\n", tw_dev->host->host_no, command->status, command->flags, TW_UNIT_OUT(command->unit__hostid));
410
411         /* Attempt to return intelligent sense information */
412         if (fill_sense) {
413                 if ((command->status == 0xc7) || (command->status == 0xcb)) {
414                         for (i = 0; i < ARRAY_SIZE(tw_sense_table); i++) {
415                                 if (command->flags == tw_sense_table[i][0]) {
416
417                                         /* Valid bit and 'current errors' */
418                                         tw_dev->srb[request_id]->sense_buffer[0] = (0x1 << 7 | 0x70);
419
420                                         /* Sense key */
421                                         tw_dev->srb[request_id]->sense_buffer[2] = tw_sense_table[i][1];
422
423                                         /* Additional sense length */
424                                         tw_dev->srb[request_id]->sense_buffer[7] = 0xa; /* 10 bytes */
425
426                                         /* Additional sense code */
427                                         tw_dev->srb[request_id]->sense_buffer[12] = tw_sense_table[i][2];
428
429                                         /* Additional sense code qualifier */
430                                         tw_dev->srb[request_id]->sense_buffer[13] = tw_sense_table[i][3];
431
432                                         tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
433                                         return TW_ISR_DONT_RESULT; /* Special case for isr to not over-write result */
434                                 }
435                         }
436                 }
437
438                 /* If no table match, error so we get a reset */
439                 return 1;
440         }
441
442         return 0;
443 } /* End tw_decode_sense() */
444
445 /* This function will report controller error status */
446 static int tw_check_errors(TW_Device_Extension *tw_dev) 
447 {
448         u32 status_reg_value;
449   
450         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
451
452         if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) {
453                 tw_decode_bits(tw_dev, status_reg_value, 0);
454                 return 1;
455         }
456
457         return 0;
458 } /* End tw_check_errors() */
459
460 /* This function will empty the response que */
461 static void tw_empty_response_que(TW_Device_Extension *tw_dev) 
462 {
463         u32 status_reg_value, response_que_value;
464
465         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
466
467         while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
468                 response_que_value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
469                 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
470         }
471 } /* End tw_empty_response_que() */
472
473 /* This function will free a request_id */
474 static void tw_state_request_finish(TW_Device_Extension *tw_dev, int request_id)
475 {
476         tw_dev->free_queue[tw_dev->free_tail] = request_id;
477         tw_dev->state[request_id] = TW_S_FINISHED;
478         tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
479 } /* End tw_state_request_finish() */
480
481 /* This function will assign an available request_id */
482 static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id)
483 {
484         *request_id = tw_dev->free_queue[tw_dev->free_head];
485         tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
486         tw_dev->state[*request_id] = TW_S_STARTED;
487 } /* End tw_state_request_start() */
488
489 /* Show some statistics about the card */
490 static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr,
491                              char *buf)
492 {
493         struct Scsi_Host *host = class_to_shost(dev);
494         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
495         unsigned long flags = 0;
496         ssize_t len;
497
498         spin_lock_irqsave(tw_dev->host->host_lock, flags);
499         len = snprintf(buf, PAGE_SIZE, "3w-xxxx Driver version: %s\n"
500                        "Current commands posted:   %4d\n"
501                        "Max commands posted:       %4d\n"
502                        "Current pending commands:  %4d\n"
503                        "Max pending commands:      %4d\n"
504                        "Last sgl length:           %4d\n"
505                        "Max sgl length:            %4d\n"
506                        "Last sector count:         %4d\n"
507                        "Max sector count:          %4d\n"
508                        "SCSI Host Resets:          %4d\n"
509                        "AEN's:                     %4d\n", 
510                        TW_DRIVER_VERSION,
511                        tw_dev->posted_request_count,
512                        tw_dev->max_posted_request_count,
513                        tw_dev->pending_request_count,
514                        tw_dev->max_pending_request_count,
515                        tw_dev->sgl_entries,
516                        tw_dev->max_sgl_entries,
517                        tw_dev->sector_count,
518                        tw_dev->max_sector_count,
519                        tw_dev->num_resets,
520                        tw_dev->aen_count);
521         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
522         return len;
523 } /* End tw_show_stats() */
524
525 /* This function will set a devices queue depth */
526 static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth,
527                                  int reason)
528 {
529         if (reason != SCSI_QDEPTH_DEFAULT)
530                 return -EOPNOTSUPP;
531
532         if (queue_depth > TW_Q_LENGTH-2)
533                 queue_depth = TW_Q_LENGTH-2;
534         scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
535         return queue_depth;
536 } /* End tw_change_queue_depth() */
537
538 /* Create sysfs 'stats' entry */
539 static struct device_attribute tw_host_stats_attr = {
540         .attr = {
541                 .name =         "stats",
542                 .mode =         S_IRUGO,
543         },
544         .show = tw_show_stats
545 };
546
547 /* Host attributes initializer */
548 static struct device_attribute *tw_host_attrs[] = {
549         &tw_host_stats_attr,
550         NULL,
551 };
552
553 /* This function will read the aen queue from the isr */
554 static int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id) 
555 {
556         TW_Command *command_packet;
557         TW_Param *param;
558         unsigned long command_que_value;
559         u32 status_reg_value;
560         unsigned long param_value = 0;
561
562         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n");
563
564         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
565         if (tw_check_bits(status_reg_value)) {
566                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n");
567                 tw_decode_bits(tw_dev, status_reg_value, 1);
568                 return 1;
569         }
570         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
571                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n");
572                 return 1;
573         }
574         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
575         memset(command_packet, 0, sizeof(TW_Sector));
576         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
577         command_packet->size = 4;
578         command_packet->request_id = request_id;
579         command_packet->status = 0;
580         command_packet->flags = 0;
581         command_packet->byte6.parameter_count = 1;
582         command_que_value = tw_dev->command_packet_physical_address[request_id];
583         if (command_que_value == 0) {
584                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n");
585                 return 1;
586         }
587         /* Now setup the param */
588         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
589                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n");
590                 return 1;
591         }
592         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
593         memset(param, 0, sizeof(TW_Sector));
594         param->table_id = 0x401; /* AEN table */
595         param->parameter_id = 2; /* Unit code */
596         param->parameter_size_bytes = 2;
597         param_value = tw_dev->alignment_physical_address[request_id];
598         if (param_value == 0) {
599                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n");
600                 return 1;
601         }
602         command_packet->byte8.param.sgl[0].address = param_value;
603         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
604
605         /* Now post the command packet */
606         if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
607                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n");
608                 tw_dev->srb[request_id] = NULL; /* Flag internal command */
609                 tw_dev->state[request_id] = TW_S_POSTED;
610                 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
611         } else {
612                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n");
613                 return 1;
614         }
615
616         return 0;
617 } /* End tw_aen_read_queue() */
618
619 /* This function will complete an aen request from the isr */
620 static int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id) 
621 {
622         TW_Param *param;
623         unsigned short aen;
624         int error = 0, table_max = 0;
625
626         dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n");
627         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
628                 printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n");
629                 return 1;
630         }
631         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
632         aen = *(unsigned short *)(param->data);
633         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen);
634
635         /* Print some useful info when certain aen codes come out */
636         if (aen == 0x0ff) {
637                 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no);
638         } else {
639                 table_max = ARRAY_SIZE(tw_aen_string);
640                 if ((aen & 0x0ff) < table_max) {
641                         if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
642                                 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8);
643                         } else {
644                                 if (aen != 0x0) 
645                                         printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]);
646                         }
647                 } else {
648                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen);
649                 }
650         }
651         if (aen != TW_AEN_QUEUE_EMPTY) {
652                 tw_dev->aen_count++;
653
654                 /* Now queue the code */
655                 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
656                 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
657                         tw_dev->aen_tail = TW_Q_START;
658                 } else {
659                         tw_dev->aen_tail = tw_dev->aen_tail + 1;
660                 }
661                 if (tw_dev->aen_head == tw_dev->aen_tail) {
662                         if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
663                                 tw_dev->aen_head = TW_Q_START;
664                         } else {
665                                 tw_dev->aen_head = tw_dev->aen_head + 1;
666                         }
667                 }
668
669                 error = tw_aen_read_queue(tw_dev, request_id);
670                 if (error) {
671                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no);
672                         tw_dev->state[request_id] = TW_S_COMPLETED;
673                         tw_state_request_finish(tw_dev, request_id);
674                 }
675         } else {
676                 tw_dev->state[request_id] = TW_S_COMPLETED;
677                 tw_state_request_finish(tw_dev, request_id);
678         }
679
680         return 0;
681 } /* End tw_aen_complete() */
682
683 /* This function will drain the aen queue after a soft reset */
684 static int tw_aen_drain_queue(TW_Device_Extension *tw_dev)
685 {
686         TW_Command *command_packet;
687         TW_Param *param;
688         int request_id = 0;
689         unsigned long command_que_value;
690         unsigned long param_value;
691         TW_Response_Queue response_queue;
692         unsigned short aen;
693         unsigned short aen_code;
694         int finished = 0;
695         int first_reset = 0;
696         int queue = 0;
697         int found = 0, table_max = 0;
698
699         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n");
700
701         if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) {
702                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count);
703                 return 1;
704         }
705         TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
706
707         /* Empty response queue */
708         tw_empty_response_que(tw_dev);
709
710         /* Initialize command packet */
711         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
712                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n");
713                 return 1;
714         }
715         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
716         memset(command_packet, 0, sizeof(TW_Sector));
717         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
718         command_packet->size = 4;
719         command_packet->request_id = request_id;
720         command_packet->status = 0;
721         command_packet->flags = 0;
722         command_packet->byte6.parameter_count = 1;
723         command_que_value = tw_dev->command_packet_physical_address[request_id];
724         if (command_que_value == 0) {
725                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n");
726                 return 1;
727         }
728
729         /* Now setup the param */
730         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
731                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n");
732                 return 1;
733         }
734         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
735         memset(param, 0, sizeof(TW_Sector));
736         param->table_id = 0x401; /* AEN table */
737         param->parameter_id = 2; /* Unit code */
738         param->parameter_size_bytes = 2;
739         param_value = tw_dev->alignment_physical_address[request_id];
740         if (param_value == 0) {
741                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n");
742                 return 1;
743         }
744         command_packet->byte8.param.sgl[0].address = param_value;
745         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
746
747         /* Now drain the controller's aen queue */
748         do {
749                 /* Post command packet */
750                 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
751
752                 /* Now poll for completion */
753                 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
754                         response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
755                         request_id = TW_RESID_OUT(response_queue.response_id);
756
757                         if (request_id != 0) {
758                                 /* Unexpected request id */
759                                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n");
760                                 return 1;
761                         }
762                         
763                         if (command_packet->status != 0) {
764                                 if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) {
765                                         /* Bad response */
766                                         tw_decode_sense(tw_dev, request_id, 0);
767                                         return 1;
768                                 } else {
769                                         /* We know this is a 3w-1x00, and doesn't support aen's */
770                                         return 0;
771                                 }
772                         }
773
774                         /* Now check the aen */
775                         aen = *(unsigned short *)(param->data);
776                         aen_code = (aen & 0x0ff);
777                         queue = 0;
778                         switch (aen_code) {
779                                 case TW_AEN_QUEUE_EMPTY:
780                                         dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
781                                         if (first_reset != 1) {
782                                                 return 1;
783                                         } else {
784                                                 finished = 1;
785                                         }
786                                         break;
787                                 case TW_AEN_SOFT_RESET:
788                                         if (first_reset == 0) {
789                                                 first_reset = 1;
790                                         } else {
791                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
792                                                 tw_dev->aen_count++;
793                                                 queue = 1;
794                                         }
795                                         break;
796                                 default:
797                                         if (aen == 0x0ff) {
798                                                 printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n");
799                                         } else {
800                                                 table_max = ARRAY_SIZE(tw_aen_string);
801                                                 if ((aen & 0x0ff) < table_max) {
802                                                         if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
803                                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8);
804                                                         } else {
805                                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
806                                                         }
807                                                 } else
808                                                         printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen);
809                                         }
810                                         tw_dev->aen_count++;
811                                         queue = 1;
812                         }
813
814                         /* Now put the aen on the aen_queue */
815                         if (queue == 1) {
816                                 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
817                                 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
818                                         tw_dev->aen_tail = TW_Q_START;
819                                 } else {
820                                         tw_dev->aen_tail = tw_dev->aen_tail + 1;
821                                 }
822                                 if (tw_dev->aen_head == tw_dev->aen_tail) {
823                                         if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
824                                                 tw_dev->aen_head = TW_Q_START;
825                                         } else {
826                                                 tw_dev->aen_head = tw_dev->aen_head + 1;
827                                         }
828                                 }
829                         }
830                         found = 1;
831                 }
832                 if (found == 0) {
833                         printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n");
834                         return 1;
835                 }
836         } while (finished == 0);
837
838         return 0;
839 } /* End tw_aen_drain_queue() */
840
841 /* This function will allocate memory */
842 static int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
843 {
844         int i;
845         dma_addr_t dma_handle;
846         unsigned long *cpu_addr = NULL;
847
848         dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");
849
850         cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
851         if (cpu_addr == NULL) {
852                 printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n");
853                 return 1;
854         }
855
856         if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {
857                 printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");
858                 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
859                 return 1;
860         }
861
862         memset(cpu_addr, 0, size*TW_Q_LENGTH);
863
864         for (i=0;i<TW_Q_LENGTH;i++) {
865                 switch(which) {
866                 case 0:
867                         tw_dev->command_packet_physical_address[i] = dma_handle+(i*size);
868                         tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
869                         break;
870                 case 1:
871                         tw_dev->alignment_physical_address[i] = dma_handle+(i*size);
872                         tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
873                         break;
874                 default:
875                         printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n");
876                         return 1;
877                 }
878         }
879
880         return 0;
881 } /* End tw_allocate_memory() */
882
883 /* This function handles ioctl for the character device */
884 static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
885 {
886         int request_id;
887         dma_addr_t dma_handle;
888         unsigned short tw_aen_code;
889         unsigned long flags;
890         unsigned int data_buffer_length = 0;
891         unsigned long data_buffer_length_adjusted = 0;
892         unsigned long *cpu_addr;
893         long timeout;
894         TW_New_Ioctl *tw_ioctl;
895         TW_Passthru *passthru;
896         TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)];
897         int retval = -EFAULT;
898         void __user *argp = (void __user *)arg;
899
900         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
901
902         /* Only let one of these through at a time */
903         if (mutex_lock_interruptible(&tw_dev->ioctl_lock))
904                 return -EINTR;
905
906         /* First copy down the buffer length */
907         if (copy_from_user(&data_buffer_length, argp, sizeof(unsigned int)))
908                 goto out;
909
910         /* Check size */
911         if (data_buffer_length > TW_MAX_IOCTL_SECTORS * 512) {
912                 retval = -EINVAL;
913                 goto out;
914         }
915
916         /* Hardware can only do multiple of 512 byte transfers */
917         data_buffer_length_adjusted = (data_buffer_length + 511) & ~511;
918         
919         /* Now allocate ioctl buf memory */
920         cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle, GFP_KERNEL);
921         if (cpu_addr == NULL) {
922                 retval = -ENOMEM;
923                 goto out;
924         }
925
926         tw_ioctl = (TW_New_Ioctl *)cpu_addr;
927
928         /* Now copy down the entire ioctl */
929         if (copy_from_user(tw_ioctl, argp, data_buffer_length + sizeof(TW_New_Ioctl) - 1))
930                 goto out2;
931
932         passthru = (TW_Passthru *)&tw_ioctl->firmware_command;
933
934         /* See which ioctl we are doing */
935         switch (cmd) {
936                 case TW_OP_NOP:
937                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n");
938                         break;
939                 case TW_OP_AEN_LISTEN:
940                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n");
941                         memset(tw_ioctl->data_buffer, 0, data_buffer_length);
942
943                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
944                         if (tw_dev->aen_head == tw_dev->aen_tail) {
945                                 tw_aen_code = TW_AEN_QUEUE_EMPTY;
946                         } else {
947                                 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
948                                 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
949                                         tw_dev->aen_head = TW_Q_START;
950                                 } else {
951                                         tw_dev->aen_head = tw_dev->aen_head + 1;
952                                 }
953                         }
954                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
955                         memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code));
956                         break;
957                 case TW_CMD_PACKET_WITH_DATA:
958                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
959                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
960
961                         tw_state_request_start(tw_dev, &request_id);
962
963                         /* Flag internal command */
964                         tw_dev->srb[request_id] = NULL;
965
966                         /* Flag chrdev ioctl */
967                         tw_dev->chrdev_request_id = request_id;
968
969                         tw_ioctl->firmware_command.request_id = request_id;
970
971                         /* Load the sg list */
972                         switch (TW_SGL_OUT(tw_ioctl->firmware_command.opcode__sgloffset)) {
973                         case 2:
974                                 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
975                                 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted;
976                                 break;
977                         case 3:
978                                 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
979                                 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted;
980                                 break;
981                         case 5:
982                                 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
983                                 passthru->sg_list[0].length = data_buffer_length_adjusted;
984                                 break;
985                         }
986
987                         memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command));
988
989                         /* Now post the command packet to the controller */
990                         tw_post_command_packet(tw_dev, request_id);
991                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
992
993                         timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
994
995                         /* Now wait for the command to complete */
996                         timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
997
998                         /* We timed out, and didn't get an interrupt */
999                         if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
1000                                 /* Now we need to reset the board */
1001                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd);
1002                                 retval = -EIO;
1003                                 if (tw_reset_device_extension(tw_dev)) {
1004                                         printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no);
1005                                 }
1006                                 goto out2;
1007                         }
1008
1009                         /* Now copy in the command packet response */
1010                         memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
1011
1012                         /* Now complete the io */
1013                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1014                         tw_dev->posted_request_count--;
1015                         tw_dev->state[request_id] = TW_S_COMPLETED;
1016                         tw_state_request_finish(tw_dev, request_id);
1017                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1018                         break;
1019                 default:
1020                         retval = -ENOTTY;
1021                         goto out2;
1022         }
1023
1024         /* Now copy the response to userspace */
1025         if (copy_to_user(argp, tw_ioctl, sizeof(TW_New_Ioctl) + data_buffer_length - 1))
1026                 goto out2;
1027         retval = 0;
1028 out2:
1029         /* Now free ioctl buf memory */
1030         dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle);
1031 out:
1032         mutex_unlock(&tw_dev->ioctl_lock);
1033         return retval;
1034 } /* End tw_chrdev_ioctl() */
1035
1036 /* This function handles open for the character device */
1037 /* NOTE that this function races with remove. */
1038 static int tw_chrdev_open(struct inode *inode, struct file *file)
1039 {
1040         unsigned int minor_number;
1041
1042         cycle_kernel_lock();
1043         dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n");
1044
1045         minor_number = iminor(inode);
1046         if (minor_number >= tw_device_extension_count)
1047                 return -ENODEV;
1048
1049         return 0;
1050 } /* End tw_chrdev_open() */
1051
1052 /* File operations struct for character device */
1053 static const struct file_operations tw_fops = {
1054         .owner          = THIS_MODULE,
1055         .ioctl          = tw_chrdev_ioctl,
1056         .open           = tw_chrdev_open,
1057         .release        = NULL
1058 };
1059
1060 /* This function will free up device extension resources */
1061 static void tw_free_device_extension(TW_Device_Extension *tw_dev)
1062 {
1063         dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n");
1064
1065         /* Free command packet and generic buffer memory */
1066         if (tw_dev->command_packet_virtual_address[0])
1067                 pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Command)*TW_Q_LENGTH, tw_dev->command_packet_virtual_address[0], tw_dev->command_packet_physical_address[0]);
1068
1069         if (tw_dev->alignment_virtual_address[0])
1070                 pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Sector)*TW_Q_LENGTH, tw_dev->alignment_virtual_address[0], tw_dev->alignment_physical_address[0]);
1071 } /* End tw_free_device_extension() */
1072
1073 /* This function will send an initconnection command to controller */
1074 static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits) 
1075 {
1076         unsigned long command_que_value;
1077         TW_Command  *command_packet;
1078         TW_Response_Queue response_queue;
1079         int request_id = 0;
1080
1081         dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n");
1082
1083         /* Initialize InitConnection command packet */
1084         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1085                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n");
1086                 return 1;
1087         }
1088
1089         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1090         memset(command_packet, 0, sizeof(TW_Sector));
1091         command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION);
1092         command_packet->size = TW_INIT_COMMAND_PACKET_SIZE;
1093         command_packet->request_id = request_id;
1094         command_packet->status = 0x0;
1095         command_packet->flags = 0x0;
1096         command_packet->byte6.message_credits = message_credits; 
1097         command_packet->byte8.init_connection.response_queue_pointer = 0x0;
1098         command_que_value = tw_dev->command_packet_physical_address[request_id];
1099
1100         if (command_que_value == 0) {
1101                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n");
1102                 return 1;
1103         }
1104   
1105         /* Send command packet to the board */
1106         outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1107     
1108         /* Poll for completion */
1109         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1110                 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1111                 request_id = TW_RESID_OUT(response_queue.response_id);
1112
1113                 if (request_id != 0) {
1114                         /* unexpected request id */
1115                         printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n");
1116                         return 1;
1117                 }
1118                 if (command_packet->status != 0) {
1119                         /* bad response */
1120                         tw_decode_sense(tw_dev, request_id, 0);
1121                         return 1;
1122                 }
1123         }
1124         return 0;
1125 } /* End tw_initconnection() */
1126
1127 /* Set a value in the features table */
1128 static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size,
1129                   unsigned char *val)
1130 {
1131         TW_Param *param;
1132         TW_Command  *command_packet;
1133         TW_Response_Queue response_queue;
1134         int request_id = 0;
1135         unsigned long command_que_value;
1136         unsigned long param_value;
1137
1138         /* Initialize SetParam command packet */
1139         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1140                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n");
1141                 return 1;
1142         }
1143         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1144         memset(command_packet, 0, sizeof(TW_Sector));
1145         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1146
1147         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
1148         param->table_id = 0x404;  /* Features table */
1149         param->parameter_id = parm;
1150         param->parameter_size_bytes = param_size;
1151         memcpy(param->data, val, param_size);
1152
1153         param_value = tw_dev->alignment_physical_address[request_id];
1154         if (param_value == 0) {
1155                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n");
1156                 tw_dev->state[request_id] = TW_S_COMPLETED;
1157                 tw_state_request_finish(tw_dev, request_id);
1158                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1159                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1160         }
1161         command_packet->byte8.param.sgl[0].address = param_value;
1162         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1163
1164         command_packet->size = 4;
1165         command_packet->request_id = request_id;
1166         command_packet->byte6.parameter_count = 1;
1167
1168         command_que_value = tw_dev->command_packet_physical_address[request_id];
1169         if (command_que_value == 0) {
1170                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n");
1171         return 1;
1172         }
1173
1174         /* Send command packet to the board */
1175         outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1176
1177         /* Poll for completion */
1178         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1179                 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1180                 request_id = TW_RESID_OUT(response_queue.response_id);
1181
1182                 if (request_id != 0) {
1183                         /* unexpected request id */
1184                         printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n");
1185                         return 1;
1186                 }
1187                 if (command_packet->status != 0) {
1188                         /* bad response */
1189                         tw_decode_sense(tw_dev, request_id, 0);
1190                         return 1;
1191                 }
1192         }
1193
1194         return 0;
1195 } /* End tw_setfeature() */
1196
1197 /* This function will reset a controller */
1198 static int tw_reset_sequence(TW_Device_Extension *tw_dev) 
1199 {
1200         int error = 0;
1201         int tries = 0;
1202         unsigned char c = 1;
1203
1204         /* Reset the board */
1205         while (tries < TW_MAX_RESET_TRIES) {
1206                 TW_SOFT_RESET(tw_dev);
1207
1208                 error = tw_aen_drain_queue(tw_dev);
1209                 if (error) {
1210                         printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no);
1211                         tries++;
1212                         continue;
1213                 }
1214
1215                 /* Check for controller errors */
1216                 if (tw_check_errors(tw_dev)) {
1217                         printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no);
1218                         tries++;
1219                         continue;
1220                 }
1221
1222                 /* Now the controller is in a good state */
1223                 break;
1224         }
1225
1226         if (tries >= TW_MAX_RESET_TRIES) {
1227                 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no);
1228                 return 1;
1229         }
1230
1231         error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
1232         if (error) {
1233                 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no);
1234                 return 1;
1235         }
1236
1237         error = tw_setfeature(tw_dev, 2, 1, &c);
1238         if (error) {
1239                 printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n");
1240         }
1241
1242         return 0;
1243 } /* End tw_reset_sequence() */
1244
1245 /* This function will initialize the fields of a device extension */
1246 static int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
1247 {
1248         int i, error=0;
1249
1250         dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n");
1251
1252         /* Initialize command packet buffers */
1253         error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0);
1254         if (error) {
1255                 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n");
1256                 return 1;
1257         }
1258
1259         /* Initialize generic buffer */
1260         error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1);
1261         if (error) {
1262                 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n");
1263                 return 1;
1264         }
1265
1266         for (i=0;i<TW_Q_LENGTH;i++) {
1267                 tw_dev->free_queue[i] = i;
1268                 tw_dev->state[i] = TW_S_INITIAL;
1269         }
1270
1271         tw_dev->pending_head = TW_Q_START;
1272         tw_dev->pending_tail = TW_Q_START;
1273         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1274
1275         mutex_init(&tw_dev->ioctl_lock);
1276         init_waitqueue_head(&tw_dev->ioctl_wqueue);
1277
1278         return 0;
1279 } /* End tw_initialize_device_extension() */
1280
1281 static int tw_map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
1282 {
1283         int use_sg;
1284
1285         dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data()\n");
1286
1287         use_sg = scsi_dma_map(cmd);
1288         if (use_sg < 0) {
1289                 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data(): pci_map_sg() failed.\n");
1290                 return 0;
1291         }
1292
1293         cmd->SCp.phase = TW_PHASE_SGLIST;
1294         cmd->SCp.have_data_in = use_sg;
1295
1296         return use_sg;
1297 } /* End tw_map_scsi_sg_data() */
1298
1299 static void tw_unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
1300 {
1301         dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n");
1302
1303         if (cmd->SCp.phase == TW_PHASE_SGLIST)
1304                 scsi_dma_unmap(cmd);
1305 } /* End tw_unmap_scsi_data() */
1306
1307 /* This function will reset a device extension */
1308 static int tw_reset_device_extension(TW_Device_Extension *tw_dev)
1309 {
1310         int i = 0;
1311         struct scsi_cmnd *srb;
1312         unsigned long flags = 0;
1313
1314         dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n");
1315
1316         set_bit(TW_IN_RESET, &tw_dev->flags);
1317         TW_DISABLE_INTERRUPTS(tw_dev);
1318         TW_MASK_COMMAND_INTERRUPT(tw_dev);
1319         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1320
1321         /* Abort all requests that are in progress */
1322         for (i=0;i<TW_Q_LENGTH;i++) {
1323                 if ((tw_dev->state[i] != TW_S_FINISHED) && 
1324                     (tw_dev->state[i] != TW_S_INITIAL) &&
1325                     (tw_dev->state[i] != TW_S_COMPLETED)) {
1326                         srb = tw_dev->srb[i];
1327                         if (srb != NULL) {
1328                                 srb->result = (DID_RESET << 16);
1329                                 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1330                                 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[i]);
1331                         }
1332                 }
1333         }
1334
1335         /* Reset queues and counts */
1336         for (i=0;i<TW_Q_LENGTH;i++) {
1337                 tw_dev->free_queue[i] = i;
1338                 tw_dev->state[i] = TW_S_INITIAL;
1339         }
1340         tw_dev->free_head = TW_Q_START;
1341         tw_dev->free_tail = TW_Q_START;
1342         tw_dev->posted_request_count = 0;
1343         tw_dev->pending_request_count = 0;
1344         tw_dev->pending_head = TW_Q_START;
1345         tw_dev->pending_tail = TW_Q_START;
1346         tw_dev->reset_print = 0;
1347
1348         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1349
1350         if (tw_reset_sequence(tw_dev)) {
1351                 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
1352                 return 1;
1353         }
1354
1355         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1356         clear_bit(TW_IN_RESET, &tw_dev->flags);
1357         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1358
1359         return 0;
1360 } /* End tw_reset_device_extension() */
1361
1362 /* This funciton returns unit geometry in cylinders/heads/sectors */
1363 static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1364                 sector_t capacity, int geom[]) 
1365 {
1366         int heads, sectors, cylinders;
1367         TW_Device_Extension *tw_dev;
1368         
1369         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n");
1370         tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1371
1372         heads = 64;
1373         sectors = 32;
1374         cylinders = sector_div(capacity, heads * sectors);
1375
1376         if (capacity >= 0x200000) {
1377                 heads = 255;
1378                 sectors = 63;
1379                 cylinders = sector_div(capacity, heads * sectors);
1380         }
1381
1382         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders);
1383         geom[0] = heads;                         
1384         geom[1] = sectors;
1385         geom[2] = cylinders;
1386
1387         return 0;
1388 } /* End tw_scsi_biosparam() */
1389
1390 /* This is the new scsi eh reset function */
1391 static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt) 
1392 {
1393         TW_Device_Extension *tw_dev=NULL;
1394         int retval = FAILED;
1395
1396         tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1397
1398         tw_dev->num_resets++;
1399
1400         sdev_printk(KERN_WARNING, SCpnt->device,
1401                 "WARNING: Command (0x%x) timed out, resetting card.\n",
1402                 SCpnt->cmnd[0]);
1403
1404         /* Make sure we are not issuing an ioctl or resetting from ioctl */
1405         mutex_lock(&tw_dev->ioctl_lock);
1406
1407         /* Now reset the card and some of the device extension data */
1408         if (tw_reset_device_extension(tw_dev)) {
1409                 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no);
1410                 goto out;
1411         }
1412
1413         retval = SUCCESS;
1414 out:
1415         mutex_unlock(&tw_dev->ioctl_lock);
1416         return retval;
1417 } /* End tw_scsi_eh_reset() */
1418
1419 /* This function handles scsi inquiry commands */
1420 static int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id)
1421 {
1422         TW_Param *param;
1423         TW_Command *command_packet;
1424         unsigned long command_que_value;
1425         unsigned long param_value;
1426
1427         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n");
1428
1429         /* Initialize command packet */
1430         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1431         if (command_packet == NULL) {
1432                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n");
1433                 return 1;
1434         }
1435         memset(command_packet, 0, sizeof(TW_Sector));
1436         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1437         command_packet->size = 4;
1438         command_packet->request_id = request_id;
1439         command_packet->status = 0;
1440         command_packet->flags = 0;
1441         command_packet->byte6.parameter_count = 1;
1442
1443         /* Now setup the param */
1444         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1445                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n");
1446                 return 1;
1447         }
1448         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1449         memset(param, 0, sizeof(TW_Sector));
1450         param->table_id = 3;     /* unit summary table */
1451         param->parameter_id = 3; /* unitsstatus parameter */
1452         param->parameter_size_bytes = TW_MAX_UNITS;
1453         param_value = tw_dev->alignment_physical_address[request_id];
1454         if (param_value == 0) {
1455                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n");
1456                 return 1;
1457         }
1458
1459         command_packet->byte8.param.sgl[0].address = param_value;
1460         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1461         command_que_value = tw_dev->command_packet_physical_address[request_id];
1462         if (command_que_value == 0) {
1463                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n");
1464                 return 1;
1465         }
1466
1467         /* Now try to post the command packet */
1468         tw_post_command_packet(tw_dev, request_id);
1469
1470         return 0;
1471 } /* End tw_scsiop_inquiry() */
1472
1473 static void tw_transfer_internal(TW_Device_Extension *tw_dev, int request_id,
1474                                  void *data, unsigned int len)
1475 {
1476         scsi_sg_copy_from_buffer(tw_dev->srb[request_id], data, len);
1477 }
1478
1479 /* This function is called by the isr to complete an inquiry command */
1480 static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id)
1481 {
1482         unsigned char *is_unit_present;
1483         unsigned char request_buffer[36];
1484         TW_Param *param;
1485
1486         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n");
1487
1488         memset(request_buffer, 0, sizeof(request_buffer));
1489         request_buffer[0] = TYPE_DISK; /* Peripheral device type */
1490         request_buffer[1] = 0;         /* Device type modifier */
1491         request_buffer[2] = 0;         /* No ansi/iso compliance */
1492         request_buffer[4] = 31;        /* Additional length */
1493         memcpy(&request_buffer[8], "3ware   ", 8);       /* Vendor ID */
1494         sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id);
1495         memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3);
1496         tw_transfer_internal(tw_dev, request_id, request_buffer,
1497                              sizeof(request_buffer));
1498
1499         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1500         if (param == NULL) {
1501                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n");
1502                 return 1;
1503         }
1504         is_unit_present = &(param->data[0]);
1505
1506         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1507                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1508         } else {
1509                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1510                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1511                 return TW_ISR_DONT_RESULT;
1512         }
1513
1514         return 0;
1515 } /* End tw_scsiop_inquiry_complete() */
1516
1517 /* This function handles scsi mode_sense commands */
1518 static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id)
1519 {
1520         TW_Param *param;
1521         TW_Command *command_packet;
1522         unsigned long command_que_value;
1523         unsigned long param_value;
1524
1525         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n");
1526
1527         /* Only page control = 0, page code = 0x8 (cache page) supported */
1528         if (tw_dev->srb[request_id]->cmnd[2] != 0x8) {
1529                 tw_dev->state[request_id] = TW_S_COMPLETED;
1530                 tw_state_request_finish(tw_dev, request_id);
1531                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1532                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1533                 return 0;
1534         }
1535
1536         /* Now read firmware cache setting for this unit */
1537         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1538         if (command_packet == NULL) {
1539                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n");
1540                 return 1;
1541         }
1542
1543         /* Setup the command packet */
1544         memset(command_packet, 0, sizeof(TW_Sector));
1545         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1546         command_packet->size = 4;
1547         command_packet->request_id = request_id;
1548         command_packet->status = 0;
1549         command_packet->flags = 0;
1550         command_packet->byte6.parameter_count = 1;
1551
1552         /* Setup the param */
1553         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1554                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n");
1555                 return 1;
1556         }
1557
1558         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1559         memset(param, 0, sizeof(TW_Sector));
1560         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id;
1561         param->parameter_id = 7; /* unit flags */
1562         param->parameter_size_bytes = 1;
1563         param_value = tw_dev->alignment_physical_address[request_id];
1564         if (param_value == 0) {
1565                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n");
1566                 return 1;
1567         }
1568
1569         command_packet->byte8.param.sgl[0].address = param_value;
1570         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1571         command_que_value = tw_dev->command_packet_physical_address[request_id];
1572         if (command_que_value == 0) {
1573                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n");
1574                 return 1;
1575         }
1576
1577         /* Now try to post the command packet */
1578         tw_post_command_packet(tw_dev, request_id);
1579         
1580         return 0;
1581 } /* End tw_scsiop_mode_sense() */
1582
1583 /* This function is called by the isr to complete a mode sense command */
1584 static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id)
1585 {
1586         TW_Param *param;
1587         unsigned char *flags;
1588         unsigned char request_buffer[8];
1589
1590         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n");
1591
1592         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1593         if (param == NULL) {
1594                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n");
1595                 return 1;
1596         }
1597         flags = (char *)&(param->data[0]);
1598         memset(request_buffer, 0, sizeof(request_buffer));
1599
1600         request_buffer[0] = 0xf;        /* mode data length */
1601         request_buffer[1] = 0;          /* default medium type */
1602         request_buffer[2] = 0x10;       /* dpo/fua support on */
1603         request_buffer[3] = 0;          /* no block descriptors */
1604         request_buffer[4] = 0x8;        /* caching page */
1605         request_buffer[5] = 0xa;        /* page length */
1606         if (*flags & 0x1)
1607                 request_buffer[6] = 0x5;        /* WCE on, RCD on */
1608         else
1609                 request_buffer[6] = 0x1;        /* WCE off, RCD on */
1610         tw_transfer_internal(tw_dev, request_id, request_buffer,
1611                              sizeof(request_buffer));
1612
1613         return 0;
1614 } /* End tw_scsiop_mode_sense_complete() */
1615
1616 /* This function handles scsi read_capacity commands */
1617 static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id) 
1618 {
1619         TW_Param *param;
1620         TW_Command *command_packet;
1621         unsigned long command_que_value;
1622         unsigned long param_value;
1623
1624         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n");
1625
1626         /* Initialize command packet */
1627         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1628
1629         if (command_packet == NULL) {
1630                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n");
1631                 return 1;
1632         }
1633         memset(command_packet, 0, sizeof(TW_Sector));
1634         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1635         command_packet->size = 4;
1636         command_packet->request_id = request_id;
1637         command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1638         command_packet->status = 0;
1639         command_packet->flags = 0;
1640         command_packet->byte6.block_count = 1;
1641
1642         /* Now setup the param */
1643         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1644                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n");
1645                 return 1;
1646         }
1647         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1648         memset(param, 0, sizeof(TW_Sector));
1649         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + 
1650         tw_dev->srb[request_id]->device->id;
1651         param->parameter_id = 4;        /* unitcapacity parameter */
1652         param->parameter_size_bytes = 4;
1653         param_value = tw_dev->alignment_physical_address[request_id];
1654         if (param_value == 0) {
1655                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n");
1656                 return 1;
1657         }
1658   
1659         command_packet->byte8.param.sgl[0].address = param_value;
1660         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1661         command_que_value = tw_dev->command_packet_physical_address[request_id];
1662         if (command_que_value == 0) {
1663                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n");
1664                 return 1;
1665         }
1666
1667         /* Now try to post the command to the board */
1668         tw_post_command_packet(tw_dev, request_id);
1669   
1670         return 0;
1671 } /* End tw_scsiop_read_capacity() */
1672
1673 /* This function is called by the isr to complete a readcapacity command */
1674 static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id)
1675 {
1676         unsigned char *param_data;
1677         u32 capacity;
1678         char buff[8];
1679         TW_Param *param;
1680
1681         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n");
1682
1683         memset(buff, 0, sizeof(buff));
1684         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1685         if (param == NULL) {
1686                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n");
1687                 return 1;
1688         }
1689         param_data = &(param->data[0]);
1690
1691         capacity = (param_data[3] << 24) | (param_data[2] << 16) | 
1692                    (param_data[1] << 8) | param_data[0];
1693
1694         /* Subtract one sector to fix get last sector ioctl */
1695         capacity -= 1;
1696
1697         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity);
1698
1699         /* Number of LBA's */
1700         buff[0] = (capacity >> 24);
1701         buff[1] = (capacity >> 16) & 0xff;
1702         buff[2] = (capacity >> 8) & 0xff;
1703         buff[3] = capacity & 0xff;
1704
1705         /* Block size in bytes (512) */
1706         buff[4] = (TW_BLOCK_SIZE >> 24);
1707         buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff;
1708         buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff;
1709         buff[7] = TW_BLOCK_SIZE & 0xff;
1710
1711         tw_transfer_internal(tw_dev, request_id, buff, sizeof(buff));
1712
1713         return 0;
1714 } /* End tw_scsiop_read_capacity_complete() */
1715
1716 /* This function handles scsi read or write commands */
1717 static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id) 
1718 {
1719         TW_Command *command_packet;
1720         unsigned long command_que_value;
1721         u32 lba = 0x0, num_sectors = 0x0;
1722         int i, use_sg;
1723         struct scsi_cmnd *srb;
1724         struct scatterlist *sglist, *sg;
1725
1726         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n");
1727
1728         srb = tw_dev->srb[request_id];
1729
1730         sglist = scsi_sglist(srb);
1731         if (!sglist) {
1732                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n");
1733                 return 1;
1734         }
1735
1736         /* Initialize command packet */
1737         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1738         if (command_packet == NULL) {
1739                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n");
1740                 return 1;
1741         }
1742
1743         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) {
1744                 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ);
1745         } else {
1746                 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE);
1747         }
1748
1749         command_packet->size = 3;
1750         command_packet->request_id = request_id;
1751         command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id);
1752         command_packet->status = 0;
1753         command_packet->flags = 0;
1754
1755         if (srb->cmnd[0] == WRITE_10) {
1756                 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10))
1757                         command_packet->flags = 1;
1758         }
1759
1760         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) {
1761                 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3];
1762                 num_sectors = (u32)srb->cmnd[4];
1763         } else {
1764                 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5];
1765                 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1766         }
1767   
1768         /* Update sector statistic */
1769         tw_dev->sector_count = num_sectors;
1770         if (tw_dev->sector_count > tw_dev->max_sector_count)
1771                 tw_dev->max_sector_count = tw_dev->sector_count;
1772   
1773         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors);
1774         command_packet->byte8.io.lba = lba;
1775         command_packet->byte6.block_count = num_sectors;
1776
1777         use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1778         if (!use_sg)
1779                 return 1;
1780
1781         scsi_for_each_sg(tw_dev->srb[request_id], sg, use_sg, i) {
1782                 command_packet->byte8.io.sgl[i].address = sg_dma_address(sg);
1783                 command_packet->byte8.io.sgl[i].length = sg_dma_len(sg);
1784                 command_packet->size+=2;
1785         }
1786
1787         /* Update SG statistics */
1788         tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1789         if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1790                 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1791
1792         command_que_value = tw_dev->command_packet_physical_address[request_id];
1793         if (command_que_value == 0) {
1794                 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n");
1795                 return 1;
1796         }
1797       
1798         /* Now try to post the command to the board */
1799         tw_post_command_packet(tw_dev, request_id);
1800
1801         return 0;
1802 } /* End tw_scsiop_read_write() */
1803
1804 /* This function will handle the request sense scsi command */
1805 static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id)
1806 {
1807         char request_buffer[18];
1808
1809         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n");
1810
1811         memset(request_buffer, 0, sizeof(request_buffer));
1812         request_buffer[0] = 0x70; /* Immediate fixed format */
1813         request_buffer[7] = 10; /* minimum size per SPC: 18 bytes */
1814         /* leave all other fields zero, giving effectively NO_SENSE return */
1815         tw_transfer_internal(tw_dev, request_id, request_buffer,
1816                              sizeof(request_buffer));
1817
1818         tw_dev->state[request_id] = TW_S_COMPLETED;
1819         tw_state_request_finish(tw_dev, request_id);
1820
1821         /* If we got a request_sense, we probably want a reset, return error */
1822         tw_dev->srb[request_id]->result = (DID_ERROR << 16);
1823         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1824
1825         return 0;
1826 } /* End tw_scsiop_request_sense() */
1827
1828 /* This function will handle synchronize cache scsi command */
1829 static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id)
1830 {
1831         TW_Command *command_packet;
1832         unsigned long command_que_value;
1833
1834         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n");
1835
1836         /* Send firmware flush command for this unit */
1837         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1838         if (command_packet == NULL) {
1839                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n");
1840                 return 1;
1841         }
1842
1843         /* Setup the command packet */
1844         memset(command_packet, 0, sizeof(TW_Sector));
1845         command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE);
1846         command_packet->size = 2;
1847         command_packet->request_id = request_id;
1848         command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1849         command_packet->status = 0;
1850         command_packet->flags = 0;
1851         command_packet->byte6.parameter_count = 1;
1852         command_que_value = tw_dev->command_packet_physical_address[request_id];
1853         if (command_que_value == 0) {
1854                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n");
1855                 return 1;
1856         }
1857
1858         /* Now try to post the command packet */
1859         tw_post_command_packet(tw_dev, request_id);
1860
1861         return 0;
1862 } /* End tw_scsiop_synchronize_cache() */
1863
1864 /* This function will handle test unit ready scsi command */
1865 static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id)
1866 {
1867         TW_Param *param;
1868         TW_Command *command_packet;
1869         unsigned long command_que_value;
1870         unsigned long param_value;
1871
1872         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n");
1873
1874         /* Initialize command packet */
1875         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1876         if (command_packet == NULL) {
1877                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n");
1878                 return 1;
1879         }
1880         memset(command_packet, 0, sizeof(TW_Sector));
1881         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1882         command_packet->size = 4;
1883         command_packet->request_id = request_id;
1884         command_packet->status = 0;
1885         command_packet->flags = 0;
1886         command_packet->byte6.parameter_count = 1;
1887
1888         /* Now setup the param */
1889         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1890                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n");
1891                 return 1;
1892         }
1893         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1894         memset(param, 0, sizeof(TW_Sector));
1895         param->table_id = 3;     /* unit summary table */
1896         param->parameter_id = 3; /* unitsstatus parameter */
1897         param->parameter_size_bytes = TW_MAX_UNITS;
1898         param_value = tw_dev->alignment_physical_address[request_id];
1899         if (param_value == 0) {
1900                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n");
1901                 return 1;
1902         }
1903
1904         command_packet->byte8.param.sgl[0].address = param_value;
1905         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1906         command_que_value = tw_dev->command_packet_physical_address[request_id];
1907         if (command_que_value == 0) {
1908                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n");
1909                 return 1;
1910         }
1911
1912         /* Now try to post the command packet */
1913         tw_post_command_packet(tw_dev, request_id);
1914
1915         return 0;
1916 } /* End tw_scsiop_test_unit_ready() */
1917
1918 /* This function is called by the isr to complete a testunitready command */
1919 static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id)
1920 {
1921         unsigned char *is_unit_present;
1922         TW_Param *param;
1923
1924         dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n");
1925
1926         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1927         if (param == NULL) {
1928                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n");
1929                 return 1;
1930         }
1931         is_unit_present = &(param->data[0]);
1932
1933         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1934                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1935         } else {
1936                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1937                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1938                 return TW_ISR_DONT_RESULT;
1939         }
1940
1941         return 0;
1942 } /* End tw_scsiop_test_unit_ready_complete() */
1943
1944 /* This is the main scsi queue function to handle scsi opcodes */
1945 static int tw_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 
1946 {
1947         unsigned char *command = SCpnt->cmnd;
1948         int request_id = 0;
1949         int retval = 1;
1950         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1951
1952         /* If we are resetting due to timed out ioctl, report as busy */
1953         if (test_bit(TW_IN_RESET, &tw_dev->flags))
1954                 return SCSI_MLQUEUE_HOST_BUSY;
1955
1956         /* Save done function into Scsi_Cmnd struct */
1957         SCpnt->scsi_done = done;
1958                  
1959         /* Queue the command and get a request id */
1960         tw_state_request_start(tw_dev, &request_id);
1961
1962         /* Save the scsi command for use by the ISR */
1963         tw_dev->srb[request_id] = SCpnt;
1964
1965         /* Initialize phase to zero */
1966         SCpnt->SCp.phase = TW_PHASE_INITIAL;
1967
1968         switch (*command) {
1969                 case READ_10:
1970                 case READ_6:
1971                 case WRITE_10:
1972                 case WRITE_6:
1973                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
1974                         retval = tw_scsiop_read_write(tw_dev, request_id);
1975                         break;
1976                 case TEST_UNIT_READY:
1977                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
1978                         retval = tw_scsiop_test_unit_ready(tw_dev, request_id);
1979                         break;
1980                 case INQUIRY:
1981                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
1982                         retval = tw_scsiop_inquiry(tw_dev, request_id);
1983                         break;
1984                 case READ_CAPACITY:
1985                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
1986                         retval = tw_scsiop_read_capacity(tw_dev, request_id);
1987                         break;
1988                 case REQUEST_SENSE:
1989                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
1990                         retval = tw_scsiop_request_sense(tw_dev, request_id);
1991                         break;
1992                 case MODE_SENSE:
1993                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
1994                         retval = tw_scsiop_mode_sense(tw_dev, request_id);
1995                         break;
1996                 case SYNCHRONIZE_CACHE:
1997                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
1998                         retval = tw_scsiop_synchronize_cache(tw_dev, request_id);
1999                         break;
2000                 case TW_IOCTL:
2001                         printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n");
2002                         break;
2003                 default:
2004                         printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
2005                         tw_dev->state[request_id] = TW_S_COMPLETED;
2006                         tw_state_request_finish(tw_dev, request_id);
2007                         SCpnt->result = (DID_BAD_TARGET << 16);
2008                         done(SCpnt);
2009                         retval = 0;
2010         }
2011         if (retval) {
2012                 tw_dev->state[request_id] = TW_S_COMPLETED;
2013                 tw_state_request_finish(tw_dev, request_id);
2014                 SCpnt->result = (DID_ERROR << 16);
2015                 done(SCpnt);
2016                 retval = 0;
2017         }
2018         return retval;
2019 } /* End tw_scsi_queue() */
2020
2021 /* This function is the interrupt service routine */
2022 static irqreturn_t tw_interrupt(int irq, void *dev_instance) 
2023 {
2024         int request_id;
2025         u32 status_reg_value;
2026         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
2027         TW_Response_Queue response_que;
2028         int error = 0, retval = 0;
2029         TW_Command *command_packet;
2030         int handled = 0;
2031
2032         /* Get the host lock for io completions */
2033         spin_lock(tw_dev->host->host_lock);
2034
2035         /* Read the registers */
2036         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2037
2038         /* Check if this is our interrupt, otherwise bail */
2039         if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
2040                 goto tw_interrupt_bail;
2041
2042         handled = 1;
2043
2044         /* If we are resetting, bail */
2045         if (test_bit(TW_IN_RESET, &tw_dev->flags))
2046                 goto tw_interrupt_bail;
2047
2048         /* Check controller for errors */
2049         if (tw_check_bits(status_reg_value)) {
2050                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2051                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2052                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2053                         goto tw_interrupt_bail;
2054                 }
2055         }
2056
2057         /* Handle host interrupt */
2058         if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
2059                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
2060                 TW_CLEAR_HOST_INTERRUPT(tw_dev);
2061         }
2062
2063         /* Handle attention interrupt */
2064         if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
2065                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
2066                 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
2067                 tw_state_request_start(tw_dev, &request_id);
2068                 error = tw_aen_read_queue(tw_dev, request_id);
2069                 if (error) {
2070                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
2071                         tw_dev->state[request_id] = TW_S_COMPLETED;
2072                         tw_state_request_finish(tw_dev, request_id);
2073                 }
2074         }
2075
2076         /* Handle command interrupt */
2077         if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
2078                 /* Drain as many pending commands as we can */
2079                 while (tw_dev->pending_request_count > 0) {
2080                         request_id = tw_dev->pending_queue[tw_dev->pending_head];
2081                         if (tw_dev->state[request_id] != TW_S_PENDING) {
2082                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
2083                                 break;
2084                         }
2085                         if (tw_post_command_packet(tw_dev, request_id)==0) {
2086                                 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2087                                         tw_dev->pending_head = TW_Q_START;
2088                                 } else {
2089                                         tw_dev->pending_head = tw_dev->pending_head + 1;
2090                                 }
2091                                 tw_dev->pending_request_count--;
2092                         } else {
2093                                 /* If we get here, we will continue re-posting on the next command interrupt */
2094                                 break;
2095                         }
2096                 }
2097                 /* If there are no more pending requests, we mask command interrupt */
2098                 if (tw_dev->pending_request_count == 0) 
2099                         TW_MASK_COMMAND_INTERRUPT(tw_dev);
2100         }
2101
2102         /* Handle response interrupt */
2103         if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
2104                 /* Drain the response queue from the board */
2105                 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
2106                         /* Read response queue register */
2107                         response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
2108                         request_id = TW_RESID_OUT(response_que.response_id);
2109                         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2110                         error = 0;
2111
2112                         /* Check for bad response */
2113                         if (command_packet->status != 0) {
2114                                 /* If internal command, don't error, don't fill sense */
2115                                 if (tw_dev->srb[request_id] == NULL) {
2116                                         tw_decode_sense(tw_dev, request_id, 0);
2117                                 } else {
2118                                         error = tw_decode_sense(tw_dev, request_id, 1);
2119                                 }
2120                         }
2121
2122                         /* Check for correct state */
2123                         if (tw_dev->state[request_id] != TW_S_POSTED) {
2124                                 if (tw_dev->srb[request_id] != NULL) {
2125                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no);
2126                                         error = 1;
2127                                 }
2128                         }
2129
2130                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
2131
2132                         /* Check for internal command completion */
2133                         if (tw_dev->srb[request_id] == NULL) {
2134                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
2135                                 /* Check for chrdev ioctl completion */
2136                                 if (request_id != tw_dev->chrdev_request_id) {
2137                                         retval = tw_aen_complete(tw_dev, request_id);
2138                                         if (retval) {
2139                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
2140                                         }
2141                                 } else {
2142                                         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2143                                         wake_up(&tw_dev->ioctl_wqueue);
2144                                 }
2145                         } else {
2146                                 switch (tw_dev->srb[request_id]->cmnd[0]) {
2147                                 case READ_10:
2148                                 case READ_6:
2149                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
2150                                         break;
2151                                 case WRITE_10:
2152                                 case WRITE_6:
2153                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
2154                                         break;
2155                                 case TEST_UNIT_READY:
2156                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
2157                                         error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
2158                                         break;
2159                                 case INQUIRY:
2160                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
2161                                         error = tw_scsiop_inquiry_complete(tw_dev, request_id);
2162                                         break;
2163                                 case READ_CAPACITY:
2164                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
2165                                         error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
2166                                         break;
2167                                 case MODE_SENSE:
2168                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
2169                                         error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
2170                                         break;
2171                                 case SYNCHRONIZE_CACHE:
2172                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
2173                                         break;
2174                                 default:
2175                                         printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
2176                                         error = 1;
2177                                 }
2178
2179                                 /* If no error command was a success */
2180                                 if (error == 0) {
2181                                         tw_dev->srb[request_id]->result = (DID_OK << 16);
2182                                 }
2183
2184                                 /* If error, command failed */
2185                                 if (error == 1) {
2186                                         /* Ask for a host reset */
2187                                         tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
2188                                 }
2189
2190                                 /* Now complete the io */
2191                                 if ((error != TW_ISR_DONT_COMPLETE)) {
2192                                         tw_dev->state[request_id] = TW_S_COMPLETED;
2193                                         tw_state_request_finish(tw_dev, request_id);
2194                                         tw_dev->posted_request_count--;
2195                                         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2196                                         
2197                                         tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
2198                                 }
2199                         }
2200                                 
2201                         /* Check for valid status after each drain */
2202                         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2203                         if (tw_check_bits(status_reg_value)) {
2204                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2205                                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2206                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2207                                         goto tw_interrupt_bail;
2208                                 }
2209                         }
2210                 }
2211         }
2212
2213 tw_interrupt_bail:
2214         spin_unlock(tw_dev->host->host_lock);
2215         return IRQ_RETVAL(handled);
2216 } /* End tw_interrupt() */
2217
2218 /* This function tells the controller to shut down */
2219 static void __tw_shutdown(TW_Device_Extension *tw_dev)
2220 {
2221         /* Disable interrupts */
2222         TW_DISABLE_INTERRUPTS(tw_dev);
2223
2224         /* Free up the IRQ */
2225         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2226
2227         printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no);
2228
2229         /* Tell the card we are shutting down */
2230         if (tw_initconnection(tw_dev, 1)) {
2231                 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n");
2232         } else {
2233                 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n");
2234         }
2235
2236         /* Clear all interrupts just before exit */
2237         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2238 } /* End __tw_shutdown() */
2239
2240 /* Wrapper for __tw_shutdown */
2241 static void tw_shutdown(struct pci_dev *pdev)
2242 {
2243         struct Scsi_Host *host = pci_get_drvdata(pdev);
2244         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2245
2246         __tw_shutdown(tw_dev);
2247 } /* End tw_shutdown() */
2248
2249 /* This function gets called when a disk is coming online */
2250 static int tw_slave_configure(struct scsi_device *sdev)
2251 {
2252         /* Force 60 second timeout */
2253         blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
2254
2255         return 0;
2256 } /* End tw_slave_configure() */
2257
2258 static struct scsi_host_template driver_template = {
2259         .module                 = THIS_MODULE,
2260         .name                   = "3ware Storage Controller",
2261         .queuecommand           = tw_scsi_queue,
2262         .eh_host_reset_handler  = tw_scsi_eh_reset,
2263         .bios_param             = tw_scsi_biosparam,
2264         .change_queue_depth     = tw_change_queue_depth,
2265         .can_queue              = TW_Q_LENGTH-2,
2266         .slave_configure        = tw_slave_configure,
2267         .this_id                = -1,
2268         .sg_tablesize           = TW_MAX_SGL_LENGTH,
2269         .max_sectors            = TW_MAX_SECTORS,
2270         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,  
2271         .use_clustering         = ENABLE_CLUSTERING,
2272         .shost_attrs            = tw_host_attrs,
2273         .emulated               = 1
2274 };
2275
2276 /* This function will probe and initialize a card */
2277 static int __devinit tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2278 {
2279         struct Scsi_Host *host = NULL;
2280         TW_Device_Extension *tw_dev;
2281         int retval = -ENODEV;
2282
2283         retval = pci_enable_device(pdev);
2284         if (retval) {
2285                 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device.");
2286                 goto out_disable_device;
2287         }
2288
2289         pci_set_master(pdev);
2290
2291         retval = pci_set_dma_mask(pdev, TW_DMA_MASK);
2292         if (retval) {
2293                 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask.");
2294                 goto out_disable_device;
2295         }
2296
2297         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2298         if (!host) {
2299                 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension.");
2300                 retval = -ENOMEM;
2301                 goto out_disable_device;
2302         }
2303         tw_dev = (TW_Device_Extension *)host->hostdata;
2304
2305         /* Save values to device extension */
2306         tw_dev->host = host;
2307         tw_dev->tw_pci_dev = pdev;
2308
2309         if (tw_initialize_device_extension(tw_dev)) {
2310                 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension.");
2311                 goto out_free_device_extension;
2312         }
2313
2314         /* Request IO regions */
2315         retval = pci_request_regions(pdev, "3w-xxxx");
2316         if (retval) {
2317                 printk(KERN_WARNING "3w-xxxx: Failed to get mem region.");
2318                 goto out_free_device_extension;
2319         }
2320
2321         /* Save base address */
2322         tw_dev->base_addr = pci_resource_start(pdev, 0);
2323         if (!tw_dev->base_addr) {
2324                 printk(KERN_WARNING "3w-xxxx: Failed to get io address.");
2325                 goto out_release_mem_region;
2326         }
2327
2328         /* Disable interrupts on the card */
2329         TW_DISABLE_INTERRUPTS(tw_dev);
2330
2331         /* Initialize the card */
2332         if (tw_reset_sequence(tw_dev))
2333                 goto out_release_mem_region;
2334
2335         /* Set host specific parameters */
2336         host->max_id = TW_MAX_UNITS;
2337         host->max_cmd_len = TW_MAX_CDB_LEN;
2338
2339         /* Luns and channels aren't supported by adapter */
2340         host->max_lun = 0;
2341         host->max_channel = 0;
2342
2343         /* Register the card with the kernel SCSI layer */
2344         retval = scsi_add_host(host, &pdev->dev);
2345         if (retval) {
2346                 printk(KERN_WARNING "3w-xxxx: scsi add host failed");
2347                 goto out_release_mem_region;
2348         }
2349
2350         pci_set_drvdata(pdev, host);
2351
2352         printk(KERN_WARNING "3w-xxxx: scsi%d: Found a 3ware Storage Controller at 0x%x, IRQ: %d.\n", host->host_no, tw_dev->base_addr, pdev->irq);
2353
2354         /* Now setup the interrupt handler */
2355         retval = request_irq(pdev->irq, tw_interrupt, IRQF_SHARED, "3w-xxxx", tw_dev);
2356         if (retval) {
2357                 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ.");
2358                 goto out_remove_host;
2359         }
2360
2361         tw_device_extension_list[tw_device_extension_count] = tw_dev;
2362         tw_device_extension_count++;
2363
2364         /* Re-enable interrupts on the card */
2365         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2366
2367         /* Finally, scan the host */
2368         scsi_scan_host(host);
2369
2370         if (twe_major == -1) {
2371                 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0)
2372                         printk(KERN_WARNING "3w-xxxx: Failed to register character device.");
2373         }
2374         return 0;
2375
2376 out_remove_host:
2377         scsi_remove_host(host);
2378 out_release_mem_region:
2379         pci_release_regions(pdev);
2380 out_free_device_extension:
2381         tw_free_device_extension(tw_dev);
2382         scsi_host_put(host);
2383 out_disable_device:
2384         pci_disable_device(pdev);
2385
2386         return retval;
2387 } /* End tw_probe() */
2388
2389 /* This function is called to remove a device */
2390 static void tw_remove(struct pci_dev *pdev)
2391 {
2392         struct Scsi_Host *host = pci_get_drvdata(pdev);
2393         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2394
2395         scsi_remove_host(tw_dev->host);
2396
2397         /* Unregister character device */
2398         if (twe_major >= 0) {
2399                 unregister_chrdev(twe_major, "twe");
2400                 twe_major = -1;
2401         }
2402
2403         /* Shutdown the card */
2404         __tw_shutdown(tw_dev);
2405
2406         /* Free up the mem region */
2407         pci_release_regions(pdev);
2408
2409         /* Free up device extension resources */
2410         tw_free_device_extension(tw_dev);
2411
2412         scsi_host_put(tw_dev->host);
2413         pci_disable_device(pdev);
2414         tw_device_extension_count--;
2415 } /* End tw_remove() */
2416
2417 /* PCI Devices supported by this driver */
2418 static struct pci_device_id tw_pci_tbl[] __devinitdata = {
2419         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000,
2420           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2421         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000,
2422           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2423         { }
2424 };
2425 MODULE_DEVICE_TABLE(pci, tw_pci_tbl);
2426
2427 /* pci_driver initializer */
2428 static struct pci_driver tw_driver = {
2429         .name           = "3w-xxxx",
2430         .id_table       = tw_pci_tbl,
2431         .probe          = tw_probe,
2432         .remove         = tw_remove,
2433         .shutdown       = tw_shutdown,
2434 };
2435
2436 /* This function is called on driver initialization */
2437 static int __init tw_init(void)
2438 {
2439         printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2440
2441         return pci_register_driver(&tw_driver);
2442 } /* End tw_init() */
2443
2444 /* This function is called on driver exit */
2445 static void __exit tw_exit(void)
2446 {
2447         pci_unregister_driver(&tw_driver);
2448 } /* End tw_exit() */
2449
2450 module_init(tw_init);
2451 module_exit(tw_exit);
2452