2 3w-xxxx.c -- 3ware Storage Controller device driver for Linux.
4 Written By: Adam Radford <linuxraid@amcc.com>
5 Modifications By: Joel Jacobson <linux@3ware.com>
6 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
7 Brad Strand <linux@3ware.com>
9 Copyright (C) 1999-2004 3ware Inc.
11 Kernel compatiblity By: Andre Hedrick <andre@suse.com>
12 Non-Copyright (C) 2000 Andre Hedrick <andre@suse.com>
14 Further tiny build fixes and trivial hoovering Alan Cox
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.
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.
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.
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
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
49 Bugs/Comments/Suggestions should be mailed to:
52 For more information, goto:
57 0.1.000 - Initial release.
58 0.4.000 - Added support for Asynchronous Event Notification through
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
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
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
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
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
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
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
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
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.
190 #include <linux/module.h>
191 #include <linux/reboot.h>
192 #include <linux/spinlock.h>
193 #include <linux/interrupt.h>
194 #include <linux/moduleparam.h>
195 #include <linux/errno.h>
196 #include <linux/types.h>
197 #include <linux/delay.h>
198 #include <linux/pci.h>
199 #include <linux/time.h>
202 #include <asm/uaccess.h>
203 #include <scsi/scsi.h>
204 #include <scsi/scsi_host.h>
205 #include <scsi/scsi_tcq.h>
206 #include <scsi/scsi_cmnd.h>
210 #define TW_DRIVER_VERSION "1.26.02.000"
211 static TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT];
212 static int tw_device_extension_count = 0;
213 static int twe_major = -1;
215 /* Module parameters */
216 MODULE_AUTHOR("AMCC");
217 MODULE_DESCRIPTION("3ware Storage Controller Linux Driver");
218 MODULE_LICENSE("GPL");
219 MODULE_VERSION(TW_DRIVER_VERSION);
221 /* Function prototypes */
222 static int tw_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
226 /* This function will check the status register for unexpected bits */
227 static int tw_check_bits(u32 status_reg_value)
229 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) {
230 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value);
233 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) {
234 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value);
239 } /* End tw_check_bits() */
241 /* This function will print readable messages from status register errors */
242 static int tw_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value, int print_host)
246 dprintk(KERN_WARNING "3w-xxxx: tw_decode_bits()\n");
249 sprintf(host, " scsi%d:", tw_dev->host->host_no);
253 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
254 printk(KERN_WARNING "3w-xxxx:%s PCI Parity Error: clearing.\n", host);
255 outl(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
258 if (status_reg_value & TW_STATUS_PCI_ABORT) {
259 printk(KERN_WARNING "3w-xxxx:%s PCI Abort: clearing.\n", host);
260 outl(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
261 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
264 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
265 printk(KERN_WARNING "3w-xxxx:%s Controller Queue Error: clearing.\n", host);
266 outl(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
269 if (status_reg_value & TW_STATUS_SBUF_WRITE_ERROR) {
270 printk(KERN_WARNING "3w-xxxx:%s SBUF Write Error: clearing.\n", host);
271 outl(TW_CONTROL_CLEAR_SBUF_WRITE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
274 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
275 if (tw_dev->reset_print == 0) {
276 printk(KERN_WARNING "3w-xxxx:%s Microcontroller Error: clearing.\n", host);
277 tw_dev->reset_print = 1;
283 } /* End tw_decode_bits() */
285 /* This function will poll the status register for a flag */
286 static int tw_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
288 u32 status_reg_value;
289 unsigned long before;
292 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
295 if (tw_check_bits(status_reg_value))
296 tw_decode_bits(tw_dev, status_reg_value, 0);
298 while ((status_reg_value & flag) != flag) {
299 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
301 if (tw_check_bits(status_reg_value))
302 tw_decode_bits(tw_dev, status_reg_value, 0);
304 if (time_after(jiffies, before + HZ * seconds))
312 } /* End tw_poll_status() */
314 /* This function will poll the status register for disappearance of a flag */
315 static int tw_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
317 u32 status_reg_value;
318 unsigned long before;
321 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
324 if (tw_check_bits(status_reg_value))
325 tw_decode_bits(tw_dev, status_reg_value, 0);
327 while ((status_reg_value & flag) != 0) {
328 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
330 if (tw_check_bits(status_reg_value))
331 tw_decode_bits(tw_dev, status_reg_value, 0);
333 if (time_after(jiffies, before + HZ * seconds))
341 } /* End tw_poll_status_gone() */
343 /* This function will attempt to post a command packet to the board */
344 static int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
346 u32 status_reg_value;
347 unsigned long command_que_value;
349 dprintk(KERN_NOTICE "3w-xxxx: tw_post_command_packet()\n");
350 command_que_value = tw_dev->command_packet_physical_address[request_id];
351 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
353 if (tw_check_bits(status_reg_value)) {
354 dprintk(KERN_WARNING "3w-xxxx: tw_post_command_packet(): Unexpected bits.\n");
355 tw_decode_bits(tw_dev, status_reg_value, 1);
358 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
359 /* We successfully posted the command packet */
360 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
361 tw_dev->state[request_id] = TW_S_POSTED;
362 tw_dev->posted_request_count++;
363 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
364 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
367 /* Couldn't post the command packet, so we do it in the isr */
368 if (tw_dev->state[request_id] != TW_S_PENDING) {
369 tw_dev->state[request_id] = TW_S_PENDING;
370 tw_dev->pending_request_count++;
371 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
372 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
374 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
375 if (tw_dev->pending_tail == TW_Q_LENGTH-1) {
376 tw_dev->pending_tail = TW_Q_START;
378 tw_dev->pending_tail = tw_dev->pending_tail + 1;
381 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
385 } /* End tw_post_command_packet() */
387 /* This function will return valid sense buffer information for failed cmds */
388 static int tw_decode_sense(TW_Device_Extension *tw_dev, int request_id, int fill_sense)
393 dprintk(KERN_WARNING "3w-xxxx: tw_decode_sense()\n");
394 command = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
396 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));
398 /* Attempt to return intelligent sense information */
400 if ((command->status == 0xc7) || (command->status == 0xcb)) {
401 for (i=0;i<(sizeof(tw_sense_table)/sizeof(tw_sense_table[0]));i++) {
402 if (command->flags == tw_sense_table[i][0]) {
404 /* Valid bit and 'current errors' */
405 tw_dev->srb[request_id]->sense_buffer[0] = (0x1 << 7 | 0x70);
408 tw_dev->srb[request_id]->sense_buffer[2] = tw_sense_table[i][1];
410 /* Additional sense length */
411 tw_dev->srb[request_id]->sense_buffer[7] = 0xa; /* 10 bytes */
413 /* Additional sense code */
414 tw_dev->srb[request_id]->sense_buffer[12] = tw_sense_table[i][2];
416 /* Additional sense code qualifier */
417 tw_dev->srb[request_id]->sense_buffer[13] = tw_sense_table[i][3];
419 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
420 return TW_ISR_DONT_RESULT; /* Special case for isr to not over-write result */
425 /* If no table match, error so we get a reset */
430 } /* End tw_decode_sense() */
432 /* This function will report controller error status */
433 static int tw_check_errors(TW_Device_Extension *tw_dev)
435 u32 status_reg_value;
437 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
439 if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) {
440 tw_decode_bits(tw_dev, status_reg_value, 0);
445 } /* End tw_check_errors() */
447 /* This function will empty the response que */
448 static void tw_empty_response_que(TW_Device_Extension *tw_dev)
450 u32 status_reg_value, response_que_value;
452 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
454 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
455 response_que_value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
456 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
458 } /* End tw_empty_response_que() */
460 /* This function will free a request_id */
461 static void tw_state_request_finish(TW_Device_Extension *tw_dev, int request_id)
463 tw_dev->free_queue[tw_dev->free_tail] = request_id;
464 tw_dev->state[request_id] = TW_S_FINISHED;
465 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
466 } /* End tw_state_request_finish() */
468 /* This function will assign an available request_id */
469 static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id)
471 *request_id = tw_dev->free_queue[tw_dev->free_head];
472 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
473 tw_dev->state[*request_id] = TW_S_STARTED;
474 } /* End tw_state_request_start() */
476 /* Show some statistics about the card */
477 static ssize_t tw_show_stats(struct class_device *class_dev, char *buf)
479 struct Scsi_Host *host = class_to_shost(class_dev);
480 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
481 unsigned long flags = 0;
484 spin_lock_irqsave(tw_dev->host->host_lock, flags);
485 len = snprintf(buf, PAGE_SIZE, "3w-xxxx Driver version: %s\n"
486 "Current commands posted: %4d\n"
487 "Max commands posted: %4d\n"
488 "Current pending commands: %4d\n"
489 "Max pending commands: %4d\n"
490 "Last sgl length: %4d\n"
491 "Max sgl length: %4d\n"
492 "Last sector count: %4d\n"
493 "Max sector count: %4d\n"
494 "SCSI Host Resets: %4d\n"
497 tw_dev->posted_request_count,
498 tw_dev->max_posted_request_count,
499 tw_dev->pending_request_count,
500 tw_dev->max_pending_request_count,
502 tw_dev->max_sgl_entries,
503 tw_dev->sector_count,
504 tw_dev->max_sector_count,
507 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
509 } /* End tw_show_stats() */
511 /* This function will set a devices queue depth */
512 static ssize_t tw_store_queue_depth(struct device *dev, const char *buf, size_t count)
515 struct scsi_device *sdev = to_scsi_device(dev);
517 queue_depth = simple_strtoul(buf, NULL, 0);
518 if (queue_depth > TW_Q_LENGTH-2)
520 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
523 } /* End tw_store_queue_depth() */
525 /* Create sysfs 'queue_depth' entry */
526 static struct device_attribute tw_queue_depth_attr = {
528 .name = "queue_depth",
529 .mode = S_IRUSR | S_IWUSR,
531 .store = tw_store_queue_depth
534 /* Device attributes initializer */
535 static struct device_attribute *tw_dev_attrs[] = {
536 &tw_queue_depth_attr,
540 /* Create sysfs 'stats' entry */
541 static struct class_device_attribute tw_host_stats_attr = {
546 .show = tw_show_stats
549 /* Host attributes initializer */
550 static struct class_device_attribute *tw_host_attrs[] = {
555 /* This function will read the aen queue from the isr */
556 static int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
558 TW_Command *command_packet;
560 unsigned long command_que_value;
561 u32 status_reg_value;
562 unsigned long param_value = 0;
564 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n");
566 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
567 if (tw_check_bits(status_reg_value)) {
568 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n");
569 tw_decode_bits(tw_dev, status_reg_value, 1);
572 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
573 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n");
576 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
577 memset(command_packet, 0, sizeof(TW_Sector));
578 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
579 command_packet->size = 4;
580 command_packet->request_id = request_id;
581 command_packet->status = 0;
582 command_packet->flags = 0;
583 command_packet->byte6.parameter_count = 1;
584 command_que_value = tw_dev->command_packet_physical_address[request_id];
585 if (command_que_value == 0) {
586 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n");
589 /* Now setup the param */
590 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
591 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n");
594 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
595 memset(param, 0, sizeof(TW_Sector));
596 param->table_id = 0x401; /* AEN table */
597 param->parameter_id = 2; /* Unit code */
598 param->parameter_size_bytes = 2;
599 param_value = tw_dev->alignment_physical_address[request_id];
600 if (param_value == 0) {
601 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n");
604 command_packet->byte8.param.sgl[0].address = param_value;
605 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
607 /* Now post the command packet */
608 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
609 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n");
610 tw_dev->srb[request_id] = NULL; /* Flag internal command */
611 tw_dev->state[request_id] = TW_S_POSTED;
612 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
614 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n");
619 } /* End tw_aen_read_queue() */
621 /* This function will complete an aen request from the isr */
622 static int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id)
626 int error = 0, table_max = 0;
628 dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n");
629 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
630 printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n");
633 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
634 aen = *(unsigned short *)(param->data);
635 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen);
637 /* Print some useful info when certain aen codes come out */
639 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no);
641 table_max = sizeof(tw_aen_string)/sizeof(char *);
642 if ((aen & 0x0ff) < table_max) {
643 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
644 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8);
647 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]);
650 printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen);
653 if (aen != TW_AEN_QUEUE_EMPTY) {
656 /* Now queue the code */
657 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
658 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
659 tw_dev->aen_tail = TW_Q_START;
661 tw_dev->aen_tail = tw_dev->aen_tail + 1;
663 if (tw_dev->aen_head == tw_dev->aen_tail) {
664 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
665 tw_dev->aen_head = TW_Q_START;
667 tw_dev->aen_head = tw_dev->aen_head + 1;
671 error = tw_aen_read_queue(tw_dev, request_id);
673 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no);
674 tw_dev->state[request_id] = TW_S_COMPLETED;
675 tw_state_request_finish(tw_dev, request_id);
678 tw_dev->state[request_id] = TW_S_COMPLETED;
679 tw_state_request_finish(tw_dev, request_id);
683 } /* End tw_aen_complete() */
685 /* This function will drain the aen queue after a soft reset */
686 static int tw_aen_drain_queue(TW_Device_Extension *tw_dev)
688 TW_Command *command_packet;
691 unsigned long command_que_value;
692 unsigned long param_value;
693 TW_Response_Queue response_queue;
695 unsigned short aen_code;
699 int found = 0, table_max = 0;
701 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n");
703 if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) {
704 dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count);
707 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
709 /* Empty response queue */
710 tw_empty_response_que(tw_dev);
712 /* Initialize command packet */
713 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
714 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n");
717 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
718 memset(command_packet, 0, sizeof(TW_Sector));
719 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
720 command_packet->size = 4;
721 command_packet->request_id = request_id;
722 command_packet->status = 0;
723 command_packet->flags = 0;
724 command_packet->byte6.parameter_count = 1;
725 command_que_value = tw_dev->command_packet_physical_address[request_id];
726 if (command_que_value == 0) {
727 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n");
731 /* Now setup the param */
732 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
733 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n");
736 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
737 memset(param, 0, sizeof(TW_Sector));
738 param->table_id = 0x401; /* AEN table */
739 param->parameter_id = 2; /* Unit code */
740 param->parameter_size_bytes = 2;
741 param_value = tw_dev->alignment_physical_address[request_id];
742 if (param_value == 0) {
743 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n");
746 command_packet->byte8.param.sgl[0].address = param_value;
747 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
749 /* Now drain the controller's aen queue */
751 /* Post command packet */
752 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
754 /* Now poll for completion */
755 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
756 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
757 request_id = TW_RESID_OUT(response_queue.response_id);
759 if (request_id != 0) {
760 /* Unexpected request id */
761 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n");
765 if (command_packet->status != 0) {
766 if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) {
768 tw_decode_sense(tw_dev, request_id, 0);
771 /* We know this is a 3w-1x00, and doesn't support aen's */
776 /* Now check the aen */
777 aen = *(unsigned short *)(param->data);
778 aen_code = (aen & 0x0ff);
781 case TW_AEN_QUEUE_EMPTY:
782 dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
783 if (first_reset != 1) {
789 case TW_AEN_SOFT_RESET:
790 if (first_reset == 0) {
793 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
800 printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n");
802 table_max = sizeof(tw_aen_string)/sizeof(char *);
803 if ((aen & 0x0ff) < table_max) {
804 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
805 printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8);
807 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
810 printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen);
816 /* Now put the aen on the aen_queue */
818 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
819 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
820 tw_dev->aen_tail = TW_Q_START;
822 tw_dev->aen_tail = tw_dev->aen_tail + 1;
824 if (tw_dev->aen_head == tw_dev->aen_tail) {
825 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
826 tw_dev->aen_head = TW_Q_START;
828 tw_dev->aen_head = tw_dev->aen_head + 1;
835 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n");
838 } while (finished == 0);
841 } /* End tw_aen_drain_queue() */
843 /* This function will allocate memory */
844 static int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
847 dma_addr_t dma_handle;
848 unsigned long *cpu_addr = NULL;
850 dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");
852 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
853 if (cpu_addr == NULL) {
854 printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n");
858 if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {
859 printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");
860 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
864 memset(cpu_addr, 0, size*TW_Q_LENGTH);
866 for (i=0;i<TW_Q_LENGTH;i++) {
869 tw_dev->command_packet_physical_address[i] = dma_handle+(i*size);
870 tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
873 tw_dev->alignment_physical_address[i] = dma_handle+(i*size);
874 tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
877 printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n");
883 } /* End tw_allocate_memory() */
885 /* This function handles ioctl for the character device */
886 static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
889 dma_addr_t dma_handle;
890 unsigned short tw_aen_code;
892 unsigned int data_buffer_length = 0;
893 unsigned long data_buffer_length_adjusted = 0;
894 unsigned long *cpu_addr;
896 TW_New_Ioctl *tw_ioctl;
897 TW_Passthru *passthru;
898 TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)];
899 int retval = -EFAULT;
900 void __user *argp = (void __user *)arg;
902 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
904 /* Only let one of these through at a time */
905 if (down_interruptible(&tw_dev->ioctl_sem))
908 /* First copy down the buffer length */
909 if (copy_from_user(&data_buffer_length, argp, sizeof(unsigned int)))
913 if (data_buffer_length > TW_MAX_SECTORS * 512) {
918 /* Hardware can only do multiple of 512 byte transfers */
919 data_buffer_length_adjusted = (data_buffer_length + 511) & ~511;
921 /* Now allocate ioctl buf memory */
922 cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle, GFP_KERNEL);
923 if (cpu_addr == NULL) {
928 tw_ioctl = (TW_New_Ioctl *)cpu_addr;
930 /* Now copy down the entire ioctl */
931 if (copy_from_user(tw_ioctl, argp, data_buffer_length + sizeof(TW_New_Ioctl) - 1))
934 passthru = (TW_Passthru *)&tw_ioctl->firmware_command;
936 /* See which ioctl we are doing */
939 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n");
941 case TW_OP_AEN_LISTEN:
942 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n");
943 memset(tw_ioctl->data_buffer, 0, data_buffer_length);
945 spin_lock_irqsave(tw_dev->host->host_lock, flags);
946 if (tw_dev->aen_head == tw_dev->aen_tail) {
947 tw_aen_code = TW_AEN_QUEUE_EMPTY;
949 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
950 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
951 tw_dev->aen_head = TW_Q_START;
953 tw_dev->aen_head = tw_dev->aen_head + 1;
956 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
957 memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code));
959 case TW_CMD_PACKET_WITH_DATA:
960 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
961 spin_lock_irqsave(tw_dev->host->host_lock, flags);
963 tw_state_request_start(tw_dev, &request_id);
965 /* Flag internal command */
966 tw_dev->srb[request_id] = NULL;
968 /* Flag chrdev ioctl */
969 tw_dev->chrdev_request_id = request_id;
971 tw_ioctl->firmware_command.request_id = request_id;
973 /* Load the sg list */
974 switch (TW_SGL_OUT(tw_ioctl->firmware_command.opcode__sgloffset)) {
976 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
977 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted;
980 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
981 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted;
984 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
985 passthru->sg_list[0].length = data_buffer_length_adjusted;
989 memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command));
991 /* Now post the command packet to the controller */
992 tw_post_command_packet(tw_dev, request_id);
993 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
995 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
997 /* Now wait for the command to complete */
998 timeout = wait_event_interruptible_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
1000 /* See if we reset while waiting for the ioctl to complete */
1001 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1002 clear_bit(TW_IN_RESET, &tw_dev->flags);
1003 retval = -ERESTARTSYS;
1007 /* Check if we timed out, got a signal, or didn't get
1009 if ((timeout <= 0) && (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE)) {
1010 /* Now we need to reset the board */
1011 if (timeout == -ERESTARTSYS) {
1014 printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd);
1017 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1018 tw_dev->state[request_id] = TW_S_COMPLETED;
1019 tw_state_request_finish(tw_dev, request_id);
1020 tw_dev->posted_request_count--;
1021 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1022 if (tw_reset_device_extension(tw_dev, 1)) {
1023 printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no);
1028 /* Now copy in the command packet response */
1029 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
1031 /* Now complete the io */
1032 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1033 tw_dev->posted_request_count--;
1034 tw_dev->state[request_id] = TW_S_COMPLETED;
1035 tw_state_request_finish(tw_dev, request_id);
1036 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1043 /* Now copy the response to userspace */
1044 if (copy_to_user(argp, tw_ioctl, sizeof(TW_New_Ioctl) + data_buffer_length - 1))
1048 /* Now free ioctl buf memory */
1049 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle);
1051 up(&tw_dev->ioctl_sem);
1053 } /* End tw_chrdev_ioctl() */
1055 /* This function handles open for the character device */
1056 static int tw_chrdev_open(struct inode *inode, struct file *file)
1058 unsigned int minor_number;
1060 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n");
1062 minor_number = iminor(inode);
1063 if (minor_number >= tw_device_extension_count)
1067 } /* End tw_chrdev_open() */
1069 /* File operations struct for character device */
1070 static struct file_operations tw_fops = {
1071 .owner = THIS_MODULE,
1072 .ioctl = tw_chrdev_ioctl,
1073 .open = tw_chrdev_open,
1077 /* This function will free up device extension resources */
1078 static void tw_free_device_extension(TW_Device_Extension *tw_dev)
1080 dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n");
1082 /* Free command packet and generic buffer memory */
1083 if (tw_dev->command_packet_virtual_address[0])
1084 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]);
1086 if (tw_dev->alignment_virtual_address[0])
1087 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]);
1088 } /* End tw_free_device_extension() */
1090 /* This function will send an initconnection command to controller */
1091 static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits)
1093 unsigned long command_que_value;
1094 TW_Command *command_packet;
1095 TW_Response_Queue response_queue;
1098 dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n");
1100 /* Initialize InitConnection command packet */
1101 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1102 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n");
1106 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1107 memset(command_packet, 0, sizeof(TW_Sector));
1108 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION);
1109 command_packet->size = TW_INIT_COMMAND_PACKET_SIZE;
1110 command_packet->request_id = request_id;
1111 command_packet->status = 0x0;
1112 command_packet->flags = 0x0;
1113 command_packet->byte6.message_credits = message_credits;
1114 command_packet->byte8.init_connection.response_queue_pointer = 0x0;
1115 command_que_value = tw_dev->command_packet_physical_address[request_id];
1117 if (command_que_value == 0) {
1118 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n");
1122 /* Send command packet to the board */
1123 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1125 /* Poll for completion */
1126 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1127 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1128 request_id = TW_RESID_OUT(response_queue.response_id);
1130 if (request_id != 0) {
1131 /* unexpected request id */
1132 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n");
1135 if (command_packet->status != 0) {
1137 tw_decode_sense(tw_dev, request_id, 0);
1142 } /* End tw_initconnection() */
1144 /* Set a value in the features table */
1145 static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size,
1149 TW_Command *command_packet;
1150 TW_Response_Queue response_queue;
1152 unsigned long command_que_value;
1153 unsigned long param_value;
1155 /* Initialize SetParam command packet */
1156 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1157 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n");
1160 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1161 memset(command_packet, 0, sizeof(TW_Sector));
1162 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1164 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
1165 param->table_id = 0x404; /* Features table */
1166 param->parameter_id = parm;
1167 param->parameter_size_bytes = param_size;
1168 memcpy(param->data, val, param_size);
1170 param_value = tw_dev->alignment_physical_address[request_id];
1171 if (param_value == 0) {
1172 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n");
1173 tw_dev->state[request_id] = TW_S_COMPLETED;
1174 tw_state_request_finish(tw_dev, request_id);
1175 tw_dev->srb[request_id]->result = (DID_OK << 16);
1176 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1178 command_packet->byte8.param.sgl[0].address = param_value;
1179 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1181 command_packet->size = 4;
1182 command_packet->request_id = request_id;
1183 command_packet->byte6.parameter_count = 1;
1185 command_que_value = tw_dev->command_packet_physical_address[request_id];
1186 if (command_que_value == 0) {
1187 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n");
1191 /* Send command packet to the board */
1192 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1194 /* Poll for completion */
1195 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1196 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1197 request_id = TW_RESID_OUT(response_queue.response_id);
1199 if (request_id != 0) {
1200 /* unexpected request id */
1201 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n");
1204 if (command_packet->status != 0) {
1206 tw_decode_sense(tw_dev, request_id, 0);
1212 } /* End tw_setfeature() */
1214 /* This function will reset a controller */
1215 static int tw_reset_sequence(TW_Device_Extension *tw_dev)
1219 unsigned char c = 1;
1221 /* Reset the board */
1222 while (tries < TW_MAX_RESET_TRIES) {
1223 TW_SOFT_RESET(tw_dev);
1225 error = tw_aen_drain_queue(tw_dev);
1227 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no);
1232 /* Check for controller errors */
1233 if (tw_check_errors(tw_dev)) {
1234 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no);
1239 /* Now the controller is in a good state */
1243 if (tries >= TW_MAX_RESET_TRIES) {
1244 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no);
1248 error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
1250 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no);
1254 error = tw_setfeature(tw_dev, 2, 1, &c);
1256 printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n");
1260 } /* End tw_reset_sequence() */
1262 /* This function will initialize the fields of a device extension */
1263 static int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
1267 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n");
1269 /* Initialize command packet buffers */
1270 error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0);
1272 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n");
1276 /* Initialize generic buffer */
1277 error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1);
1279 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n");
1283 for (i=0;i<TW_Q_LENGTH;i++) {
1284 tw_dev->free_queue[i] = i;
1285 tw_dev->state[i] = TW_S_INITIAL;
1288 tw_dev->pending_head = TW_Q_START;
1289 tw_dev->pending_tail = TW_Q_START;
1290 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1292 init_MUTEX(&tw_dev->ioctl_sem);
1293 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1296 } /* End tw_initialize_device_extension() */
1298 static int tw_map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
1302 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data()\n");
1304 if (cmd->use_sg == 0)
1307 use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, DMA_BIDIRECTIONAL);
1310 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data(): pci_map_sg() failed.\n");
1314 cmd->SCp.phase = TW_PHASE_SGLIST;
1315 cmd->SCp.have_data_in = use_sg;
1318 } /* End tw_map_scsi_sg_data() */
1320 static u32 tw_map_scsi_single_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
1324 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data()\n");
1326 if (cmd->request_bufflen == 0)
1329 mapping = pci_map_page(pdev, virt_to_page(cmd->request_buffer), offset_in_page(cmd->request_buffer), cmd->request_bufflen, DMA_BIDIRECTIONAL);
1332 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data(): pci_map_page() failed.\n");
1336 cmd->SCp.phase = TW_PHASE_SINGLE;
1337 cmd->SCp.have_data_in = mapping;
1340 } /* End tw_map_scsi_single_data() */
1342 static void tw_unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
1344 dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n");
1346 switch(cmd->SCp.phase) {
1347 case TW_PHASE_SINGLE:
1348 pci_unmap_page(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL);
1350 case TW_PHASE_SGLIST:
1351 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL);
1354 } /* End tw_unmap_scsi_data() */
1356 /* This function will reset a device extension */
1357 static int tw_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1360 struct scsi_cmnd *srb;
1361 unsigned long flags = 0;
1363 dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n");
1365 set_bit(TW_IN_RESET, &tw_dev->flags);
1366 TW_DISABLE_INTERRUPTS(tw_dev);
1367 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1368 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1370 /* Abort all requests that are in progress */
1371 for (i=0;i<TW_Q_LENGTH;i++) {
1372 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1373 (tw_dev->state[i] != TW_S_INITIAL) &&
1374 (tw_dev->state[i] != TW_S_COMPLETED)) {
1375 srb = tw_dev->srb[i];
1377 srb->result = (DID_RESET << 16);
1378 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1379 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[i]);
1384 /* Reset queues and counts */
1385 for (i=0;i<TW_Q_LENGTH;i++) {
1386 tw_dev->free_queue[i] = i;
1387 tw_dev->state[i] = TW_S_INITIAL;
1389 tw_dev->free_head = TW_Q_START;
1390 tw_dev->free_tail = TW_Q_START;
1391 tw_dev->posted_request_count = 0;
1392 tw_dev->pending_request_count = 0;
1393 tw_dev->pending_head = TW_Q_START;
1394 tw_dev->pending_tail = TW_Q_START;
1395 tw_dev->reset_print = 0;
1397 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1399 if (tw_reset_sequence(tw_dev)) {
1400 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
1403 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1405 /* Wake up any ioctl that was pending before the reset */
1406 if ((tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE) || (ioctl_reset)) {
1407 clear_bit(TW_IN_RESET, &tw_dev->flags);
1409 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1410 wake_up(&tw_dev->ioctl_wqueue);
1414 } /* End tw_reset_device_extension() */
1416 /* This funciton returns unit geometry in cylinders/heads/sectors */
1417 static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1418 sector_t capacity, int geom[])
1420 int heads, sectors, cylinders;
1421 TW_Device_Extension *tw_dev;
1423 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n");
1424 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1428 cylinders = sector_div(capacity, heads * sectors);
1430 if (capacity >= 0x200000) {
1433 cylinders = sector_div(capacity, heads * sectors);
1436 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders);
1439 geom[2] = cylinders;
1442 } /* End tw_scsi_biosparam() */
1444 /* This is the new scsi eh reset function */
1445 static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1447 TW_Device_Extension *tw_dev=NULL;
1448 int retval = FAILED;
1450 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1452 spin_unlock_irq(tw_dev->host->host_lock);
1454 tw_dev->num_resets++;
1456 printk(KERN_WARNING "3w-xxxx: scsi%d: WARNING: Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, SCpnt->device->id, SCpnt->cmnd[0]);
1458 /* Now reset the card and some of the device extension data */
1459 if (tw_reset_device_extension(tw_dev, 0)) {
1460 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no);
1466 spin_lock_irq(tw_dev->host->host_lock);
1468 } /* End tw_scsi_eh_reset() */
1470 /* This function handles scsi inquiry commands */
1471 static int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id)
1474 TW_Command *command_packet;
1475 unsigned long command_que_value;
1476 unsigned long param_value;
1478 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n");
1480 /* Initialize command packet */
1481 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1482 if (command_packet == NULL) {
1483 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n");
1486 memset(command_packet, 0, sizeof(TW_Sector));
1487 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1488 command_packet->size = 4;
1489 command_packet->request_id = request_id;
1490 command_packet->status = 0;
1491 command_packet->flags = 0;
1492 command_packet->byte6.parameter_count = 1;
1494 /* Now setup the param */
1495 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1496 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n");
1499 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1500 memset(param, 0, sizeof(TW_Sector));
1501 param->table_id = 3; /* unit summary table */
1502 param->parameter_id = 3; /* unitsstatus parameter */
1503 param->parameter_size_bytes = TW_MAX_UNITS;
1504 param_value = tw_dev->alignment_physical_address[request_id];
1505 if (param_value == 0) {
1506 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n");
1510 command_packet->byte8.param.sgl[0].address = param_value;
1511 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1512 command_que_value = tw_dev->command_packet_physical_address[request_id];
1513 if (command_que_value == 0) {
1514 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n");
1518 /* Now try to post the command packet */
1519 tw_post_command_packet(tw_dev, request_id);
1522 } /* End tw_scsiop_inquiry() */
1524 /* This function is called by the isr to complete an inquiry command */
1525 static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id)
1527 unsigned char *is_unit_present;
1528 unsigned char *request_buffer;
1531 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n");
1533 /* Fill request buffer */
1534 if (tw_dev->srb[request_id]->request_buffer == NULL) {
1535 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Request buffer NULL.\n");
1538 request_buffer = tw_dev->srb[request_id]->request_buffer;
1539 memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
1540 request_buffer[0] = TYPE_DISK; /* Peripheral device type */
1541 request_buffer[1] = 0; /* Device type modifier */
1542 request_buffer[2] = 0; /* No ansi/iso compliance */
1543 request_buffer[4] = 31; /* Additional length */
1544 memcpy(&request_buffer[8], "3ware ", 8); /* Vendor ID */
1545 sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id);
1546 memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3);
1548 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1549 if (param == NULL) {
1550 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n");
1553 is_unit_present = &(param->data[0]);
1555 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1556 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1558 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1559 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1560 return TW_ISR_DONT_RESULT;
1564 } /* End tw_scsiop_inquiry_complete() */
1566 /* This function handles scsi mode_sense commands */
1567 static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id)
1570 TW_Command *command_packet;
1571 unsigned long command_que_value;
1572 unsigned long param_value;
1574 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n");
1576 /* Only page control = 0, page code = 0x8 (cache page) supported */
1577 if (tw_dev->srb[request_id]->cmnd[2] != 0x8) {
1578 tw_dev->state[request_id] = TW_S_COMPLETED;
1579 tw_state_request_finish(tw_dev, request_id);
1580 tw_dev->srb[request_id]->result = (DID_OK << 16);
1581 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1585 /* Now read firmware cache setting for this unit */
1586 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1587 if (command_packet == NULL) {
1588 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n");
1592 /* Setup the command packet */
1593 memset(command_packet, 0, sizeof(TW_Sector));
1594 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1595 command_packet->size = 4;
1596 command_packet->request_id = request_id;
1597 command_packet->status = 0;
1598 command_packet->flags = 0;
1599 command_packet->byte6.parameter_count = 1;
1601 /* Setup the param */
1602 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1603 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n");
1607 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1608 memset(param, 0, sizeof(TW_Sector));
1609 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id;
1610 param->parameter_id = 7; /* unit flags */
1611 param->parameter_size_bytes = 1;
1612 param_value = tw_dev->alignment_physical_address[request_id];
1613 if (param_value == 0) {
1614 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n");
1618 command_packet->byte8.param.sgl[0].address = param_value;
1619 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1620 command_que_value = tw_dev->command_packet_physical_address[request_id];
1621 if (command_que_value == 0) {
1622 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n");
1626 /* Now try to post the command packet */
1627 tw_post_command_packet(tw_dev, request_id);
1630 } /* End tw_scsiop_mode_sense() */
1632 /* This function is called by the isr to complete a mode sense command */
1633 static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id)
1636 unsigned char *flags;
1637 unsigned char *request_buffer;
1639 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n");
1641 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1642 if (param == NULL) {
1643 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n");
1646 flags = (char *)&(param->data[0]);
1647 request_buffer = tw_dev->srb[request_id]->buffer;
1648 memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
1650 request_buffer[0] = 0xf; /* mode data length */
1651 request_buffer[1] = 0; /* default medium type */
1652 request_buffer[2] = 0x10; /* dpo/fua support on */
1653 request_buffer[3] = 0; /* no block descriptors */
1654 request_buffer[4] = 0x8; /* caching page */
1655 request_buffer[5] = 0xa; /* page length */
1657 request_buffer[6] = 0x4; /* WCE on */
1659 request_buffer[6] = 0x0; /* WCE off */
1662 } /* End tw_scsiop_mode_sense_complete() */
1664 /* This function handles scsi read_capacity commands */
1665 static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id)
1668 TW_Command *command_packet;
1669 unsigned long command_que_value;
1670 unsigned long param_value;
1672 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n");
1674 /* Initialize command packet */
1675 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1677 if (command_packet == NULL) {
1678 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n");
1681 memset(command_packet, 0, sizeof(TW_Sector));
1682 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1683 command_packet->size = 4;
1684 command_packet->request_id = request_id;
1685 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1686 command_packet->status = 0;
1687 command_packet->flags = 0;
1688 command_packet->byte6.block_count = 1;
1690 /* Now setup the param */
1691 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1692 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n");
1695 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1696 memset(param, 0, sizeof(TW_Sector));
1697 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE +
1698 tw_dev->srb[request_id]->device->id;
1699 param->parameter_id = 4; /* unitcapacity parameter */
1700 param->parameter_size_bytes = 4;
1701 param_value = tw_dev->alignment_physical_address[request_id];
1702 if (param_value == 0) {
1703 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n");
1707 command_packet->byte8.param.sgl[0].address = param_value;
1708 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1709 command_que_value = tw_dev->command_packet_physical_address[request_id];
1710 if (command_que_value == 0) {
1711 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n");
1715 /* Now try to post the command to the board */
1716 tw_post_command_packet(tw_dev, request_id);
1719 } /* End tw_scsiop_read_capacity() */
1721 /* This function is called by the isr to complete a readcapacity command */
1722 static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id)
1724 unsigned char *param_data;
1729 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n");
1731 buff = tw_dev->srb[request_id]->request_buffer;
1733 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Request buffer NULL.\n");
1736 memset(buff, 0, tw_dev->srb[request_id]->request_bufflen);
1737 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1738 if (param == NULL) {
1739 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n");
1742 param_data = &(param->data[0]);
1744 capacity = (param_data[3] << 24) | (param_data[2] << 16) |
1745 (param_data[1] << 8) | param_data[0];
1747 /* Subtract one sector to fix get last sector ioctl */
1750 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity);
1752 /* Number of LBA's */
1753 buff[0] = (capacity >> 24);
1754 buff[1] = (capacity >> 16) & 0xff;
1755 buff[2] = (capacity >> 8) & 0xff;
1756 buff[3] = capacity & 0xff;
1758 /* Block size in bytes (512) */
1759 buff[4] = (TW_BLOCK_SIZE >> 24);
1760 buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff;
1761 buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff;
1762 buff[7] = TW_BLOCK_SIZE & 0xff;
1765 } /* End tw_scsiop_read_capacity_complete() */
1767 /* This function handles scsi read or write commands */
1768 static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id)
1770 TW_Command *command_packet;
1771 unsigned long command_que_value;
1772 u32 lba = 0x0, num_sectors = 0x0, buffaddr = 0x0;
1774 struct scsi_cmnd *srb;
1775 struct scatterlist *sglist;
1777 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n");
1779 if (tw_dev->srb[request_id]->request_buffer == NULL) {
1780 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n");
1783 sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1784 srb = tw_dev->srb[request_id];
1786 /* Initialize command packet */
1787 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1788 if (command_packet == NULL) {
1789 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n");
1793 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) {
1794 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ);
1796 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE);
1799 command_packet->size = 3;
1800 command_packet->request_id = request_id;
1801 command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id);
1802 command_packet->status = 0;
1803 command_packet->flags = 0;
1805 if (srb->cmnd[0] == WRITE_10) {
1806 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10))
1807 command_packet->flags = 1;
1810 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) {
1811 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3];
1812 num_sectors = (u32)srb->cmnd[4];
1814 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5];
1815 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1818 /* Update sector statistic */
1819 tw_dev->sector_count = num_sectors;
1820 if (tw_dev->sector_count > tw_dev->max_sector_count)
1821 tw_dev->max_sector_count = tw_dev->sector_count;
1823 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors);
1824 command_packet->byte8.io.lba = lba;
1825 command_packet->byte6.block_count = num_sectors;
1827 /* Do this if there are no sg list entries */
1828 if (tw_dev->srb[request_id]->use_sg == 0) {
1829 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): SG = 0\n");
1830 buffaddr = tw_map_scsi_single_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1834 command_packet->byte8.io.sgl[0].address = buffaddr;
1835 command_packet->byte8.io.sgl[0].length = tw_dev->srb[request_id]->request_bufflen;
1836 command_packet->size+=2;
1839 /* Do this if we have multiple sg list entries */
1840 if (tw_dev->srb[request_id]->use_sg > 0) {
1841 use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1845 for (i=0;i<use_sg; i++) {
1846 command_packet->byte8.io.sgl[i].address = sg_dma_address(&sglist[i]);
1847 command_packet->byte8.io.sgl[i].length = sg_dma_len(&sglist[i]);
1848 command_packet->size+=2;
1852 /* Update SG statistics */
1853 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg;
1854 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1855 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1857 command_que_value = tw_dev->command_packet_physical_address[request_id];
1858 if (command_que_value == 0) {
1859 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n");
1863 /* Now try to post the command to the board */
1864 tw_post_command_packet(tw_dev, request_id);
1867 } /* End tw_scsiop_read_write() */
1869 /* This function will handle the request sense scsi command */
1870 static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id)
1872 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n");
1874 /* For now we just zero the request buffer */
1875 memset(tw_dev->srb[request_id]->request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
1876 tw_dev->state[request_id] = TW_S_COMPLETED;
1877 tw_state_request_finish(tw_dev, request_id);
1879 /* If we got a request_sense, we probably want a reset, return error */
1880 tw_dev->srb[request_id]->result = (DID_ERROR << 16);
1881 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1884 } /* End tw_scsiop_request_sense() */
1886 /* This function will handle synchronize cache scsi command */
1887 static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id)
1889 TW_Command *command_packet;
1890 unsigned long command_que_value;
1892 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n");
1894 /* Send firmware flush command for this unit */
1895 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1896 if (command_packet == NULL) {
1897 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n");
1901 /* Setup the command packet */
1902 memset(command_packet, 0, sizeof(TW_Sector));
1903 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE);
1904 command_packet->size = 2;
1905 command_packet->request_id = request_id;
1906 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1907 command_packet->status = 0;
1908 command_packet->flags = 0;
1909 command_packet->byte6.parameter_count = 1;
1910 command_que_value = tw_dev->command_packet_physical_address[request_id];
1911 if (command_que_value == 0) {
1912 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n");
1916 /* Now try to post the command packet */
1917 tw_post_command_packet(tw_dev, request_id);
1920 } /* End tw_scsiop_synchronize_cache() */
1922 /* This function will handle test unit ready scsi command */
1923 static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id)
1926 TW_Command *command_packet;
1927 unsigned long command_que_value;
1928 unsigned long param_value;
1930 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n");
1932 /* Initialize command packet */
1933 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1934 if (command_packet == NULL) {
1935 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n");
1938 memset(command_packet, 0, sizeof(TW_Sector));
1939 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1940 command_packet->size = 4;
1941 command_packet->request_id = request_id;
1942 command_packet->status = 0;
1943 command_packet->flags = 0;
1944 command_packet->byte6.parameter_count = 1;
1946 /* Now setup the param */
1947 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1948 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n");
1951 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1952 memset(param, 0, sizeof(TW_Sector));
1953 param->table_id = 3; /* unit summary table */
1954 param->parameter_id = 3; /* unitsstatus parameter */
1955 param->parameter_size_bytes = TW_MAX_UNITS;
1956 param_value = tw_dev->alignment_physical_address[request_id];
1957 if (param_value == 0) {
1958 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n");
1962 command_packet->byte8.param.sgl[0].address = param_value;
1963 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1964 command_que_value = tw_dev->command_packet_physical_address[request_id];
1965 if (command_que_value == 0) {
1966 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n");
1970 /* Now try to post the command packet */
1971 tw_post_command_packet(tw_dev, request_id);
1974 } /* End tw_scsiop_test_unit_ready() */
1976 /* This function is called by the isr to complete a testunitready command */
1977 static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id)
1979 unsigned char *is_unit_present;
1982 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n");
1984 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1985 if (param == NULL) {
1986 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n");
1989 is_unit_present = &(param->data[0]);
1991 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1992 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1994 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1995 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1996 return TW_ISR_DONT_RESULT;
2000 } /* End tw_scsiop_test_unit_ready_complete() */
2002 /* This is the main scsi queue function to handle scsi opcodes */
2003 static int tw_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
2005 unsigned char *command = SCpnt->cmnd;
2008 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
2010 /* Save done function into Scsi_Cmnd struct */
2011 SCpnt->scsi_done = done;
2013 /* Queue the command and get a request id */
2014 tw_state_request_start(tw_dev, &request_id);
2016 /* Save the scsi command for use by the ISR */
2017 tw_dev->srb[request_id] = SCpnt;
2019 /* Initialize phase to zero */
2020 SCpnt->SCp.phase = TW_PHASE_INITIAL;
2027 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
2028 retval = tw_scsiop_read_write(tw_dev, request_id);
2030 case TEST_UNIT_READY:
2031 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
2032 retval = tw_scsiop_test_unit_ready(tw_dev, request_id);
2035 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
2036 retval = tw_scsiop_inquiry(tw_dev, request_id);
2039 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
2040 retval = tw_scsiop_read_capacity(tw_dev, request_id);
2043 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
2044 retval = tw_scsiop_request_sense(tw_dev, request_id);
2047 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
2048 retval = tw_scsiop_mode_sense(tw_dev, request_id);
2050 case SYNCHRONIZE_CACHE:
2051 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
2052 retval = tw_scsiop_synchronize_cache(tw_dev, request_id);
2055 printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n");
2058 printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
2059 tw_dev->state[request_id] = TW_S_COMPLETED;
2060 tw_state_request_finish(tw_dev, request_id);
2061 SCpnt->result = (DID_BAD_TARGET << 16);
2066 tw_dev->state[request_id] = TW_S_COMPLETED;
2067 tw_state_request_finish(tw_dev, request_id);
2068 SCpnt->result = (DID_ERROR << 16);
2074 } /* End tw_scsi_queue() */
2076 /* This function is the interrupt service routine */
2077 static irqreturn_t tw_interrupt(int irq, void *dev_instance,
2078 struct pt_regs *regs)
2081 u32 status_reg_value;
2082 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
2083 TW_Response_Queue response_que;
2084 int error = 0, retval = 0;
2085 TW_Command *command_packet;
2088 /* Get the host lock for io completions */
2089 spin_lock(tw_dev->host->host_lock);
2091 /* See if the interrupt matches this instance */
2092 if (tw_dev->tw_pci_dev->irq == (unsigned int)irq) {
2096 /* Read the registers */
2097 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2099 /* Check if this is our interrupt, otherwise bail */
2100 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
2101 goto tw_interrupt_bail;
2103 /* Check controller for errors */
2104 if (tw_check_bits(status_reg_value)) {
2105 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2106 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2107 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2108 goto tw_interrupt_bail;
2112 /* Handle host interrupt */
2113 if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
2114 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
2115 TW_CLEAR_HOST_INTERRUPT(tw_dev);
2118 /* Handle attention interrupt */
2119 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
2120 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
2121 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
2122 tw_state_request_start(tw_dev, &request_id);
2123 error = tw_aen_read_queue(tw_dev, request_id);
2125 printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
2126 tw_dev->state[request_id] = TW_S_COMPLETED;
2127 tw_state_request_finish(tw_dev, request_id);
2131 /* Handle command interrupt */
2132 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
2133 /* Drain as many pending commands as we can */
2134 while (tw_dev->pending_request_count > 0) {
2135 request_id = tw_dev->pending_queue[tw_dev->pending_head];
2136 if (tw_dev->state[request_id] != TW_S_PENDING) {
2137 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
2140 if (tw_post_command_packet(tw_dev, request_id)==0) {
2141 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2142 tw_dev->pending_head = TW_Q_START;
2144 tw_dev->pending_head = tw_dev->pending_head + 1;
2146 tw_dev->pending_request_count--;
2148 /* If we get here, we will continue re-posting on the next command interrupt */
2152 /* If there are no more pending requests, we mask command interrupt */
2153 if (tw_dev->pending_request_count == 0)
2154 TW_MASK_COMMAND_INTERRUPT(tw_dev);
2157 /* Handle response interrupt */
2158 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
2159 /* Drain the response queue from the board */
2160 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
2161 /* Read response queue register */
2162 response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
2163 request_id = TW_RESID_OUT(response_que.response_id);
2164 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2167 /* Check for bad response */
2168 if (command_packet->status != 0) {
2169 /* If internal command, don't error, don't fill sense */
2170 if (tw_dev->srb[request_id] == NULL) {
2171 tw_decode_sense(tw_dev, request_id, 0);
2173 error = tw_decode_sense(tw_dev, request_id, 1);
2177 /* Check for correct state */
2178 if (tw_dev->state[request_id] != TW_S_POSTED) {
2179 if (tw_dev->srb[request_id] != NULL) {
2180 printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no);
2185 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
2187 /* Check for internal command completion */
2188 if (tw_dev->srb[request_id] == NULL) {
2189 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
2190 /* Check for chrdev ioctl completion */
2191 if (request_id != tw_dev->chrdev_request_id) {
2192 retval = tw_aen_complete(tw_dev, request_id);
2194 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
2197 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2198 wake_up(&tw_dev->ioctl_wqueue);
2201 switch (tw_dev->srb[request_id]->cmnd[0]) {
2204 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
2208 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
2210 case TEST_UNIT_READY:
2211 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
2212 error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
2215 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
2216 error = tw_scsiop_inquiry_complete(tw_dev, request_id);
2219 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
2220 error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
2223 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
2224 error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
2226 case SYNCHRONIZE_CACHE:
2227 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
2230 printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
2234 /* If no error command was a success */
2236 tw_dev->srb[request_id]->result = (DID_OK << 16);
2239 /* If error, command failed */
2241 /* Ask for a host reset */
2242 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
2245 /* Now complete the io */
2246 if ((error != TW_ISR_DONT_COMPLETE)) {
2247 tw_dev->state[request_id] = TW_S_COMPLETED;
2248 tw_state_request_finish(tw_dev, request_id);
2249 tw_dev->posted_request_count--;
2250 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2252 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
2256 /* Check for valid status after each drain */
2257 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2258 if (tw_check_bits(status_reg_value)) {
2259 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2260 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2261 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2262 goto tw_interrupt_bail;
2269 spin_unlock(tw_dev->host->host_lock);
2270 return IRQ_RETVAL(handled);
2271 } /* End tw_interrupt() */
2273 /* This function tells the controller to shut down */
2274 static void __tw_shutdown(TW_Device_Extension *tw_dev)
2276 /* Disable interrupts */
2277 TW_DISABLE_INTERRUPTS(tw_dev);
2279 printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no);
2281 /* Tell the card we are shutting down */
2282 if (tw_initconnection(tw_dev, 1)) {
2283 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n");
2285 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n");
2288 /* Clear all interrupts just before exit */
2289 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2290 } /* End __tw_shutdown() */
2292 /* Wrapper for __tw_shutdown */
2293 static void tw_shutdown(struct device *dev)
2295 struct Scsi_Host *host = pci_get_drvdata(to_pci_dev(dev));
2296 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2298 __tw_shutdown(tw_dev);
2299 } /* End tw_shutdown() */
2301 static struct scsi_host_template driver_template = {
2302 .module = THIS_MODULE,
2303 .name = "3ware Storage Controller",
2304 .queuecommand = tw_scsi_queue,
2305 .eh_host_reset_handler = tw_scsi_eh_reset,
2306 .bios_param = tw_scsi_biosparam,
2307 .can_queue = TW_Q_LENGTH-2,
2309 .sg_tablesize = TW_MAX_SGL_LENGTH,
2310 .max_sectors = TW_MAX_SECTORS,
2311 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
2312 .use_clustering = ENABLE_CLUSTERING,
2313 .shost_attrs = tw_host_attrs,
2314 .sdev_attrs = tw_dev_attrs,
2318 /* This function will probe and initialize a card */
2319 static int __devinit tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2321 struct Scsi_Host *host = NULL;
2322 TW_Device_Extension *tw_dev;
2323 int retval = -ENODEV;
2325 retval = pci_enable_device(pdev);
2327 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device.");
2328 goto out_disable_device;
2331 pci_set_master(pdev);
2333 retval = pci_set_dma_mask(pdev, TW_DMA_MASK);
2335 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask.");
2336 goto out_disable_device;
2339 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2341 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension.");
2343 goto out_disable_device;
2345 tw_dev = (TW_Device_Extension *)host->hostdata;
2347 memset(tw_dev, 0, sizeof(TW_Device_Extension));
2349 /* Save values to device extension */
2350 tw_dev->host = host;
2351 tw_dev->tw_pci_dev = pdev;
2353 if (tw_initialize_device_extension(tw_dev)) {
2354 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension.");
2355 goto out_free_device_extension;
2358 /* Request IO regions */
2359 retval = pci_request_regions(pdev, "3w-xxxx");
2361 printk(KERN_WARNING "3w-xxxx: Failed to get mem region.");
2362 goto out_free_device_extension;
2365 /* Save base address */
2366 tw_dev->base_addr = pci_resource_start(pdev, 0);
2367 if (!tw_dev->base_addr) {
2368 printk(KERN_WARNING "3w-xxxx: Failed to get io address.");
2369 goto out_release_mem_region;
2372 /* Disable interrupts on the card */
2373 TW_DISABLE_INTERRUPTS(tw_dev);
2375 /* Initialize the card */
2376 if (tw_reset_sequence(tw_dev))
2377 goto out_release_mem_region;
2379 /* Set host specific parameters */
2380 host->max_id = TW_MAX_UNITS;
2381 host->max_cmd_len = TW_MAX_CDB_LEN;
2383 /* Luns and channels aren't supported by adapter */
2385 host->max_channel = 0;
2387 /* Register the card with the kernel SCSI layer */
2388 retval = scsi_add_host(host, &pdev->dev);
2390 printk(KERN_WARNING "3w-xxxx: scsi add host failed");
2391 goto out_release_mem_region;
2394 pci_set_drvdata(pdev, host);
2396 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);
2398 /* Now setup the interrupt handler */
2399 retval = request_irq(pdev->irq, tw_interrupt, SA_SHIRQ, "3w-xxxx", tw_dev);
2401 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ.");
2402 goto out_remove_host;
2405 tw_device_extension_list[tw_device_extension_count] = tw_dev;
2406 tw_device_extension_count++;
2408 /* Re-enable interrupts on the card */
2409 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2411 /* Finally, scan the host */
2412 scsi_scan_host(host);
2414 if (twe_major == -1) {
2415 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0)
2416 printk(KERN_WARNING "3w-xxxx: Failed to register character device.");
2421 scsi_remove_host(host);
2422 out_release_mem_region:
2423 pci_release_regions(pdev);
2424 out_free_device_extension:
2425 tw_free_device_extension(tw_dev);
2426 scsi_host_put(host);
2428 pci_disable_device(pdev);
2431 } /* End tw_probe() */
2433 /* This function is called to remove a device */
2434 static void tw_remove(struct pci_dev *pdev)
2436 struct Scsi_Host *host = pci_get_drvdata(pdev);
2437 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2439 scsi_remove_host(tw_dev->host);
2441 __tw_shutdown(tw_dev);
2443 /* Free up the IRQ */
2444 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2446 /* Free up the mem region */
2447 pci_release_regions(pdev);
2449 /* Free up device extension resources */
2450 tw_free_device_extension(tw_dev);
2452 /* Unregister character device */
2453 if (twe_major >= 0) {
2454 unregister_chrdev(twe_major, "twe");
2458 scsi_host_put(tw_dev->host);
2459 pci_disable_device(pdev);
2460 tw_device_extension_count--;
2461 } /* End tw_remove() */
2463 /* PCI Devices supported by this driver */
2464 static struct pci_device_id tw_pci_tbl[] __devinitdata = {
2465 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000,
2466 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2467 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000,
2468 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2471 MODULE_DEVICE_TABLE(pci, tw_pci_tbl);
2473 /* pci_driver initializer */
2474 static struct pci_driver tw_driver = {
2476 .id_table = tw_pci_tbl,
2478 .remove = tw_remove,
2480 .shutdown = tw_shutdown
2484 /* This function is called on driver initialization */
2485 static int __init tw_init(void)
2487 printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2489 return pci_module_init(&tw_driver);
2490 } /* End tw_init() */
2492 /* This function is called on driver exit */
2493 static void __exit tw_exit(void)
2495 pci_unregister_driver(&tw_driver);
2496 } /* End tw_exit() */
2498 module_init(tw_init);
2499 module_exit(tw_exit);