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

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         .open           = tw_chrdev_open,
1049         .release        = NULL,
1050         .llseek         = noop_llseek,
1051 };
1052 
1053 /* This function will free up device extension resources */
1054 static void tw_free_device_extension(TW_Device_Extension *tw_dev)
1055 {
1056         dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n");
1057 
1058         /* Free command packet and generic buffer memory */
1059         if (tw_dev->command_packet_virtual_address[0])
1060                 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]);
1061 
1062         if (tw_dev->alignment_virtual_address[0])
1063                 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]);
1064 } /* End tw_free_device_extension() */
1065 
1066 /* This function will send an initconnection command to controller */
1067 static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits) 
1068 {
1069         unsigned long command_que_value;
1070         TW_Command  *command_packet;
1071         TW_Response_Queue response_queue;
1072         int request_id = 0;
1073 
1074         dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n");
1075 
1076         /* Initialize InitConnection command packet */
1077         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1078                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n");
1079                 return 1;
1080         }
1081 
1082         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1083         memset(command_packet, 0, sizeof(TW_Sector));
1084         command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION);
1085         command_packet->size = TW_INIT_COMMAND_PACKET_SIZE;
1086         command_packet->request_id = request_id;
1087         command_packet->status = 0x0;
1088         command_packet->flags = 0x0;
1089         command_packet->byte6.message_credits = message_credits; 
1090         command_packet->byte8.init_connection.response_queue_pointer = 0x0;
1091         command_que_value = tw_dev->command_packet_physical_address[request_id];
1092 
1093         if (command_que_value == 0) {
1094                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n");
1095                 return 1;
1096         }
1097   
1098         /* Send command packet to the board */
1099         outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1100     
1101         /* Poll for completion */
1102         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1103                 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1104                 request_id = TW_RESID_OUT(response_queue.response_id);
1105 
1106                 if (request_id != 0) {
1107                         /* unexpected request id */
1108                         printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n");
1109                         return 1;
1110                 }
1111                 if (command_packet->status != 0) {
1112                         /* bad response */
1113                         tw_decode_sense(tw_dev, request_id, 0);
1114                         return 1;
1115                 }
1116         }
1117         return 0;
1118 } /* End tw_initconnection() */
1119 
1120 /* Set a value in the features table */
1121 static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size,
1122                   unsigned char *val)
1123 {
1124         TW_Param *param;
1125         TW_Command  *command_packet;
1126         TW_Response_Queue response_queue;
1127         int request_id = 0;
1128         unsigned long command_que_value;
1129         unsigned long param_value;
1130 
1131         /* Initialize SetParam command packet */
1132         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1133                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n");
1134                 return 1;
1135         }
1136         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1137         memset(command_packet, 0, sizeof(TW_Sector));
1138         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1139 
1140         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
1141         param->table_id = 0x404;  /* Features table */
1142         param->parameter_id = parm;
1143         param->parameter_size_bytes = param_size;
1144         memcpy(param->data, val, param_size);
1145 
1146         param_value = tw_dev->alignment_physical_address[request_id];
1147         if (param_value == 0) {
1148                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n");
1149                 tw_dev->state[request_id] = TW_S_COMPLETED;
1150                 tw_state_request_finish(tw_dev, request_id);
1151                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1152                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1153         }
1154         command_packet->byte8.param.sgl[0].address = param_value;
1155         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1156 
1157         command_packet->size = 4;
1158         command_packet->request_id = request_id;
1159         command_packet->byte6.parameter_count = 1;
1160 
1161         command_que_value = tw_dev->command_packet_physical_address[request_id];
1162         if (command_que_value == 0) {
1163                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n");
1164         return 1;
1165         }
1166 
1167         /* Send command packet to the board */
1168         outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1169 
1170         /* Poll for completion */
1171         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1172                 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1173                 request_id = TW_RESID_OUT(response_queue.response_id);
1174 
1175                 if (request_id != 0) {
1176                         /* unexpected request id */
1177                         printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n");
1178                         return 1;
1179                 }
1180                 if (command_packet->status != 0) {
1181                         /* bad response */
1182                         tw_decode_sense(tw_dev, request_id, 0);
1183                         return 1;
1184                 }
1185         }
1186 
1187         return 0;
1188 } /* End tw_setfeature() */
1189 
1190 /* This function will reset a controller */
1191 static int tw_reset_sequence(TW_Device_Extension *tw_dev) 
1192 {
1193         int error = 0;
1194         int tries = 0;
1195         unsigned char c = 1;
1196 
1197         /* Reset the board */
1198         while (tries < TW_MAX_RESET_TRIES) {
1199                 TW_SOFT_RESET(tw_dev);
1200 
1201                 error = tw_aen_drain_queue(tw_dev);
1202                 if (error) {
1203                         printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no);
1204                         tries++;
1205                         continue;
1206                 }
1207 
1208                 /* Check for controller errors */
1209                 if (tw_check_errors(tw_dev)) {
1210                         printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no);
1211                         tries++;
1212                         continue;
1213                 }
1214 
1215                 /* Now the controller is in a good state */
1216                 break;
1217         }
1218 
1219         if (tries >= TW_MAX_RESET_TRIES) {
1220                 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no);
1221                 return 1;
1222         }
1223 
1224         error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
1225         if (error) {
1226                 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no);
1227                 return 1;
1228         }
1229 
1230         error = tw_setfeature(tw_dev, 2, 1, &c);
1231         if (error) {
1232                 printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n");
1233         }
1234 
1235         return 0;
1236 } /* End tw_reset_sequence() */
1237 
1238 /* This function will initialize the fields of a device extension */
1239 static int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
1240 {
1241         int i, error=0;
1242 
1243         dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n");
1244 
1245         /* Initialize command packet buffers */
1246         error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0);
1247         if (error) {
1248                 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n");
1249                 return 1;
1250         }
1251 
1252         /* Initialize generic buffer */
1253         error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1);
1254         if (error) {
1255                 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n");
1256                 return 1;
1257         }
1258 
1259         for (i=0;i<TW_Q_LENGTH;i++) {
1260                 tw_dev->free_queue[i] = i;
1261                 tw_dev->state[i] = TW_S_INITIAL;
1262         }
1263 
1264         tw_dev->pending_head = TW_Q_START;
1265         tw_dev->pending_tail = TW_Q_START;
1266         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1267 
1268         mutex_init(&tw_dev->ioctl_lock);
1269         init_waitqueue_head(&tw_dev->ioctl_wqueue);
1270 
1271         return 0;
1272 } /* End tw_initialize_device_extension() */
1273 
1274 static int tw_map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
1275 {
1276         int use_sg;
1277 
1278         dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data()\n");
1279 
1280         use_sg = scsi_dma_map(cmd);
1281         if (use_sg < 0) {
1282                 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data(): pci_map_sg() failed.\n");
1283                 return 0;
1284         }
1285 
1286         cmd->SCp.phase = TW_PHASE_SGLIST;
1287         cmd->SCp.have_data_in = use_sg;
1288 
1289         return use_sg;
1290 } /* End tw_map_scsi_sg_data() */
1291 
1292 static void tw_unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
1293 {
1294         dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n");
1295 
1296         if (cmd->SCp.phase == TW_PHASE_SGLIST)
1297                 scsi_dma_unmap(cmd);
1298 } /* End tw_unmap_scsi_data() */
1299 
1300 /* This function will reset a device extension */
1301 static int tw_reset_device_extension(TW_Device_Extension *tw_dev)
1302 {
1303         int i = 0;
1304         struct scsi_cmnd *srb;
1305         unsigned long flags = 0;
1306 
1307         dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n");
1308 
1309         set_bit(TW_IN_RESET, &tw_dev->flags);
1310         TW_DISABLE_INTERRUPTS(tw_dev);
1311         TW_MASK_COMMAND_INTERRUPT(tw_dev);
1312         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1313 
1314         /* Abort all requests that are in progress */
1315         for (i=0;i<TW_Q_LENGTH;i++) {
1316                 if ((tw_dev->state[i] != TW_S_FINISHED) && 
1317                     (tw_dev->state[i] != TW_S_INITIAL) &&
1318                     (tw_dev->state[i] != TW_S_COMPLETED)) {
1319                         srb = tw_dev->srb[i];
1320                         if (srb != NULL) {
1321                                 srb->result = (DID_RESET << 16);
1322                                 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1323                                 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[i]);
1324                         }
1325                 }
1326         }
1327 
1328         /* Reset queues and counts */
1329         for (i=0;i<TW_Q_LENGTH;i++) {
1330                 tw_dev->free_queue[i] = i;
1331                 tw_dev->state[i] = TW_S_INITIAL;
1332         }
1333         tw_dev->free_head = TW_Q_START;
1334         tw_dev->free_tail = TW_Q_START;
1335         tw_dev->posted_request_count = 0;
1336         tw_dev->pending_request_count = 0;
1337         tw_dev->pending_head = TW_Q_START;
1338         tw_dev->pending_tail = TW_Q_START;
1339         tw_dev->reset_print = 0;
1340 
1341         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1342 
1343         if (tw_reset_sequence(tw_dev)) {
1344                 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
1345                 return 1;
1346         }
1347 
1348         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1349         clear_bit(TW_IN_RESET, &tw_dev->flags);
1350         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1351 
1352         return 0;
1353 } /* End tw_reset_device_extension() */
1354 
1355 /* This funciton returns unit geometry in cylinders/heads/sectors */
1356 static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1357                 sector_t capacity, int geom[]) 
1358 {
1359         int heads, sectors, cylinders;
1360         TW_Device_Extension *tw_dev;
1361         
1362         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n");
1363         tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1364 
1365         heads = 64;
1366         sectors = 32;
1367         cylinders = sector_div(capacity, heads * sectors);
1368 
1369         if (capacity >= 0x200000) {
1370                 heads = 255;
1371                 sectors = 63;
1372                 cylinders = sector_div(capacity, heads * sectors);
1373         }
1374 
1375         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders);
1376         geom[0] = heads;                         
1377         geom[1] = sectors;
1378         geom[2] = cylinders;
1379 
1380         return 0;
1381 } /* End tw_scsi_biosparam() */
1382 
1383 /* This is the new scsi eh reset function */
1384 static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt) 
1385 {
1386         TW_Device_Extension *tw_dev=NULL;
1387         int retval = FAILED;
1388 
1389         tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1390 
1391         tw_dev->num_resets++;
1392 
1393         sdev_printk(KERN_WARNING, SCpnt->device,
1394                 "WARNING: Command (0x%x) timed out, resetting card.\n",
1395                 SCpnt->cmnd[0]);
1396 
1397         /* Make sure we are not issuing an ioctl or resetting from ioctl */
1398         mutex_lock(&tw_dev->ioctl_lock);
1399 
1400         /* Now reset the card and some of the device extension data */
1401         if (tw_reset_device_extension(tw_dev)) {
1402                 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no);
1403                 goto out;
1404         }
1405 
1406         retval = SUCCESS;
1407 out:
1408         mutex_unlock(&tw_dev->ioctl_lock);
1409         return retval;
1410 } /* End tw_scsi_eh_reset() */
1411 
1412 /* This function handles scsi inquiry commands */
1413 static int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id)
1414 {
1415         TW_Param *param;
1416         TW_Command *command_packet;
1417         unsigned long command_que_value;
1418         unsigned long param_value;
1419 
1420         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n");
1421 
1422         /* Initialize command packet */
1423         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1424         if (command_packet == NULL) {
1425                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n");
1426                 return 1;
1427         }
1428         memset(command_packet, 0, sizeof(TW_Sector));
1429         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1430         command_packet->size = 4;
1431         command_packet->request_id = request_id;
1432         command_packet->status = 0;
1433         command_packet->flags = 0;
1434         command_packet->byte6.parameter_count = 1;
1435 
1436         /* Now setup the param */
1437         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1438                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n");
1439                 return 1;
1440         }
1441         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1442         memset(param, 0, sizeof(TW_Sector));
1443         param->table_id = 3;     /* unit summary table */
1444         param->parameter_id = 3; /* unitsstatus parameter */
1445         param->parameter_size_bytes = TW_MAX_UNITS;
1446         param_value = tw_dev->alignment_physical_address[request_id];
1447         if (param_value == 0) {
1448                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n");
1449                 return 1;
1450         }
1451 
1452         command_packet->byte8.param.sgl[0].address = param_value;
1453         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1454         command_que_value = tw_dev->command_packet_physical_address[request_id];
1455         if (command_que_value == 0) {
1456                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n");
1457                 return 1;
1458         }
1459 
1460         /* Now try to post the command packet */
1461         tw_post_command_packet(tw_dev, request_id);
1462 
1463         return 0;
1464 } /* End tw_scsiop_inquiry() */
1465 
1466 static void tw_transfer_internal(TW_Device_Extension *tw_dev, int request_id,
1467                                  void *data, unsigned int len)
1468 {
1469         scsi_sg_copy_from_buffer(tw_dev->srb[request_id], data, len);
1470 }
1471 
1472 /* This function is called by the isr to complete an inquiry command */
1473 static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id)
1474 {
1475         unsigned char *is_unit_present;
1476         unsigned char request_buffer[36];
1477         TW_Param *param;
1478 
1479         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n");
1480 
1481         memset(request_buffer, 0, sizeof(request_buffer));
1482         request_buffer[0] = TYPE_DISK; /* Peripheral device type */
1483         request_buffer[1] = 0;         /* Device type modifier */
1484         request_buffer[2] = 0;         /* No ansi/iso compliance */
1485         request_buffer[4] = 31;        /* Additional length */
1486         memcpy(&request_buffer[8], "3ware   ", 8);       /* Vendor ID */
1487         sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id);
1488         memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3);
1489         tw_transfer_internal(tw_dev, request_id, request_buffer,
1490                              sizeof(request_buffer));
1491 
1492         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1493         if (param == NULL) {
1494                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n");
1495                 return 1;
1496         }
1497         is_unit_present = &(param->data[0]);
1498 
1499         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1500                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1501         } else {
1502                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1503                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1504                 return TW_ISR_DONT_RESULT;
1505         }
1506 
1507         return 0;
1508 } /* End tw_scsiop_inquiry_complete() */
1509 
1510 /* This function handles scsi mode_sense commands */
1511 static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id)
1512 {
1513         TW_Param *param;
1514         TW_Command *command_packet;
1515         unsigned long command_que_value;
1516         unsigned long param_value;
1517 
1518         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n");
1519 
1520         /* Only page control = 0, page code = 0x8 (cache page) supported */
1521         if (tw_dev->srb[request_id]->cmnd[2] != 0x8) {
1522                 tw_dev->state[request_id] = TW_S_COMPLETED;
1523                 tw_state_request_finish(tw_dev, request_id);
1524                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1525                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1526                 return 0;
1527         }
1528 
1529         /* Now read firmware cache setting for this unit */
1530         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1531         if (command_packet == NULL) {
1532                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n");
1533                 return 1;
1534         }
1535 
1536         /* Setup the command packet */
1537         memset(command_packet, 0, sizeof(TW_Sector));
1538         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1539         command_packet->size = 4;
1540         command_packet->request_id = request_id;
1541         command_packet->status = 0;
1542         command_packet->flags = 0;
1543         command_packet->byte6.parameter_count = 1;
1544 
1545         /* Setup the param */
1546         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1547                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n");
1548                 return 1;
1549         }
1550 
1551         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1552         memset(param, 0, sizeof(TW_Sector));
1553         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id;
1554         param->parameter_id = 7; /* unit flags */
1555         param->parameter_size_bytes = 1;
1556         param_value = tw_dev->alignment_physical_address[request_id];
1557         if (param_value == 0) {
1558                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n");
1559                 return 1;
1560         }
1561 
1562         command_packet->byte8.param.sgl[0].address = param_value;
1563         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1564         command_que_value = tw_dev->command_packet_physical_address[request_id];
1565         if (command_que_value == 0) {
1566                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n");
1567                 return 1;
1568         }
1569 
1570         /* Now try to post the command packet */
1571         tw_post_command_packet(tw_dev, request_id);
1572         
1573         return 0;
1574 } /* End tw_scsiop_mode_sense() */
1575 
1576 /* This function is called by the isr to complete a mode sense command */
1577 static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id)
1578 {
1579         TW_Param *param;
1580         unsigned char *flags;
1581         unsigned char request_buffer[8];
1582 
1583         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n");
1584 
1585         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1586         if (param == NULL) {
1587                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n");
1588                 return 1;
1589         }
1590         flags = (char *)&(param->data[0]);
1591         memset(request_buffer, 0, sizeof(request_buffer));
1592 
1593         request_buffer[0] = 0xf;        /* mode data length */
1594         request_buffer[1] = 0;          /* default medium type */
1595         request_buffer[2] = 0x10;       /* dpo/fua support on */
1596         request_buffer[3] = 0;          /* no block descriptors */
1597         request_buffer[4] = 0x8;        /* caching page */
1598         request_buffer[5] = 0xa;        /* page length */
1599         if (*flags & 0x1)
1600                 request_buffer[6] = 0x5;        /* WCE on, RCD on */
1601         else
1602                 request_buffer[6] = 0x1;        /* WCE off, RCD on */
1603         tw_transfer_internal(tw_dev, request_id, request_buffer,
1604                              sizeof(request_buffer));
1605 
1606         return 0;
1607 } /* End tw_scsiop_mode_sense_complete() */
1608 
1609 /* This function handles scsi read_capacity commands */
1610 static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id) 
1611 {
1612         TW_Param *param;
1613         TW_Command *command_packet;
1614         unsigned long command_que_value;
1615         unsigned long param_value;
1616 
1617         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n");
1618 
1619         /* Initialize command packet */
1620         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1621 
1622         if (command_packet == NULL) {
1623                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n");
1624                 return 1;
1625         }
1626         memset(command_packet, 0, sizeof(TW_Sector));
1627         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1628         command_packet->size = 4;
1629         command_packet->request_id = request_id;
1630         command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1631         command_packet->status = 0;
1632         command_packet->flags = 0;
1633         command_packet->byte6.block_count = 1;
1634 
1635         /* Now setup the param */
1636         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1637                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n");
1638                 return 1;
1639         }
1640         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1641         memset(param, 0, sizeof(TW_Sector));
1642         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + 
1643         tw_dev->srb[request_id]->device->id;
1644         param->parameter_id = 4;        /* unitcapacity parameter */
1645         param->parameter_size_bytes = 4;
1646         param_value = tw_dev->alignment_physical_address[request_id];
1647         if (param_value == 0) {
1648                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n");
1649                 return 1;
1650         }
1651   
1652         command_packet->byte8.param.sgl[0].address = param_value;
1653         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1654         command_que_value = tw_dev->command_packet_physical_address[request_id];
1655         if (command_que_value == 0) {
1656                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n");
1657                 return 1;
1658         }
1659 
1660         /* Now try to post the command to the board */
1661         tw_post_command_packet(tw_dev, request_id);
1662   
1663         return 0;
1664 } /* End tw_scsiop_read_capacity() */
1665 
1666 /* This function is called by the isr to complete a readcapacity command */
1667 static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id)
1668 {
1669         unsigned char *param_data;
1670         u32 capacity;
1671         char buff[8];
1672         TW_Param *param;
1673 
1674         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n");
1675 
1676         memset(buff, 0, sizeof(buff));
1677         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1678         if (param == NULL) {
1679                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n");
1680                 return 1;
1681         }
1682         param_data = &(param->data[0]);
1683 
1684         capacity = (param_data[3] << 24) | (param_data[2] << 16) | 
1685                    (param_data[1] << 8) | param_data[0];
1686 
1687         /* Subtract one sector to fix get last sector ioctl */
1688         capacity -= 1;
1689 
1690         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity);
1691 
1692         /* Number of LBA's */
1693         buff[0] = (capacity >> 24);
1694         buff[1] = (capacity >> 16) & 0xff;
1695         buff[2] = (capacity >> 8) & 0xff;
1696         buff[3] = capacity & 0xff;
1697 
1698         /* Block size in bytes (512) */
1699         buff[4] = (TW_BLOCK_SIZE >> 24);
1700         buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff;
1701         buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff;
1702         buff[7] = TW_BLOCK_SIZE & 0xff;
1703 
1704         tw_transfer_internal(tw_dev, request_id, buff, sizeof(buff));
1705 
1706         return 0;
1707 } /* End tw_scsiop_read_capacity_complete() */
1708 
1709 /* This function handles scsi read or write commands */
1710 static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id) 
1711 {
1712         TW_Command *command_packet;
1713         unsigned long command_que_value;
1714         u32 lba = 0x0, num_sectors = 0x0;
1715         int i, use_sg;
1716         struct scsi_cmnd *srb;
1717         struct scatterlist *sglist, *sg;
1718 
1719         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n");
1720 
1721         srb = tw_dev->srb[request_id];
1722 
1723         sglist = scsi_sglist(srb);
1724         if (!sglist) {
1725                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n");
1726                 return 1;
1727         }
1728 
1729         /* Initialize command packet */
1730         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1731         if (command_packet == NULL) {
1732                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n");
1733                 return 1;
1734         }
1735 
1736         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) {
1737                 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ);
1738         } else {
1739                 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE);
1740         }
1741 
1742         command_packet->size = 3;
1743         command_packet->request_id = request_id;
1744         command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id);
1745         command_packet->status = 0;
1746         command_packet->flags = 0;
1747 
1748         if (srb->cmnd[0] == WRITE_10) {
1749                 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10))
1750                         command_packet->flags = 1;
1751         }
1752 
1753         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) {
1754                 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3];
1755                 num_sectors = (u32)srb->cmnd[4];
1756         } else {
1757                 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5];
1758                 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1759         }
1760   
1761         /* Update sector statistic */
1762         tw_dev->sector_count = num_sectors;
1763         if (tw_dev->sector_count > tw_dev->max_sector_count)
1764                 tw_dev->max_sector_count = tw_dev->sector_count;
1765   
1766         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors);
1767         command_packet->byte8.io.lba = lba;
1768         command_packet->byte6.block_count = num_sectors;
1769 
1770         use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1771         if (!use_sg)
1772                 return 1;
1773 
1774         scsi_for_each_sg(tw_dev->srb[request_id], sg, use_sg, i) {
1775                 command_packet->byte8.io.sgl[i].address = sg_dma_address(sg);
1776                 command_packet->byte8.io.sgl[i].length = sg_dma_len(sg);
1777                 command_packet->size+=2;
1778         }
1779 
1780         /* Update SG statistics */
1781         tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1782         if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1783                 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1784 
1785         command_que_value = tw_dev->command_packet_physical_address[request_id];
1786         if (command_que_value == 0) {
1787                 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n");
1788                 return 1;
1789         }
1790       
1791         /* Now try to post the command to the board */
1792         tw_post_command_packet(tw_dev, request_id);
1793 
1794         return 0;
1795 } /* End tw_scsiop_read_write() */
1796 
1797 /* This function will handle the request sense scsi command */
1798 static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id)
1799 {
1800         char request_buffer[18];
1801 
1802         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n");
1803 
1804         memset(request_buffer, 0, sizeof(request_buffer));
1805         request_buffer[0] = 0x70; /* Immediate fixed format */
1806         request_buffer[7] = 10; /* minimum size per SPC: 18 bytes */
1807         /* leave all other fields zero, giving effectively NO_SENSE return */
1808         tw_transfer_internal(tw_dev, request_id, request_buffer,
1809                              sizeof(request_buffer));
1810 
1811         tw_dev->state[request_id] = TW_S_COMPLETED;
1812         tw_state_request_finish(tw_dev, request_id);
1813 
1814         /* If we got a request_sense, we probably want a reset, return error */
1815         tw_dev->srb[request_id]->result = (DID_ERROR << 16);
1816         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1817 
1818         return 0;
1819 } /* End tw_scsiop_request_sense() */
1820 
1821 /* This function will handle synchronize cache scsi command */
1822 static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id)
1823 {
1824         TW_Command *command_packet;
1825         unsigned long command_que_value;
1826 
1827         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n");
1828 
1829         /* Send firmware flush command for this unit */
1830         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1831         if (command_packet == NULL) {
1832                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n");
1833                 return 1;
1834         }
1835 
1836         /* Setup the command packet */
1837         memset(command_packet, 0, sizeof(TW_Sector));
1838         command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE);
1839         command_packet->size = 2;
1840         command_packet->request_id = request_id;
1841         command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1842         command_packet->status = 0;
1843         command_packet->flags = 0;
1844         command_packet->byte6.parameter_count = 1;
1845         command_que_value = tw_dev->command_packet_physical_address[request_id];
1846         if (command_que_value == 0) {
1847                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n");
1848                 return 1;
1849         }
1850 
1851         /* Now try to post the command packet */
1852         tw_post_command_packet(tw_dev, request_id);
1853 
1854         return 0;
1855 } /* End tw_scsiop_synchronize_cache() */
1856 
1857 /* This function will handle test unit ready scsi command */
1858 static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id)
1859 {
1860         TW_Param *param;
1861         TW_Command *command_packet;
1862         unsigned long command_que_value;
1863         unsigned long param_value;
1864 
1865         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n");
1866 
1867         /* Initialize command packet */
1868         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1869         if (command_packet == NULL) {
1870                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n");
1871                 return 1;
1872         }
1873         memset(command_packet, 0, sizeof(TW_Sector));
1874         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1875         command_packet->size = 4;
1876         command_packet->request_id = request_id;
1877         command_packet->status = 0;
1878         command_packet->flags = 0;
1879         command_packet->byte6.parameter_count = 1;
1880 
1881         /* Now setup the param */
1882         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1883                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n");
1884                 return 1;
1885         }
1886         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1887         memset(param, 0, sizeof(TW_Sector));
1888         param->table_id = 3;     /* unit summary table */
1889         param->parameter_id = 3; /* unitsstatus parameter */
1890         param->parameter_size_bytes = TW_MAX_UNITS;
1891         param_value = tw_dev->alignment_physical_address[request_id];
1892         if (param_value == 0) {
1893                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n");
1894                 return 1;
1895         }
1896 
1897         command_packet->byte8.param.sgl[0].address = param_value;
1898         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1899         command_que_value = tw_dev->command_packet_physical_address[request_id];
1900         if (command_que_value == 0) {
1901                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n");
1902                 return 1;
1903         }
1904 
1905         /* Now try to post the command packet */
1906         tw_post_command_packet(tw_dev, request_id);
1907 
1908         return 0;
1909 } /* End tw_scsiop_test_unit_ready() */
1910 
1911 /* This function is called by the isr to complete a testunitready command */
1912 static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id)
1913 {
1914         unsigned char *is_unit_present;
1915         TW_Param *param;
1916 
1917         dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n");
1918 
1919         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1920         if (param == NULL) {
1921                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n");
1922                 return 1;
1923         }
1924         is_unit_present = &(param->data[0]);
1925 
1926         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1927                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1928         } else {
1929                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1930                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1931                 return TW_ISR_DONT_RESULT;
1932         }
1933 
1934         return 0;
1935 } /* End tw_scsiop_test_unit_ready_complete() */
1936 
1937 /* This is the main scsi queue function to handle scsi opcodes */
1938 static int tw_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1939 {
1940         unsigned char *command = SCpnt->cmnd;
1941         int request_id = 0;
1942         int retval = 1;
1943         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1944 
1945         /* If we are resetting due to timed out ioctl, report as busy */
1946         if (test_bit(TW_IN_RESET, &tw_dev->flags))
1947                 return SCSI_MLQUEUE_HOST_BUSY;
1948 
1949         /* Save done function into Scsi_Cmnd struct */
1950         SCpnt->scsi_done = done;
1951                  
1952         /* Queue the command and get a request id */
1953         tw_state_request_start(tw_dev, &request_id);
1954 
1955         /* Save the scsi command for use by the ISR */
1956         tw_dev->srb[request_id] = SCpnt;
1957 
1958         /* Initialize phase to zero */
1959         SCpnt->SCp.phase = TW_PHASE_INITIAL;
1960 
1961         switch (*command) {
1962                 case READ_10:
1963                 case READ_6:
1964                 case WRITE_10:
1965                 case WRITE_6:
1966                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
1967                         retval = tw_scsiop_read_write(tw_dev, request_id);
1968                         break;
1969                 case TEST_UNIT_READY:
1970                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
1971                         retval = tw_scsiop_test_unit_ready(tw_dev, request_id);
1972                         break;
1973                 case INQUIRY:
1974                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
1975                         retval = tw_scsiop_inquiry(tw_dev, request_id);
1976                         break;
1977                 case READ_CAPACITY:
1978                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
1979                         retval = tw_scsiop_read_capacity(tw_dev, request_id);
1980                         break;
1981                 case REQUEST_SENSE:
1982                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
1983                         retval = tw_scsiop_request_sense(tw_dev, request_id);
1984                         break;
1985                 case MODE_SENSE:
1986                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
1987                         retval = tw_scsiop_mode_sense(tw_dev, request_id);
1988                         break;
1989                 case SYNCHRONIZE_CACHE:
1990                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
1991                         retval = tw_scsiop_synchronize_cache(tw_dev, request_id);
1992                         break;
1993                 case TW_IOCTL:
1994                         printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n");
1995                         break;
1996                 default:
1997                         printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
1998                         tw_dev->state[request_id] = TW_S_COMPLETED;
1999                         tw_state_request_finish(tw_dev, request_id);
2000                         SCpnt->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
2001                         scsi_build_sense_buffer(1, SCpnt->sense_buffer, ILLEGAL_REQUEST, 0x20, 0);
2002                         done(SCpnt);
2003                         retval = 0;
2004         }
2005         if (retval) {
2006                 tw_dev->state[request_id] = TW_S_COMPLETED;
2007                 tw_state_request_finish(tw_dev, request_id);
2008                 SCpnt->result = (DID_ERROR << 16);
2009                 done(SCpnt);
2010                 retval = 0;
2011         }
2012         return retval;
2013 } /* End tw_scsi_queue() */
2014 
2015 static DEF_SCSI_QCMD(tw_scsi_queue)
2016 
2017 /* This function is the interrupt service routine */
2018 static irqreturn_t tw_interrupt(int irq, void *dev_instance) 
2019 {
2020         int request_id;
2021         u32 status_reg_value;
2022         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
2023         TW_Response_Queue response_que;
2024         int error = 0, retval = 0;
2025         TW_Command *command_packet;
2026         int handled = 0;
2027 
2028         /* Get the host lock for io completions */
2029         spin_lock(tw_dev->host->host_lock);
2030 
2031         /* Read the registers */
2032         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2033 
2034         /* Check if this is our interrupt, otherwise bail */
2035         if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
2036                 goto tw_interrupt_bail;
2037 
2038         handled = 1;
2039 
2040         /* If we are resetting, bail */
2041         if (test_bit(TW_IN_RESET, &tw_dev->flags))
2042                 goto tw_interrupt_bail;
2043 
2044         /* Check controller for errors */
2045         if (tw_check_bits(status_reg_value)) {
2046                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2047                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2048                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2049                         goto tw_interrupt_bail;
2050                 }
2051         }
2052 
2053         /* Handle host interrupt */
2054         if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
2055                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
2056                 TW_CLEAR_HOST_INTERRUPT(tw_dev);
2057         }
2058 
2059         /* Handle attention interrupt */
2060         if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
2061                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
2062                 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
2063                 tw_state_request_start(tw_dev, &request_id);
2064                 error = tw_aen_read_queue(tw_dev, request_id);
2065                 if (error) {
2066                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
2067                         tw_dev->state[request_id] = TW_S_COMPLETED;
2068                         tw_state_request_finish(tw_dev, request_id);
2069                 }
2070         }
2071 
2072         /* Handle command interrupt */
2073         if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
2074                 /* Drain as many pending commands as we can */
2075                 while (tw_dev->pending_request_count > 0) {
2076                         request_id = tw_dev->pending_queue[tw_dev->pending_head];
2077                         if (tw_dev->state[request_id] != TW_S_PENDING) {
2078                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
2079                                 break;
2080                         }
2081                         if (tw_post_command_packet(tw_dev, request_id)==0) {
2082                                 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2083                                         tw_dev->pending_head = TW_Q_START;
2084                                 } else {
2085                                         tw_dev->pending_head = tw_dev->pending_head + 1;
2086                                 }
2087                                 tw_dev->pending_request_count--;
2088                         } else {
2089                                 /* If we get here, we will continue re-posting on the next command interrupt */
2090                                 break;
2091                         }
2092                 }
2093                 /* If there are no more pending requests, we mask command interrupt */
2094                 if (tw_dev->pending_request_count == 0) 
2095                         TW_MASK_COMMAND_INTERRUPT(tw_dev);
2096         }
2097 
2098         /* Handle response interrupt */
2099         if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
2100                 /* Drain the response queue from the board */
2101                 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
2102                         /* Read response queue register */
2103                         response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
2104                         request_id = TW_RESID_OUT(response_que.response_id);
2105                         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2106                         error = 0;
2107 
2108                         /* Check for bad response */
2109                         if (command_packet->status != 0) {
2110                                 /* If internal command, don't error, don't fill sense */
2111                                 if (tw_dev->srb[request_id] == NULL) {
2112                                         tw_decode_sense(tw_dev, request_id, 0);
2113                                 } else {
2114                                         error = tw_decode_sense(tw_dev, request_id, 1);
2115                                 }
2116                         }
2117 
2118                         /* Check for correct state */
2119                         if (tw_dev->state[request_id] != TW_S_POSTED) {
2120                                 if (tw_dev->srb[request_id] != NULL) {
2121                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no);
2122                                         error = 1;
2123                                 }
2124                         }
2125 
2126                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
2127 
2128                         /* Check for internal command completion */
2129                         if (tw_dev->srb[request_id] == NULL) {
2130                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
2131                                 /* Check for chrdev ioctl completion */
2132                                 if (request_id != tw_dev->chrdev_request_id) {
2133                                         retval = tw_aen_complete(tw_dev, request_id);
2134                                         if (retval) {
2135                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
2136                                         }
2137                                 } else {
2138                                         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2139                                         wake_up(&tw_dev->ioctl_wqueue);
2140                                 }
2141                         } else {
2142                                 switch (tw_dev->srb[request_id]->cmnd[0]) {
2143                                 case READ_10:
2144                                 case READ_6:
2145                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
2146                                         break;
2147                                 case WRITE_10:
2148                                 case WRITE_6:
2149                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
2150                                         break;
2151                                 case TEST_UNIT_READY:
2152                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
2153                                         error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
2154                                         break;
2155                                 case INQUIRY:
2156                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
2157                                         error = tw_scsiop_inquiry_complete(tw_dev, request_id);
2158                                         break;
2159                                 case READ_CAPACITY:
2160                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
2161                                         error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
2162                                         break;
2163                                 case MODE_SENSE:
2164                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
2165                                         error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
2166                                         break;
2167                                 case SYNCHRONIZE_CACHE:
2168                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
2169                                         break;
2170                                 default:
2171                                         printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
2172                                         error = 1;
2173                                 }
2174 
2175                                 /* If no error command was a success */
2176                                 if (error == 0) {
2177                                         tw_dev->srb[request_id]->result = (DID_OK << 16);
2178                                 }
2179 
2180                                 /* If error, command failed */
2181                                 if (error == 1) {
2182                                         /* Ask for a host reset */
2183                                         tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
2184                                 }
2185 
2186                                 /* Now complete the io */
2187                                 if ((error != TW_ISR_DONT_COMPLETE)) {
2188                                         tw_dev->state[request_id] = TW_S_COMPLETED;
2189                                         tw_state_request_finish(tw_dev, request_id);
2190                                         tw_dev->posted_request_count--;
2191                                         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2192                                         
2193                                         tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
2194                                 }
2195                         }
2196                                 
2197                         /* Check for valid status after each drain */
2198                         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2199                         if (tw_check_bits(status_reg_value)) {
2200                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2201                                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2202                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2203                                         goto tw_interrupt_bail;
2204                                 }
2205                         }
2206                 }
2207         }
2208 
2209 tw_interrupt_bail:
2210         spin_unlock(tw_dev->host->host_lock);
2211         return IRQ_RETVAL(handled);
2212 } /* End tw_interrupt() */
2213 
2214 /* This function tells the controller to shut down */
2215 static void __tw_shutdown(TW_Device_Extension *tw_dev)
2216 {
2217         /* Disable interrupts */
2218         TW_DISABLE_INTERRUPTS(tw_dev);
2219 
2220         /* Free up the IRQ */
2221         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2222 
2223         printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no);
2224 
2225         /* Tell the card we are shutting down */
2226         if (tw_initconnection(tw_dev, 1)) {
2227                 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n");
2228         } else {
2229                 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n");
2230         }
2231 
2232         /* Clear all interrupts just before exit */
2233         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2234 } /* End __tw_shutdown() */
2235 
2236 /* Wrapper for __tw_shutdown */
2237 static void tw_shutdown(struct pci_dev *pdev)
2238 {
2239         struct Scsi_Host *host = pci_get_drvdata(pdev);
2240         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2241 
2242         __tw_shutdown(tw_dev);
2243 } /* End tw_shutdown() */
2244 
2245 /* This function gets called when a disk is coming online */
2246 static int tw_slave_configure(struct scsi_device *sdev)
2247 {
2248         /* Force 60 second timeout */
2249         blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
2250 
2251         return 0;
2252 } /* End tw_slave_configure() */
2253 
2254 static struct scsi_host_template driver_template = {
2255         .module                 = THIS_MODULE,
2256         .name                   = "3ware Storage Controller",
2257         .queuecommand           = tw_scsi_queue,
2258         .eh_host_reset_handler  = tw_scsi_eh_reset,
2259         .bios_param             = tw_scsi_biosparam,
2260         .change_queue_depth     = scsi_change_queue_depth,
2261         .can_queue              = TW_Q_LENGTH-2,
2262         .slave_configure        = tw_slave_configure,
2263         .this_id                = -1,
2264         .sg_tablesize           = TW_MAX_SGL_LENGTH,
2265         .max_sectors            = TW_MAX_SECTORS,
2266         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,  
2267         .use_clustering         = ENABLE_CLUSTERING,
2268         .shost_attrs            = tw_host_attrs,
2269         .emulated               = 1,
2270         .no_write_same          = 1,
2271 };
2272 
2273 /* This function will probe and initialize a card */
2274 static int tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2275 {
2276         struct Scsi_Host *host = NULL;
2277         TW_Device_Extension *tw_dev;
2278         int retval = -ENODEV;
2279 
2280         retval = pci_enable_device(pdev);
2281         if (retval) {
2282                 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device.");
2283                 goto out_disable_device;
2284         }
2285 
2286         pci_set_master(pdev);
2287 
2288         retval = pci_set_dma_mask(pdev, TW_DMA_MASK);
2289         if (retval) {
2290                 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask.");
2291                 goto out_disable_device;
2292         }
2293 
2294         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2295         if (!host) {
2296                 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension.");
2297                 retval = -ENOMEM;
2298                 goto out_disable_device;
2299         }
2300         tw_dev = (TW_Device_Extension *)host->hostdata;
2301 
2302         /* Save values to device extension */
2303         tw_dev->host = host;
2304         tw_dev->tw_pci_dev = pdev;
2305 
2306         if (tw_initialize_device_extension(tw_dev)) {
2307                 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension.");
2308                 goto out_free_device_extension;
2309         }
2310 
2311         /* Request IO regions */
2312         retval = pci_request_regions(pdev, "3w-xxxx");
2313         if (retval) {
2314                 printk(KERN_WARNING "3w-xxxx: Failed to get mem region.");
2315                 goto out_free_device_extension;
2316         }
2317 
2318         /* Save base address */
2319         tw_dev->base_addr = pci_resource_start(pdev, 0);
2320         if (!tw_dev->base_addr) {
2321                 printk(KERN_WARNING "3w-xxxx: Failed to get io address.");
2322                 goto out_release_mem_region;
2323         }
2324 
2325         /* Disable interrupts on the card */
2326         TW_DISABLE_INTERRUPTS(tw_dev);
2327 
2328         /* Initialize the card */
2329         if (tw_reset_sequence(tw_dev))
2330                 goto out_release_mem_region;
2331 
2332         /* Set host specific parameters */
2333         host->max_id = TW_MAX_UNITS;
2334         host->max_cmd_len = TW_MAX_CDB_LEN;
2335 
2336         /* Luns and channels aren't supported by adapter */
2337         host->max_lun = 0;
2338         host->max_channel = 0;
2339 
2340         /* Register the card with the kernel SCSI layer */
2341         retval = scsi_add_host(host, &pdev->dev);
2342         if (retval) {
2343                 printk(KERN_WARNING "3w-xxxx: scsi add host failed");
2344                 goto out_release_mem_region;
2345         }
2346 
2347         pci_set_drvdata(pdev, host);
2348 
2349         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);
2350 
2351         /* Now setup the interrupt handler */
2352         retval = request_irq(pdev->irq, tw_interrupt, IRQF_SHARED, "3w-xxxx", tw_dev);
2353         if (retval) {
2354                 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ.");
2355                 goto out_remove_host;
2356         }
2357 
2358         tw_device_extension_list[tw_device_extension_count] = tw_dev;
2359         tw_device_extension_count++;
2360 
2361         /* Re-enable interrupts on the card */
2362         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2363 
2364         /* Finally, scan the host */
2365         scsi_scan_host(host);
2366 
2367         if (twe_major == -1) {
2368                 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0)
2369                         printk(KERN_WARNING "3w-xxxx: Failed to register character device.");
2370         }
2371         return 0;
2372 
2373 out_remove_host:
2374         scsi_remove_host(host);
2375 out_release_mem_region:
2376         pci_release_regions(pdev);
2377 out_free_device_extension:
2378         tw_free_device_extension(tw_dev);
2379         scsi_host_put(host);
2380 out_disable_device:
2381         pci_disable_device(pdev);
2382 
2383         return retval;
2384 } /* End tw_probe() */
2385 
2386 /* This function is called to remove a device */
2387 static void tw_remove(struct pci_dev *pdev)
2388 {
2389         struct Scsi_Host *host = pci_get_drvdata(pdev);
2390         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2391 
2392         scsi_remove_host(tw_dev->host);
2393 
2394         /* Unregister character device */
2395         if (twe_major >= 0) {
2396                 unregister_chrdev(twe_major, "twe");
2397                 twe_major = -1;
2398         }
2399 
2400         /* Shutdown the card */
2401         __tw_shutdown(tw_dev);
2402 
2403         /* Free up the mem region */
2404         pci_release_regions(pdev);
2405 
2406         /* Free up device extension resources */
2407         tw_free_device_extension(tw_dev);
2408 
2409         scsi_host_put(tw_dev->host);
2410         pci_disable_device(pdev);
2411         tw_device_extension_count--;
2412 } /* End tw_remove() */
2413 
2414 /* PCI Devices supported by this driver */
2415 static struct pci_device_id tw_pci_tbl[] = {
2416         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000,
2417           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2418         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000,
2419           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2420         { }
2421 };
2422 MODULE_DEVICE_TABLE(pci, tw_pci_tbl);
2423 
2424 /* pci_driver initializer */
2425 static struct pci_driver tw_driver = {
2426         .name           = "3w-xxxx",
2427         .id_table       = tw_pci_tbl,
2428         .probe          = tw_probe,
2429         .remove         = tw_remove,
2430         .shutdown       = tw_shutdown,
2431 };
2432 
2433 /* This function is called on driver initialization */
2434 static int __init tw_init(void)
2435 {
2436         printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2437 
2438         return pci_register_driver(&tw_driver);
2439 } /* End tw_init() */
2440 
2441 /* This function is called on driver exit */
2442 static void __exit tw_exit(void)
2443 {
2444         pci_unregister_driver(&tw_driver);
2445 } /* End tw_exit() */
2446 
2447 module_init(tw_init);
2448 module_exit(tw_exit);
2449 
2450 

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