Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

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

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