2 3w-xxxx.c -- 3ware Storage Controller device driver for Linux.
4 Written By: Adam Radford <linux@3ware.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-2003 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.
184 #include <linux/module.h>
186 MODULE_AUTHOR ("3ware Inc.");
188 MODULE_DESCRIPTION ("3ware Storage Controller Linux Driver (SMP)");
190 MODULE_DESCRIPTION ("3ware Storage Controller Linux Driver");
192 MODULE_LICENSE("GPL");
194 #include <linux/kernel.h>
195 #include <linux/pci.h>
196 #include <linux/time.h>
197 #include <linux/proc_fs.h>
198 #include <linux/sched.h>
199 #include <linux/ioport.h>
200 #include <linux/blkdev.h>
201 #include <linux/hdreg.h>
202 #include <linux/string.h>
203 #include <linux/delay.h>
204 #include <linux/smp.h>
205 #include <linux/reboot.h>
206 #include <linux/spinlock.h>
207 #include <linux/interrupt.h>
209 #include <asm/errno.h>
212 #include <asm/uaccess.h>
214 #define __3W_C /* let 3w-xxxx.h know it is use */
221 static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
222 static int tw_chrdev_open(struct inode *inode, struct file *file);
223 static int tw_chrdev_release(struct inode *inode, struct file *file);
224 static int tw_copy_info(TW_Info *info, char *fmt, ...);
225 static void tw_copy_mem_info(TW_Info *info, char *data, int len);
226 static int tw_halt(struct notifier_block *nb, ulong event, void *buf);
227 static int tw_map_scsi_sg_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);
228 static u32 tw_map_scsi_single_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);
229 static void tw_unmap_scsi_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);
231 /* Notifier block to get a notify on system shutdown/halt/reboot */
232 static struct notifier_block tw_notifier = {
236 /* File operations struct for character device */
237 static struct file_operations tw_fops = {
238 .owner = THIS_MODULE,
239 .ioctl = tw_chrdev_ioctl,
240 .open = tw_chrdev_open,
241 .release = tw_chrdev_release
245 char *tw_driver_version="1.02.00.037";
246 TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT];
247 int tw_device_extension_count = 0;
248 static int twe_major = -1;
252 /* This function will complete an aen request from the isr */
253 int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id)
257 int error = 0, table_max = 0;
259 dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n");
260 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
261 printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n");
264 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
265 aen = *(unsigned short *)(param->data);
266 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen);
268 /* Print some useful info when certain aen codes come out */
270 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no);
272 table_max = sizeof(tw_aen_string)/sizeof(char *);
273 if ((aen & 0x0ff) < table_max) {
274 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
275 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8);
278 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]);
281 printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen);
284 if (aen != TW_AEN_QUEUE_EMPTY) {
287 /* Now queue the code */
288 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
289 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
290 tw_dev->aen_tail = TW_Q_START;
292 tw_dev->aen_tail = tw_dev->aen_tail + 1;
294 if (tw_dev->aen_head == tw_dev->aen_tail) {
295 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
296 tw_dev->aen_head = TW_Q_START;
298 tw_dev->aen_head = tw_dev->aen_head + 1;
302 error = tw_aen_read_queue(tw_dev, request_id);
304 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no);
305 tw_dev->state[request_id] = TW_S_COMPLETED;
306 tw_state_request_finish(tw_dev, request_id);
309 tw_dev->state[request_id] = TW_S_COMPLETED;
310 tw_state_request_finish(tw_dev, request_id);
314 } /* End tw_aen_complete() */
316 /* This function will drain the aen queue after a soft reset */
317 int tw_aen_drain_queue(TW_Device_Extension *tw_dev)
319 TW_Command *command_packet;
322 u32 command_que_addr;
323 unsigned long command_que_value;
324 unsigned long param_value;
325 TW_Response_Queue response_queue;
326 u32 response_que_addr;
328 unsigned short aen_code;
332 int found = 0, table_max = 0;
334 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n");
336 command_que_addr = tw_dev->registers.command_que_addr;
337 response_que_addr = tw_dev->registers.response_que_addr;
339 if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) {
340 dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count);
343 tw_clear_attention_interrupt(tw_dev);
345 /* Empty response queue */
346 tw_empty_response_que(tw_dev);
348 /* Initialize command packet */
349 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
350 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n");
353 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
354 memset(command_packet, 0, sizeof(TW_Sector));
355 command_packet->byte0.opcode = TW_OP_GET_PARAM;
356 command_packet->byte0.sgl_offset = 2;
357 command_packet->size = 4;
358 command_packet->request_id = request_id;
359 command_packet->byte3.unit = 0;
360 command_packet->byte3.host_id = 0;
361 command_packet->status = 0;
362 command_packet->flags = 0;
363 command_packet->byte6.parameter_count = 1;
364 command_que_value = tw_dev->command_packet_physical_address[request_id];
365 if (command_que_value == 0) {
366 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n");
370 /* Now setup the param */
371 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
372 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n");
375 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
376 memset(param, 0, sizeof(TW_Sector));
377 param->table_id = 0x401; /* AEN table */
378 param->parameter_id = 2; /* Unit code */
379 param->parameter_size_bytes = 2;
380 param_value = tw_dev->alignment_physical_address[request_id];
381 if (param_value == 0) {
382 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n");
385 command_packet->byte8.param.sgl[0].address = param_value;
386 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
388 /* Now drain the controller's aen queue */
390 /* Post command packet */
391 outl(command_que_value, command_que_addr);
393 /* Now poll for completion */
394 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
395 response_queue.value = inl(response_que_addr);
396 request_id = (unsigned char)response_queue.u.response_id;
398 if (request_id != 0) {
399 /* Unexpected request id */
400 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n");
404 if (command_packet->status != 0) {
405 if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) {
407 tw_decode_sense(tw_dev, request_id, 0);
410 /* We know this is a 3w-1x00, and doesn't support aen's */
415 /* Now check the aen */
416 aen = *(unsigned short *)(param->data);
417 aen_code = (aen & 0x0ff);
420 case TW_AEN_QUEUE_EMPTY:
421 dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
422 if (first_reset != 1) {
428 case TW_AEN_SOFT_RESET:
429 if (first_reset == 0) {
432 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
439 printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n");
441 table_max = sizeof(tw_aen_string)/sizeof(char *);
442 if ((aen & 0x0ff) < table_max) {
443 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
444 printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8);
446 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
449 printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen);
455 /* Now put the aen on the aen_queue */
457 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
458 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
459 tw_dev->aen_tail = TW_Q_START;
461 tw_dev->aen_tail = tw_dev->aen_tail + 1;
463 if (tw_dev->aen_head == tw_dev->aen_tail) {
464 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
465 tw_dev->aen_head = TW_Q_START;
467 tw_dev->aen_head = tw_dev->aen_head + 1;
474 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n");
477 } while (finished == 0);
480 } /* End tw_aen_drain_queue() */
482 /* This function will read the aen queue from the isr */
483 int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
485 TW_Command *command_packet;
487 u32 command_que_addr;
488 unsigned long command_que_value;
489 u32 status_reg_value = 0, status_reg_addr;
490 unsigned long param_value = 0;
492 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n");
493 command_que_addr = tw_dev->registers.command_que_addr;
494 status_reg_addr = tw_dev->registers.status_reg_addr;
496 status_reg_value = inl(status_reg_addr);
497 if (tw_check_bits(status_reg_value)) {
498 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n");
499 tw_decode_bits(tw_dev, status_reg_value, 1);
502 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
503 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n");
506 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
507 memset(command_packet, 0, sizeof(TW_Sector));
508 command_packet->byte0.opcode = TW_OP_GET_PARAM;
509 command_packet->byte0.sgl_offset = 2;
510 command_packet->size = 4;
511 command_packet->request_id = request_id;
512 command_packet->byte3.unit = 0;
513 command_packet->byte3.host_id = 0;
514 command_packet->status = 0;
515 command_packet->flags = 0;
516 command_packet->byte6.parameter_count = 1;
517 command_que_value = tw_dev->command_packet_physical_address[request_id];
518 if (command_que_value == 0) {
519 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n");
522 /* Now setup the param */
523 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
524 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n");
527 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
528 memset(param, 0, sizeof(TW_Sector));
529 param->table_id = 0x401; /* AEN table */
530 param->parameter_id = 2; /* Unit code */
531 param->parameter_size_bytes = 2;
532 param_value = tw_dev->alignment_physical_address[request_id];
533 if (param_value == 0) {
534 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n");
537 command_packet->byte8.param.sgl[0].address = param_value;
538 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
540 /* Now post the command packet */
541 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
542 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n");
543 tw_dev->srb[request_id] = 0; /* Flag internal command */
544 tw_dev->state[request_id] = TW_S_POSTED;
545 outl(command_que_value, command_que_addr);
547 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n");
552 } /* End tw_aen_read_queue() */
554 /* This function will allocate memory */
555 int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
558 dma_addr_t dma_handle;
559 unsigned long *cpu_addr = NULL;
561 dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");
563 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
564 if (cpu_addr == NULL) {
565 printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n");
569 if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {
570 printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");
571 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
575 memset(cpu_addr, 0, size*TW_Q_LENGTH);
577 for (i=0;i<TW_Q_LENGTH;i++) {
580 tw_dev->command_packet_physical_address[i] = dma_handle+(i*size);
581 tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
584 tw_dev->alignment_physical_address[i] = dma_handle+(i*size);
585 tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
588 printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n");
594 } /* End tw_allocate_memory() */
596 /* This function will check the status register for unexpected bits */
597 int tw_check_bits(u32 status_reg_value)
599 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) {
600 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value);
603 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) {
604 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value);
609 } /* End tw_check_bits() */
611 /* This function will report controller error status */
612 int tw_check_errors(TW_Device_Extension *tw_dev)
614 u32 status_reg_addr, status_reg_value;
616 status_reg_addr = tw_dev->registers.status_reg_addr;
617 status_reg_value = inl(status_reg_addr);
619 if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) {
620 tw_decode_bits(tw_dev, status_reg_value, 0);
625 } /* End tw_check_errors() */
627 /* This function handles ioctl for the character device */
628 static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
630 int error, request_id;
631 dma_addr_t dma_handle;
632 unsigned short tw_aen_code;
634 unsigned int data_buffer_length = 0;
635 unsigned long data_buffer_length_adjusted = 0;
636 unsigned long *cpu_addr;
638 TW_New_Ioctl *tw_ioctl;
639 TW_Passthru *passthru;
640 TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)];
641 int retval = -EFAULT;
643 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
645 /* Only let one of these through at a time */
646 if (down_interruptible(&tw_dev->ioctl_sem))
649 /* First copy down the buffer length */
650 error = copy_from_user(&data_buffer_length, (void *)arg, sizeof(unsigned int));
655 if (data_buffer_length > TW_MAX_SECTORS * 512) {
660 /* Hardware can only do multiple of 512 byte transfers */
661 data_buffer_length_adjusted = (data_buffer_length + 511) & ~511;
663 /* Now allocate ioctl buf memory */
664 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle);
665 if (cpu_addr == NULL) {
670 tw_ioctl = (TW_New_Ioctl *)cpu_addr;
672 /* Now copy down the entire ioctl */
673 error = copy_from_user(tw_ioctl, (void *)arg, data_buffer_length + sizeof(TW_New_Ioctl) - 1);
677 passthru = (TW_Passthru *)&tw_ioctl->firmware_command;
679 /* See which ioctl we are doing */
682 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n");
684 case TW_OP_AEN_LISTEN:
685 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n");
686 memset(tw_ioctl->data_buffer, 0, tw_ioctl->data_buffer_length);
688 spin_lock_irqsave(tw_dev->host->host_lock, flags);
689 if (tw_dev->aen_head == tw_dev->aen_tail) {
690 tw_aen_code = TW_AEN_QUEUE_EMPTY;
692 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
693 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
694 tw_dev->aen_head = TW_Q_START;
696 tw_dev->aen_head = tw_dev->aen_head + 1;
699 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
700 memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code));
702 case TW_CMD_PACKET_WITH_DATA:
703 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
704 spin_lock_irqsave(&tw_dev->tw_lock, flags);
706 tw_state_request_start(tw_dev, &request_id);
708 /* Flag internal command */
709 tw_dev->srb[request_id] = 0;
711 /* Flag chrdev ioctl */
712 tw_dev->chrdev_request_id = request_id;
714 tw_ioctl->firmware_command.request_id = request_id;
716 /* Load the sg list */
717 switch (tw_ioctl->firmware_command.byte0.sgl_offset) {
719 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
720 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted;
723 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
724 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted;
727 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
728 passthru->sg_list[0].length = data_buffer_length_adjusted;
732 memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command));
734 /* Now post the command packet to the controller */
735 tw_post_command_packet(tw_dev, request_id);
736 spin_unlock_irqrestore(&tw_dev->tw_lock, flags);
738 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
740 /* Now wait for the command to complete */
741 wait_event_interruptible_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
743 /* Check if we timed out, got a signal, or didn't get
745 if ((timeout <= 0) && (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE)) {
746 /* Now we need to reset the board */
747 if (timeout == -ERESTARTSYS) {
750 printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd);
753 spin_lock_irqsave(&tw_dev->tw_lock, flags);
754 tw_dev->state[request_id] = TW_S_COMPLETED;
755 tw_state_request_finish(tw_dev, request_id);
756 tw_dev->posted_request_count--;
757 if (tw_reset_device_extension(tw_dev)) {
758 printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no);
760 spin_unlock_irqrestore(&tw_dev->tw_lock, flags);
764 /* Now copy in the command packet response */
765 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
767 /* Now complete the io */
768 spin_lock_irqsave(&tw_dev->tw_lock, flags);
769 tw_dev->posted_request_count--;
770 tw_dev->state[request_id] = TW_S_COMPLETED;
771 tw_state_request_finish(tw_dev, request_id);
772 spin_unlock_irqrestore(&tw_dev->tw_lock, flags);
779 /* Now copy the response to userspace */
780 error = copy_to_user((void *)arg, tw_ioctl, sizeof(TW_New_Ioctl) + tw_ioctl->data_buffer_length - 1);
784 /* Now free ioctl buf memory */
785 pci_free_consistent(tw_dev->tw_pci_dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle);
787 up(&tw_dev->ioctl_sem);
789 } /* End tw_chrdev_ioctl() */
791 /* This function handles open for the character device */
792 static int tw_chrdev_open(struct inode *inode, struct file *file)
794 unsigned int minor_number;
796 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n");
798 minor_number = iminor(inode);
799 if (minor_number >= tw_device_extension_count)
803 } /* End tw_chrdev_open() */
805 /* This function handles close for the character device */
806 static int tw_chrdev_release(struct inode *inode, struct file *file)
808 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_release()\n");
811 } /* End tw_chrdev_release() */
813 /* This function will clear all interrupts on the controller */
814 void tw_clear_all_interrupts(TW_Device_Extension *tw_dev)
816 u32 control_reg_addr, control_reg_value;
818 control_reg_addr = tw_dev->registers.control_reg_addr;
819 control_reg_value = TW_STATUS_VALID_INTERRUPT;
820 outl(control_reg_value, control_reg_addr);
821 } /* End tw_clear_all_interrupts() */
823 /* This function will clear the attention interrupt */
824 void tw_clear_attention_interrupt(TW_Device_Extension *tw_dev)
826 u32 control_reg_addr, control_reg_value;
828 control_reg_addr = tw_dev->registers.control_reg_addr;
829 control_reg_value = TW_CONTROL_CLEAR_ATTENTION_INTERRUPT;
830 outl(control_reg_value, control_reg_addr);
831 } /* End tw_clear_attention_interrupt() */
833 /* This function will clear the host interrupt */
834 void tw_clear_host_interrupt(TW_Device_Extension *tw_dev)
836 u32 control_reg_addr, control_reg_value;
838 control_reg_addr = tw_dev->registers.control_reg_addr;
839 control_reg_value = TW_CONTROL_CLEAR_HOST_INTERRUPT;
840 outl(control_reg_value, control_reg_addr);
841 } /* End tw_clear_host_interrupt() */
843 /* This function is called by tw_scsi_proc_info */
844 static int tw_copy_info(TW_Info *info, char *fmt, ...)
851 len = vsprintf(buf, fmt, args);
853 tw_copy_mem_info(info, buf, len);
855 } /* End tw_copy_info() */
857 /* This function is called by tw_scsi_proc_info */
858 static void tw_copy_mem_info(TW_Info *info, char *data, int len)
860 if (info->position + len > info->length)
861 len = info->length - info->position;
863 if (info->position + len < info->offset) {
864 info->position += len;
867 if (info->position < info->offset) {
868 data += (info->offset - info->position);
869 len -= (info->offset - info->position);
872 memcpy(info->buffer + info->position, data, len);
873 info->position += len;
875 } /* End tw_copy_mem_info() */
877 /* This function will print readable messages from status register errors */
878 int tw_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value, int print_host)
882 dprintk(KERN_WARNING "3w-xxxx: tw_decode_bits()\n");
885 sprintf(host, " scsi%d:", tw_dev->host->host_no);
889 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
890 printk(KERN_WARNING "3w-xxxx:%s PCI Parity Error: clearing.\n", host);
891 outl(TW_CONTROL_CLEAR_PARITY_ERROR, tw_dev->registers.control_reg_addr);
894 if (status_reg_value & TW_STATUS_PCI_ABORT) {
895 printk(KERN_WARNING "3w-xxxx:%s PCI Abort: clearing.\n", host);
896 outl(TW_CONTROL_CLEAR_PCI_ABORT, tw_dev->registers.control_reg_addr);
897 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
900 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
901 printk(KERN_WARNING "3w-xxxx:%s Controller Queue Error: clearing.\n", host);
902 outl(TW_CONTROL_CLEAR_QUEUE_ERROR, tw_dev->registers.control_reg_addr);
905 if (status_reg_value & TW_STATUS_SBUF_WRITE_ERROR) {
906 printk(KERN_WARNING "3w-xxxx:%s SBUF Write Error: clearing.\n", host);
907 outl(TW_CONTROL_CLEAR_SBUF_WRITE_ERROR, tw_dev->registers.control_reg_addr);
910 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
911 if (tw_dev->reset_print == 0) {
912 printk(KERN_WARNING "3w-xxxx:%s Microcontroller Error: clearing.\n", host);
913 tw_dev->reset_print = 1;
919 } /* End tw_decode_bits() */
921 /* This function will return valid sense buffer information for failed cmds */
922 int tw_decode_sense(TW_Device_Extension *tw_dev, int request_id, int fill_sense)
927 dprintk(KERN_WARNING "3w-xxxx: tw_decode_sense()\n");
928 command = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
930 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, command->byte3.unit);
932 /* Attempt to return intelligent sense information */
934 if ((command->status == 0xc7) || (command->status == 0xcb)) {
935 for (i=0;i<(sizeof(tw_sense_table)/sizeof(tw_sense_table[0]));i++) {
936 if (command->flags == tw_sense_table[i][0]) {
938 /* Valid bit and 'current errors' */
939 tw_dev->srb[request_id]->sense_buffer[0] = (0x1 << 7 | 0x70);
942 tw_dev->srb[request_id]->sense_buffer[2] = tw_sense_table[i][1];
944 /* Additional sense length */
945 tw_dev->srb[request_id]->sense_buffer[7] = 0xa; /* 10 bytes */
947 /* Additional sense code */
948 tw_dev->srb[request_id]->sense_buffer[12] = tw_sense_table[i][2];
950 /* Additional sense code qualifier */
951 tw_dev->srb[request_id]->sense_buffer[13] = tw_sense_table[i][3];
953 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
954 return TW_ISR_DONT_RESULT; /* Special case for isr to not over-write result */
959 /* If no table match, error so we get a reset */
964 } /* End tw_decode_sense() */
966 /* This function will disable interrupts on the controller */
967 void tw_disable_interrupts(TW_Device_Extension *tw_dev)
969 u32 control_reg_value, control_reg_addr;
971 control_reg_addr = tw_dev->registers.control_reg_addr;
972 control_reg_value = TW_CONTROL_DISABLE_INTERRUPTS;
973 outl(control_reg_value, control_reg_addr);
974 } /* End tw_disable_interrupts() */
976 /* This function will empty the response que */
977 void tw_empty_response_que(TW_Device_Extension *tw_dev)
979 u32 status_reg_addr, status_reg_value;
980 u32 response_que_addr, response_que_value;
982 status_reg_addr = tw_dev->registers.status_reg_addr;
983 response_que_addr = tw_dev->registers.response_que_addr;
985 status_reg_value = inl(status_reg_addr);
987 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
988 response_que_value = inl(response_que_addr);
989 status_reg_value = inl(status_reg_addr);
991 } /* End tw_empty_response_que() */
993 /* This function will enable interrupts on the controller */
994 void tw_enable_interrupts(TW_Device_Extension *tw_dev)
996 u32 control_reg_value, control_reg_addr;
998 control_reg_addr = tw_dev->registers.control_reg_addr;
999 control_reg_value = (TW_CONTROL_ENABLE_INTERRUPTS |
1000 TW_CONTROL_UNMASK_RESPONSE_INTERRUPT);
1001 outl(control_reg_value, control_reg_addr);
1002 } /* End tw_enable_interrupts() */
1004 /* This function will enable interrupts on the controller */
1005 void tw_enable_and_clear_interrupts(TW_Device_Extension *tw_dev)
1007 u32 control_reg_value, control_reg_addr;
1009 control_reg_addr = tw_dev->registers.control_reg_addr;
1010 control_reg_value = (TW_CONTROL_CLEAR_ATTENTION_INTERRUPT |
1011 TW_CONTROL_UNMASK_RESPONSE_INTERRUPT |
1012 TW_CONTROL_ENABLE_INTERRUPTS);
1013 outl(control_reg_value, control_reg_addr);
1014 } /* End tw_enable_and_clear_interrupts() */
1016 /* This function will find and initialize all cards */
1017 int tw_findcards(Scsi_Host_Template *tw_host)
1019 int numcards = 0, tries = 0, error = 0;
1020 struct Scsi_Host *host;
1021 TW_Device_Extension *tw_dev;
1022 TW_Device_Extension *tw_dev2;
1023 struct pci_dev *tw_pci_dev = NULL;
1024 u32 status_reg_value;
1025 unsigned char c = 1;
1027 u16 device[TW_NUMDEVICES] = { TW_DEVICE_ID, TW_DEVICE_ID2 };
1029 dprintk(KERN_NOTICE "3w-xxxx: tw_findcards()\n");
1031 for (i=0;i<TW_NUMDEVICES;i++) {
1032 while ((tw_pci_dev = pci_find_device(TW_VENDOR_ID, device[i], tw_pci_dev))) {
1034 if (pci_enable_device(tw_pci_dev))
1037 /* We only need 32-bit addressing for 5,6,7xxx cards */
1038 if (pci_set_dma_mask(tw_pci_dev, 0xffffffff)) {
1039 printk(KERN_WARNING "3w-xxxx: No suitable DMA available.\n");
1043 /* Prepare temporary device extension */
1044 tw_dev=(TW_Device_Extension *)kmalloc(sizeof(TW_Device_Extension), GFP_ATOMIC);
1045 if (tw_dev == NULL) {
1046 printk(KERN_WARNING "3w-xxxx: tw_findcards(): kmalloc() failed for card %d.\n", j);
1049 memset(tw_dev, 0, sizeof(TW_Device_Extension));
1051 /* Save pci_dev struct to device extension */
1052 tw_dev->tw_pci_dev = tw_pci_dev;
1054 error = tw_initialize_device_extension(tw_dev);
1056 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Couldn't initialize device extension for card %d.\n", j);
1057 tw_free_device_extension(tw_dev);
1062 /* Calculate the cards register addresses */
1063 tw_dev->registers.base_addr = pci_resource_start(tw_pci_dev, 0);
1064 tw_dev->registers.control_reg_addr = pci_resource_start(tw_pci_dev, 0);
1065 tw_dev->registers.status_reg_addr = pci_resource_start(tw_pci_dev, 0) + 0x4;
1066 tw_dev->registers.command_que_addr = pci_resource_start(tw_pci_dev, 0) + 0x8;
1067 tw_dev->registers.response_que_addr = pci_resource_start(tw_pci_dev, 0) + 0xC;
1069 /* Check for errors and clear them */
1070 status_reg_value = inl(tw_dev->registers.status_reg_addr);
1071 if (TW_STATUS_ERRORS(status_reg_value))
1072 tw_decode_bits(tw_dev, status_reg_value, 0);
1074 /* Poll status register for 60 secs for 'Controller Ready' flag */
1075 if (tw_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY, 60)) {
1076 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Microcontroller not ready for card %d.\n", j);
1077 tw_free_device_extension(tw_dev);
1082 /* Disable interrupts on the card */
1083 tw_disable_interrupts(tw_dev);
1087 while (tries < TW_MAX_RESET_TRIES) {
1089 tw_soft_reset(tw_dev);
1091 error = tw_aen_drain_queue(tw_dev);
1093 printk(KERN_WARNING "3w-xxxx: AEN drain failed for card %d.\n", j);
1098 /* Check for controller errors */
1099 if (tw_check_errors(tw_dev)) {
1100 printk(KERN_WARNING "3w-xxxx: Controller errors found, retrying for card %d.\n", j);
1105 /* Now the controller is in a good state */
1109 if (tries >= TW_MAX_RESET_TRIES) {
1110 printk(KERN_WARNING "3w-xxxx: Controller errors, card not responding, check all cabling for card %d.\n", j);
1111 tw_free_device_extension(tw_dev);
1116 /* Reserve the io address space */
1117 if (!request_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE, TW_DEVICE_NAME)) {
1118 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Couldn't get io range 0x%lx-0x%lx for card %d.\n",
1119 (tw_dev->tw_pci_dev->resource[0].start),
1120 (tw_dev->tw_pci_dev->resource[0].start) +
1121 TW_IO_ADDRESS_RANGE, j);
1122 tw_free_device_extension(tw_dev);
1127 error = tw_initialize_units(tw_dev);
1129 printk(KERN_WARNING "3w-xxxx: No valid units for for card %d.\n", j);
1132 error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
1134 printk(KERN_WARNING "3w-xxxx: Connection initialization failed for card %d.\n", j);
1135 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1136 tw_free_device_extension(tw_dev);
1141 /* Set card status as online */
1144 #ifdef CONFIG_3W_XXXX_CMD_PER_LUN
1145 tw_host->cmd_per_lun = CONFIG_3W_XXXX_CMD_PER_LUN;
1146 if (tw_host->cmd_per_lun > TW_MAX_CMDS_PER_LUN)
1147 tw_host->cmd_per_lun = TW_MAX_CMDS_PER_LUN;
1149 /* Use SHT cmd_per_lun here */
1150 tw_host->cmd_per_lun = TW_MAX_CMDS_PER_LUN;
1152 tw_dev->free_head = TW_Q_START;
1153 tw_dev->free_tail = TW_Q_START;
1154 tw_dev->free_wrap = TW_Q_LENGTH - 1;
1156 /* Register the card with the kernel SCSI layer */
1157 host = scsi_register(tw_host, sizeof(TW_Device_Extension));
1159 printk(KERN_WARNING "3w-xxxx: tw_findcards(): scsi_register() failed for card %d.\n", j);
1160 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1161 tw_free_device_extension(tw_dev);
1166 /* Set max target id's */
1167 host->max_id = TW_MAX_UNITS;
1169 /* Set max cdb size in bytes */
1170 host->max_cmd_len = 16;
1172 /* Set max sectors per io */
1173 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
1174 host->max_sectors = TW_MAX_SECTORS;
1177 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
1178 scsi_set_device(host, &tw_pci_dev->dev);
1179 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,4)
1180 scsi_set_pci_device(host, tw_pci_dev);
1183 status_reg_value = inl(tw_dev->registers.status_reg_addr);
1185 printk(KERN_NOTICE "scsi%d : Found a 3ware Storage Controller at 0x%x, IRQ: %d, P-chip: %d.%d\n", host->host_no,
1186 (u32)(tw_pci_dev->resource[0].start), tw_pci_dev->irq,
1187 (status_reg_value & TW_STATUS_MAJOR_VERSION_MASK) >> 28,
1188 (status_reg_value & TW_STATUS_MINOR_VERSION_MASK) >> 24);
1190 if (host->hostdata) {
1191 tw_dev2 = (TW_Device_Extension *)host->hostdata;
1192 memcpy(tw_dev2, tw_dev, sizeof(TW_Device_Extension));
1193 /* Need to init the sem/wqueue after the copy */
1194 init_MUTEX(&tw_dev2->ioctl_sem);
1195 init_waitqueue_head(&tw_dev2->ioctl_wqueue);
1197 tw_device_extension_list[tw_device_extension_count] = tw_dev2;
1199 tw_device_extension_count = numcards;
1200 tw_dev2->host = host;
1202 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Bad scsi host data for card %d.\n", j);
1203 scsi_unregister(host);
1204 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1205 tw_free_device_extension(tw_dev);
1210 /* Tell the firmware we support shutdown notification*/
1211 error = tw_setfeature(tw_dev2, 2, 1, &c);
1213 printk(KERN_WARNING "3w-xxxx: Unable to set features for card %d, old firmware or card.\n", j);
1216 /* Now setup the interrupt handler */
1217 error = tw_setup_irq(tw_dev2);
1219 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Error requesting irq for card %d.\n", j);
1220 scsi_unregister(host);
1221 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1223 tw_free_device_extension(tw_dev);
1229 /* Re-enable interrupts on the card */
1230 tw_enable_interrupts(tw_dev2);
1232 /* Free the temporary device extension */
1238 if (numcards == 0) {
1239 printk(KERN_WARNING "3w-xxxx: No cards found.\n");
1241 register_reboot_notifier(&tw_notifier);
1242 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0) {
1243 printk(KERN_WARNING "3w-xxxx: Unable to register \"twe\" character device, error = %d.\n", twe_major);
1248 } /* End tw_findcards() */
1250 /* This function will free up device extension resources */
1251 void tw_free_device_extension(TW_Device_Extension *tw_dev)
1253 dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n");
1255 /* Free command packet and generic buffer memory */
1256 if (tw_dev->command_packet_virtual_address[0])
1257 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]);
1259 if (tw_dev->alignment_virtual_address[0])
1260 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]);
1261 } /* End tw_free_device_extension() */
1263 /* Clean shutdown routine */
1264 static int tw_halt(struct notifier_block *nb, ulong event, void *buf)
1268 for (i=0;i<tw_device_extension_count;i++) {
1269 if (tw_device_extension_list[i]->online == 1) {
1270 printk(KERN_NOTICE "3w-xxxx: Shutting down card %d.\n", i);
1271 tw_shutdown_device(tw_device_extension_list[i]);
1272 tw_device_extension_list[i]->online = 0;
1275 unregister_reboot_notifier(&tw_notifier);
1278 } /* End tw_halt() */
1280 /* This function will send an initconnection command to controller */
1281 int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits)
1283 unsigned long command_que_value;
1284 u32 command_que_addr;
1285 u32 response_que_addr;
1286 TW_Command *command_packet;
1287 TW_Response_Queue response_queue;
1290 dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n");
1291 command_que_addr = tw_dev->registers.command_que_addr;
1292 response_que_addr = tw_dev->registers.response_que_addr;
1294 /* Initialize InitConnection command packet */
1295 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1296 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n");
1300 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1301 memset(command_packet, 0, sizeof(TW_Sector));
1302 command_packet->byte0.opcode = TW_OP_INIT_CONNECTION;
1303 command_packet->byte0.sgl_offset = 0x0;
1304 command_packet->size = TW_INIT_COMMAND_PACKET_SIZE;
1305 command_packet->request_id = request_id;
1306 command_packet->byte3.unit = 0x0;
1307 command_packet->byte3.host_id = 0x0;
1308 command_packet->status = 0x0;
1309 command_packet->flags = 0x0;
1310 command_packet->byte6.message_credits = message_credits;
1311 command_packet->byte8.init_connection.response_queue_pointer = 0x0;
1312 command_que_value = tw_dev->command_packet_physical_address[request_id];
1314 if (command_que_value == 0) {
1315 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n");
1319 /* Send command packet to the board */
1320 outl(command_que_value, command_que_addr);
1322 /* Poll for completion */
1323 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1324 response_queue.value = inl(response_que_addr);
1325 request_id = (unsigned char)response_queue.u.response_id;
1326 if (request_id != 0) {
1327 /* unexpected request id */
1328 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n");
1331 if (command_packet->status != 0) {
1333 tw_decode_sense(tw_dev, request_id, 0);
1338 } /* End tw_initconnection() */
1340 /* This function will initialize the fields of a device extension */
1341 int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
1345 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n");
1347 /* Initialize command packet buffers */
1348 error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0);
1350 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n");
1354 /* Initialize generic buffer */
1355 error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1);
1357 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n");
1361 for (i=0;i<TW_Q_LENGTH;i++) {
1362 tw_dev->free_queue[i] = i;
1363 tw_dev->state[i] = TW_S_INITIAL;
1366 tw_dev->pending_head = TW_Q_START;
1367 tw_dev->pending_tail = TW_Q_START;
1368 spin_lock_init(&tw_dev->tw_lock);
1369 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1372 } /* End tw_initialize_device_extension() */
1374 /* This function will get unit info from the controller */
1375 int tw_initialize_units(TW_Device_Extension *tw_dev)
1378 unsigned char request_id = 0;
1379 TW_Command *command_packet;
1381 int i, imax, num_units = 0;
1382 unsigned long command_que_value;
1383 u32 command_que_addr;
1384 u32 response_que_addr;
1385 TW_Response_Queue response_queue;
1386 unsigned long param_value;
1387 unsigned char *is_unit_present;
1389 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_units()\n");
1391 command_que_addr = tw_dev->registers.command_que_addr;
1392 response_que_addr = tw_dev->registers.response_que_addr;
1394 /* Setup the command packet */
1395 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1396 if (command_packet == NULL) {
1397 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad command packet virtual address.\n");
1400 memset(command_packet, 0, sizeof(TW_Sector));
1401 command_packet->byte0.opcode = TW_OP_GET_PARAM;
1402 command_packet->byte0.sgl_offset = 2;
1403 command_packet->size = 4;
1404 command_packet->request_id = request_id;
1405 command_packet->byte3.unit = 0;
1406 command_packet->byte3.host_id = 0;
1407 command_packet->status = 0;
1408 command_packet->flags = 0;
1409 command_packet->byte6.block_count = 1;
1411 /* Now setup the param */
1412 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1413 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad alignment virtual address.\n");
1416 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1417 memset(param, 0, sizeof(TW_Sector));
1418 param->table_id = 3; /* unit summary table */
1419 param->parameter_id = 3; /* unitstatus parameter */
1420 param->parameter_size_bytes = TW_MAX_UNITS;
1421 param_value = tw_dev->alignment_physical_address[request_id];
1422 if (param_value == 0) {
1423 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad alignment physical address.\n");
1427 command_packet->byte8.param.sgl[0].address = param_value;
1428 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1430 /* Post the command packet to the board */
1431 command_que_value = tw_dev->command_packet_physical_address[request_id];
1432 if (command_que_value == 0) {
1433 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad command packet physical address.\n");
1436 outl(command_que_value, command_que_addr);
1438 /* Poll for completion */
1439 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1440 response_queue.value = inl(response_que_addr);
1441 request_id = (unsigned char)response_queue.u.response_id;
1442 if (request_id != 0) {
1443 /* unexpected request id */
1444 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Unexpected request id.\n");
1447 if (command_packet->status != 0) {
1449 tw_decode_sense(tw_dev, request_id, 0);
1455 /* response never received */
1456 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): No response.\n");
1460 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1461 is_unit_present = (unsigned char *)&(param->data[0]);
1463 /* Show all units present */
1464 imax = TW_MAX_UNITS;
1465 for(i=0; i<imax; i++) {
1466 if (is_unit_present[i] == 0) {
1467 tw_dev->is_unit_present[i] = FALSE;
1469 if (is_unit_present[i] & TW_UNIT_ONLINE) {
1470 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_units(): Unit %d found.\n", i);
1471 tw_dev->is_unit_present[i] = TRUE;
1476 tw_dev->num_units = num_units;
1478 if (num_units == 0) {
1479 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_units(): No units found.\n");
1484 } /* End tw_initialize_units() */
1486 /* This function is the interrupt service routine */
1487 static irqreturn_t tw_interrupt(int irq, void *dev_instance,
1488 struct pt_regs *regs)
1491 u32 status_reg_addr, status_reg_value;
1492 u32 response_que_addr;
1493 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1494 TW_Response_Queue response_que;
1495 int error = 0, retval = 0;
1496 unsigned long flags = 0;
1497 TW_Command *command_packet;
1500 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt()\n");
1502 /* See if we are already running on another processor */
1503 if (test_and_set_bit(TW_IN_INTR, &tw_dev->flags))
1506 /* Get the host lock for io completions */
1507 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1509 /* See if the interrupt matches this instance */
1510 if (tw_dev->tw_pci_dev->irq == irq) {
1513 /* Make sure io isn't queueing */
1514 spin_lock(&tw_dev->tw_lock);
1516 /* Read the registers */
1517 status_reg_addr = tw_dev->registers.status_reg_addr;
1518 response_que_addr = tw_dev->registers.response_que_addr;
1519 status_reg_value = inl(status_reg_addr);
1521 /* Check if this is our interrupt, otherwise bail */
1522 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1523 goto tw_interrupt_bail;
1525 /* Check controller for errors */
1526 if (tw_check_bits(status_reg_value)) {
1527 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
1528 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
1529 tw_clear_all_interrupts(tw_dev);
1530 goto tw_interrupt_bail;
1534 /* Handle host interrupt */
1535 if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
1536 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
1537 tw_clear_host_interrupt(tw_dev);
1540 /* Handle attention interrupt */
1541 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1542 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
1543 tw_clear_attention_interrupt(tw_dev);
1544 tw_state_request_start(tw_dev, &request_id);
1545 error = tw_aen_read_queue(tw_dev, request_id);
1547 printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
1548 tw_dev->state[request_id] = TW_S_COMPLETED;
1549 tw_state_request_finish(tw_dev, request_id);
1553 /* Handle command interrupt */
1554 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1555 /* Drain as many pending commands as we can */
1556 while (tw_dev->pending_request_count > 0) {
1557 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1558 if (tw_dev->state[request_id] != TW_S_PENDING) {
1559 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
1562 if (tw_post_command_packet(tw_dev, request_id)==0) {
1563 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
1564 tw_dev->pending_head = TW_Q_START;
1566 tw_dev->pending_head = tw_dev->pending_head + 1;
1568 tw_dev->pending_request_count--;
1570 /* If we get here, we will continue re-posting on the next command interrupt */
1574 /* If there are no more pending requests, we mask command interrupt */
1575 if (tw_dev->pending_request_count == 0)
1576 tw_mask_command_interrupt(tw_dev);
1579 /* Handle response interrupt */
1580 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1581 /* Drain the response queue from the board */
1582 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1583 /* Read response queue register */
1584 response_que.value = inl(response_que_addr);
1585 request_id = response_que.u.response_id;
1586 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1589 /* Check for bad response */
1590 if (command_packet->status != 0) {
1591 /* If internal command, don't error, don't fill sense */
1592 if (tw_dev->srb[request_id] == 0) {
1593 tw_decode_sense(tw_dev, request_id, 0);
1595 error = tw_decode_sense(tw_dev, request_id, 1);
1599 /* Check for correct state */
1600 if (tw_dev->state[request_id] != TW_S_POSTED) {
1601 /* Handle timed out ioctl's */
1602 if (tw_dev->srb[request_id] != 0) {
1603 if (tw_dev->srb[request_id]->cmnd[0] != TW_IOCTL) {
1604 printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id (%d) (opcode = 0x%x) that wasn't posted.\n", tw_dev->host->host_no, request_id, command_packet->byte0.opcode);
1610 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
1612 /* Check for internal command completion */
1613 if (tw_dev->srb[request_id] == 0) {
1614 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
1615 /* Check for chrdev ioctl completion */
1616 if (request_id != tw_dev->chrdev_request_id) {
1617 retval = tw_aen_complete(tw_dev, request_id);
1619 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
1622 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1623 wake_up(&tw_dev->ioctl_wqueue);
1626 switch (tw_dev->srb[request_id]->cmnd[0]) {
1629 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
1633 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
1635 case TEST_UNIT_READY:
1636 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
1637 error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
1640 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
1641 error = tw_scsiop_inquiry_complete(tw_dev, request_id);
1644 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
1645 error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
1648 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
1649 error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
1651 case SYNCHRONIZE_CACHE:
1652 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
1655 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TW_IOCTL\n");
1656 error = tw_ioctl_complete(tw_dev, request_id);
1659 printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
1663 /* If no error command was a success */
1665 tw_dev->srb[request_id]->result = (DID_OK << 16);
1668 /* If error, command failed */
1670 /* Ask for a host reset */
1671 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1674 /* Now complete the io */
1675 if ((error != TW_ISR_DONT_COMPLETE)) {
1676 tw_dev->state[request_id] = TW_S_COMPLETED;
1677 tw_state_request_finish(tw_dev, request_id);
1678 tw_dev->posted_request_count--;
1679 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1681 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1685 /* Check for valid status after each drain */
1686 status_reg_value = inl(status_reg_addr);
1687 if (tw_check_bits(status_reg_value)) {
1688 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
1689 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
1690 tw_clear_all_interrupts(tw_dev);
1691 goto tw_interrupt_bail;
1697 spin_unlock(&tw_dev->tw_lock);
1699 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt() called for wrong instance.\n");
1701 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1702 clear_bit(TW_IN_INTR, &tw_dev->flags);
1703 return IRQ_RETVAL(handled);
1704 } /* End tw_interrupt() */
1706 /* This function handles ioctls from userspace to the driver */
1707 int tw_ioctl(TW_Device_Extension *tw_dev, int request_id)
1709 unsigned char opcode;
1710 int bufflen, error = 0;
1712 TW_Command *command_packet, *command_save;
1713 unsigned long param_value;
1714 TW_Ioctl *ioctl = NULL;
1715 TW_Passthru *passthru = NULL;
1716 int tw_aen_code, i, use_sg;
1717 unsigned long *data_ptr;
1718 int total_bytes = 0, posted = 0;
1719 dma_addr_t dma_handle;
1720 struct timeval before, timeout;
1722 ioctl = (TW_Ioctl *)tw_dev->srb[request_id]->request_buffer;
1723 if (ioctl == NULL) {
1724 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Request buffer NULL.\n");
1725 tw_dev->state[request_id] = TW_S_COMPLETED;
1726 tw_state_request_finish(tw_dev, request_id);
1727 tw_dev->srb[request_id]->result = (DID_OK << 16);
1728 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1731 bufflen = tw_dev->srb[request_id]->request_bufflen;
1733 /* Initialize command packet */
1734 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1735 if (command_packet == NULL) {
1736 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad command packet virtual address.\n");
1737 tw_dev->state[request_id] = TW_S_COMPLETED;
1738 tw_state_request_finish(tw_dev, request_id);
1739 tw_dev->srb[request_id]->result = (DID_OK << 16);
1740 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1743 memset(command_packet, 0, sizeof(TW_Sector));
1745 /* Initialize param */
1746 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1747 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad alignment virtual address.\n");
1748 tw_dev->state[request_id] = TW_S_COMPLETED;
1749 tw_state_request_finish(tw_dev, request_id);
1750 tw_dev->srb[request_id]->result = (DID_OK << 16);
1751 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1754 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1755 memset(param, 0, sizeof(TW_Sector));
1757 dprintk(KERN_NOTICE "opcode = %d table_id = %d parameter_id = %d parameter_size_bytes = %d\n", ioctl->opcode, ioctl->table_id, ioctl->parameter_id, ioctl->parameter_size_bytes);
1758 opcode = ioctl->opcode;
1762 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_NOP.\n");
1763 command_packet->byte0.opcode = TW_OP_NOP;
1765 case TW_OP_GET_PARAM:
1766 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_GET_PARAM.\n");
1767 command_packet->byte0.opcode = TW_OP_GET_PARAM;
1768 command_packet->byte3.unit = ioctl->unit_index;
1769 param->table_id = ioctl->table_id;
1770 param->parameter_id = ioctl->parameter_id;
1771 param->parameter_size_bytes = ioctl->parameter_size_bytes;
1772 tw_dev->ioctl_size[request_id] = ioctl->parameter_size_bytes;
1773 dprintk(KERN_NOTICE "table_id = %d parameter_id = %d parameter_size_bytes %d\n", param->table_id, param->parameter_id, param->parameter_size_bytes);
1775 case TW_OP_SET_PARAM:
1776 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_SET_PARAM: table_id = %d, parameter_id = %d, parameter_size_bytes = %d.\n",
1777 ioctl->table_id, ioctl->parameter_id, ioctl->parameter_size_bytes);
1778 if (ioctl->data != NULL) {
1779 command_packet->byte0.opcode = TW_OP_SET_PARAM;
1780 param->table_id = ioctl->table_id;
1781 param->parameter_id = ioctl->parameter_id;
1782 param->parameter_size_bytes = ioctl->parameter_size_bytes;
1783 memcpy(param->data, ioctl->data, ioctl->parameter_size_bytes);
1786 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
1789 case TW_OP_AEN_LISTEN:
1790 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_AEN_LISTEN.\n");
1791 if (tw_dev->aen_head == tw_dev->aen_tail) {
1792 /* aen queue empty */
1793 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): Aen queue empty.\n");
1794 tw_aen_code = TW_AEN_QUEUE_EMPTY;
1795 memcpy(tw_dev->srb[request_id]->request_buffer, &tw_aen_code, ioctl->parameter_size_bytes);
1797 /* Copy aen queue entry to request buffer */
1798 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): Returning aen 0x%x\n", tw_dev->aen_queue[tw_dev->aen_head]);
1799 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
1800 memcpy(tw_dev->srb[request_id]->request_buffer, &tw_aen_code, ioctl->parameter_size_bytes);
1801 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
1802 tw_dev->aen_head = TW_Q_START;
1804 tw_dev->aen_head = tw_dev->aen_head + 1;
1807 tw_dev->state[request_id] = TW_S_COMPLETED;
1808 tw_state_request_finish(tw_dev, request_id);
1809 tw_dev->srb[request_id]->result = (DID_OK << 16);
1810 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1812 case TW_ATA_PASSTHRU:
1813 if (ioctl->data != NULL) {
1814 memcpy(command_packet, ioctl->data, sizeof(TW_Command));
1815 command_packet->request_id = request_id;
1817 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
1821 passthru = (TW_Passthru *)tw_dev->command_packet_virtual_address[request_id];
1822 /* Don't load sg_list for non-data ATA cmds */
1823 if ((passthru->param != 0) && (passthru->param != 0x8)) {
1824 passthru->sg_list[0].length = passthru->sector_count*512;
1825 if (passthru->sg_list[0].length > TW_MAX_PASSTHRU_BYTES) {
1826 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Passthru size (%d) too big.\n", passthru->sg_list[0].length);
1829 passthru->sg_list[0].address = tw_dev->alignment_physical_address[request_id];
1831 tw_post_command_packet(tw_dev, request_id);
1834 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl(): caught TW_CMD_PACKET.\n");
1835 if (ioctl->data != NULL) {
1836 memcpy(command_packet, ioctl->data, sizeof(TW_Command));
1837 command_packet->request_id = request_id;
1838 tw_post_command_packet(tw_dev, request_id);
1841 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
1844 case TW_CMD_PACKET_WITH_DATA:
1845 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
1846 command_save = (TW_Command *)tw_dev->alignment_virtual_address[request_id];
1847 if (command_save == NULL) {
1848 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad alignment virtual address.\n", tw_dev->host->host_no);
1851 if (ioctl->data != NULL) {
1852 /* Copy down the command packet */
1853 memcpy(command_packet, ioctl->data, sizeof(TW_Command));
1854 memcpy(command_save, ioctl->data, sizeof(TW_Command));
1855 command_packet->request_id = request_id;
1857 /* Now deal with the two possible sglists */
1858 if (command_packet->byte0.sgl_offset == 2) {
1859 use_sg = command_packet->size - 3;
1860 for (i=0;i<use_sg;i++)
1861 total_bytes+=command_packet->byte8.param.sgl[i].length;
1862 tw_dev->ioctl_data[request_id] = pci_alloc_consistent(tw_dev->tw_pci_dev, total_bytes, &dma_handle);
1864 if (!tw_dev->ioctl_data[request_id]) {
1865 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): pci_alloc_consistent() failed for request_id %d.\n", tw_dev->host->host_no, request_id);
1869 /* Copy param sglist into the kernel */
1870 data_ptr = tw_dev->ioctl_data[request_id];
1871 for (i=0;i<use_sg;i++) {
1872 if (command_packet->byte8.param.sgl[i].address != 0) {
1873 error = copy_from_user(data_ptr, (void *)(unsigned long)command_packet->byte8.param.sgl[i].address, command_packet->byte8.param.sgl[i].length);
1875 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying param sglist from userspace.\n", tw_dev->host->host_no);
1879 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad param sgl address.\n", tw_dev->host->host_no);
1880 tw_dev->srb[request_id]->result = (DID_RESET << 16);
1883 data_ptr+=command_packet->byte8.param.sgl[i].length;
1885 command_packet->size = 4;
1886 command_packet->byte8.param.sgl[0].address = dma_handle;
1887 command_packet->byte8.param.sgl[0].length = total_bytes;
1889 if (command_packet->byte0.sgl_offset == 3) {
1890 use_sg = command_packet->size - 4;
1891 for (i=0;i<use_sg;i++)
1892 total_bytes+=command_packet->byte8.io.sgl[i].length;
1893 tw_dev->ioctl_data[request_id] = pci_alloc_consistent(tw_dev->tw_pci_dev, total_bytes, &dma_handle);
1895 if (!tw_dev->ioctl_data[request_id]) {
1896 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): pci_alloc_consistent() failed for request_id %d.\n", tw_dev->host->host_no, request_id);
1899 if (command_packet->byte0.opcode == TW_OP_WRITE) {
1900 /* Copy io sglist into the kernel */
1901 data_ptr = tw_dev->ioctl_data[request_id];
1902 for (i=0;i<use_sg;i++) {
1903 if (command_packet->byte8.io.sgl[i].address != 0) {
1904 error = copy_from_user(data_ptr, (void *)(unsigned long)command_packet->byte8.io.sgl[i].address, command_packet->byte8.io.sgl[i].length);
1906 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying io sglist from userspace.\n", tw_dev->host->host_no);
1910 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad io sgl address.\n", tw_dev->host->host_no);
1911 tw_dev->srb[request_id]->result = (DID_RESET << 16);
1914 data_ptr+=command_packet->byte8.io.sgl[i].length;
1917 command_packet->size = 5;
1918 command_packet->byte8.io.sgl[0].address = dma_handle;
1919 command_packet->byte8.io.sgl[0].length = total_bytes;
1922 spin_unlock(&tw_dev->tw_lock);
1923 spin_unlock_irq(tw_dev->host->host_lock);
1925 set_bit(TW_IN_IOCTL, &tw_dev->flags);
1927 /* Finally post the command packet */
1928 tw_post_command_packet(tw_dev, request_id);
1930 do_gettimeofday(&before);
1933 mdelay(TW_IOCTL_WAIT_TIME);
1934 if (test_bit(TW_IN_IOCTL, &tw_dev->flags)) {
1935 do_gettimeofday(&timeout);
1936 if (before.tv_sec + TW_IOCTL_TIMEOUT < timeout.tv_sec) {
1937 spin_lock_irq(tw_dev->host->host_lock);
1938 spin_lock(&tw_dev->tw_lock);
1941 goto tw_ioctl_retry;
1945 spin_lock_irq(tw_dev->host->host_lock);
1946 spin_lock(&tw_dev->tw_lock);
1948 if (signal_pending(current)) {
1949 dprintk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Signal pending, aborting ioctl().\n", tw_dev->host->host_no);
1950 tw_dev->srb[request_id]->result = (DID_OK << 16);
1954 tw_dev->srb[request_id]->result = (DID_OK << 16);
1955 /* Now copy up the param or io sglist to userspace */
1956 if (command_packet->byte0.sgl_offset == 2) {
1957 use_sg = command_save->size - 3;
1958 data_ptr = tw_dev->ioctl_data[request_id];
1959 for (i=0;i<use_sg;i++) {
1960 if (command_save->byte8.param.sgl[i].address != 0) {
1961 error = copy_to_user((void *)(unsigned long)command_save->byte8.param.sgl[i].address, data_ptr, command_save->byte8.param.sgl[i].length);
1963 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying param sglist to userspace.\n", tw_dev->host->host_no);
1966 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Copied %ld bytes to pid %d.\n", tw_dev->host->host_no, command_save->byte8.param.sgl[i].length, current->pid);
1967 data_ptr+=command_save->byte8.param.sgl[i].length;
1969 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad param sgl address.\n", tw_dev->host->host_no);
1970 tw_dev->srb[request_id]->result = (DID_RESET << 16);
1975 if (command_packet->byte0.sgl_offset == 3) {
1976 use_sg = command_save->size - 4;
1977 if (command_packet->byte0.opcode == TW_OP_READ) {
1978 data_ptr = tw_dev->ioctl_data[request_id];
1979 for(i=0;i<use_sg;i++) {
1980 if (command_save->byte8.io.sgl[i].address != 0) {
1981 error = copy_to_user((void *)(unsigned long)command_save->byte8.io.sgl[i].address, data_ptr, command_save->byte8.io.sgl[i].length);
1983 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying io sglist to userspace.\n", tw_dev->host->host_no);
1986 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Copied %ld bytes to pid %d.\n", tw_dev->host->host_no, command_save->byte8.io.sgl[i].length, current->pid);
1987 data_ptr+=command_save->byte8.io.sgl[i].length;
1989 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad io sgl address.\n", tw_dev->host->host_no);
1990 tw_dev->srb[request_id]->result = (DID_RESET << 16);
1999 /* Free up sglist memory */
2000 if (tw_dev->ioctl_data[request_id])
2001 pci_free_consistent(tw_dev->tw_pci_dev, total_bytes, tw_dev->ioctl_data[request_id], dma_handle);
2003 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Error freeing ioctl data.\n", tw_dev->host->host_no);
2005 /* Now complete the io */
2006 tw_dev->state[request_id] = TW_S_COMPLETED;
2007 tw_state_request_finish(tw_dev, request_id);
2009 tw_dev->posted_request_count--;
2010 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2013 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
2017 dprintk(KERN_WARNING "3w-xxxx: Unknown ioctl 0x%x.\n", opcode);
2018 tw_dev->state[request_id] = TW_S_COMPLETED;
2019 tw_state_request_finish(tw_dev, request_id);
2020 tw_dev->srb[request_id]->result = (DID_OK << 16);
2021 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2025 param_value = tw_dev->alignment_physical_address[request_id];
2026 if (param_value == 0) {
2027 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad alignment physical address.\n");
2028 tw_dev->state[request_id] = TW_S_COMPLETED;
2029 tw_state_request_finish(tw_dev, request_id);
2030 tw_dev->srb[request_id]->result = (DID_OK << 16);
2031 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2034 command_packet->byte8.param.sgl[0].address = param_value;
2035 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2037 command_packet->byte0.sgl_offset = 2;
2038 command_packet->size = 4;
2039 command_packet->request_id = request_id;
2040 command_packet->byte3.host_id = 0;
2041 command_packet->status = 0;
2042 command_packet->flags = 0;
2043 command_packet->byte6.parameter_count = 1;
2045 /* Now try to post the command to the board */
2046 tw_post_command_packet(tw_dev, request_id);
2049 } /* End tw_ioctl() */
2051 /* This function is called by the isr to complete ioctl requests */
2052 int tw_ioctl_complete(TW_Device_Extension *tw_dev, int request_id)
2054 unsigned char *param_data;
2055 unsigned char *buff;
2057 TW_Ioctl *ioctl = NULL;
2058 TW_Passthru *passthru = NULL;
2059 TW_Command *command_packet;
2061 ioctl = (TW_Ioctl *)tw_dev->srb[request_id]->request_buffer;
2062 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl_complete()\n");
2063 buff = tw_dev->srb[request_id]->request_buffer;
2065 printk(KERN_WARNING "3w-xxxx: tw_ioctl_complete(): Request buffer NULL.\n");
2069 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2070 if (command_packet == NULL) {
2071 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl_complete(): Bad command packet virtual address.\n", tw_dev->host->host_no);
2075 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl_complete(): Request_bufflen = %d\n", tw_dev->srb[request_id]->request_bufflen);
2077 ioctl = (TW_Ioctl *)buff;
2078 switch (ioctl->opcode) {
2079 case TW_ATA_PASSTHRU:
2080 passthru = (TW_Passthru *)ioctl->data;
2081 /* Don't return data for non-data ATA cmds */
2082 if ((passthru->param != 0) && (passthru->param != 0x8))
2083 memcpy(buff, tw_dev->alignment_virtual_address[request_id], passthru->sector_count * 512);
2085 /* For non-data cmds, return cmd pkt */
2086 if (tw_dev->srb[request_id]->request_bufflen >= sizeof(TW_Command))
2087 memcpy(buff, tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
2090 case TW_CMD_PACKET_WITH_DATA:
2091 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_complete(): caught TW_CMD_PACKET_WITH_DATA.\n");
2092 clear_bit(TW_IN_IOCTL, &tw_dev->flags);
2093 return TW_ISR_DONT_COMPLETE; /* Special case for isr to not complete io */
2095 memset(buff, 0, tw_dev->srb[request_id]->request_bufflen);
2096 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2097 if (param == NULL) {
2098 printk(KERN_WARNING "3w-xxxx: tw_ioctl_complete(): Bad alignment virtual address.\n");
2101 param_data = &(param->data[0]);
2102 memcpy(buff, param_data, tw_dev->ioctl_size[request_id]);
2105 } /* End tw_ioctl_complete() */
2107 static int tw_map_scsi_sg_data(struct pci_dev *pdev, Scsi_Cmnd *cmd)
2110 int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
2112 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data()\n");
2114 if (cmd->use_sg == 0)
2117 use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir);
2120 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data(): pci_map_sg() failed.\n");
2125 cmd->SCp.have_data_in = use_sg;
2128 } /* End tw_map_scsi_sg_data() */
2130 static u32 tw_map_scsi_single_data(struct pci_dev *pdev, Scsi_Cmnd *cmd)
2133 int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
2135 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data()\n");
2137 if (cmd->request_bufflen == 0)
2140 mapping = pci_map_page(pdev, virt_to_page(cmd->request_buffer), offset_in_page(cmd->request_buffer), cmd->request_bufflen, dma_dir);
2143 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data(): pci_map_page() failed.\n");
2148 cmd->SCp.have_data_in = mapping;
2151 } /* End tw_map_scsi_single_data() */
2153 /* This function will mask the command interrupt */
2154 void tw_mask_command_interrupt(TW_Device_Extension *tw_dev)
2156 u32 control_reg_addr, control_reg_value;
2158 control_reg_addr = tw_dev->registers.control_reg_addr;
2159 control_reg_value = TW_CONTROL_MASK_COMMAND_INTERRUPT;
2160 outl(control_reg_value, control_reg_addr);
2161 } /* End tw_mask_command_interrupt() */
2163 /* This function will poll the status register for a flag */
2164 int tw_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
2166 u32 status_reg_addr, status_reg_value;
2167 struct timeval before, timeout;
2169 status_reg_addr = tw_dev->registers.status_reg_addr;
2170 do_gettimeofday(&before);
2171 status_reg_value = inl(status_reg_addr);
2173 if (tw_check_bits(status_reg_value)) {
2174 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status(): Unexpected bits.\n");
2175 tw_decode_bits(tw_dev, status_reg_value, 0);
2178 while ((status_reg_value & flag) != flag) {
2179 status_reg_value = inl(status_reg_addr);
2181 if (tw_check_bits(status_reg_value)) {
2182 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status(): Unexpected bits.\n");
2183 tw_decode_bits(tw_dev, status_reg_value, 0);
2186 do_gettimeofday(&timeout);
2187 if (before.tv_sec + seconds < timeout.tv_sec) {
2188 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status(): Flag 0x%x not found.\n", flag);
2194 } /* End tw_poll_status() */
2196 /* This function will poll the status register for disappearance of a flag */
2197 int tw_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
2199 u32 status_reg_addr, status_reg_value;
2200 struct timeval before, timeout;
2202 status_reg_addr = tw_dev->registers.status_reg_addr;
2203 do_gettimeofday(&before);
2204 status_reg_value = inl(status_reg_addr);
2206 if (tw_check_bits(status_reg_value)) {
2207 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status_gone(): Unexpected bits.\n");
2208 tw_decode_bits(tw_dev, status_reg_value, 0);
2211 while ((status_reg_value & flag) != 0) {
2212 status_reg_value = inl(status_reg_addr);
2214 if (tw_check_bits(status_reg_value)) {
2215 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status_gone(): Unexpected bits.\n");
2216 tw_decode_bits(tw_dev, status_reg_value, 0);
2219 do_gettimeofday(&timeout);
2220 if (before.tv_sec + seconds < timeout.tv_sec) {
2221 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status_gone(): Flag 0x%x never disappeared.\n", flag);
2227 } /* End tw_poll_status_gone() */
2229 /* This function will attempt to post a command packet to the board */
2230 int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
2232 u32 status_reg_addr, status_reg_value;
2233 unsigned long command_que_value;
2234 u32 command_que_addr;
2236 dprintk(KERN_NOTICE "3w-xxxx: tw_post_command_packet()\n");
2237 command_que_addr = tw_dev->registers.command_que_addr;
2238 command_que_value = tw_dev->command_packet_physical_address[request_id];
2239 status_reg_addr = tw_dev->registers.status_reg_addr;
2240 status_reg_value = inl(status_reg_addr);
2242 if (tw_check_bits(status_reg_value)) {
2243 dprintk(KERN_WARNING "3w-xxxx: tw_post_command_packet(): Unexpected bits.\n");
2244 tw_decode_bits(tw_dev, status_reg_value, 1);
2247 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
2248 /* We successfully posted the command packet */
2249 outl(command_que_value, command_que_addr);
2250 tw_dev->state[request_id] = TW_S_POSTED;
2251 tw_dev->posted_request_count++;
2252 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
2253 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
2256 /* Couldn't post the command packet, so we do it in the isr */
2257 if (tw_dev->state[request_id] != TW_S_PENDING) {
2258 tw_dev->state[request_id] = TW_S_PENDING;
2259 tw_dev->pending_request_count++;
2260 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
2261 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
2263 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
2264 if (tw_dev->pending_tail == TW_Q_LENGTH-1) {
2265 tw_dev->pending_tail = TW_Q_START;
2267 tw_dev->pending_tail = tw_dev->pending_tail + 1;
2270 tw_unmask_command_interrupt(tw_dev);
2274 } /* End tw_post_command_packet() */
2276 /* This function will reset a device extension */
2277 int tw_reset_device_extension(TW_Device_Extension *tw_dev)
2283 dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n");
2286 if (tw_reset_sequence(tw_dev)) {
2287 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
2291 /* Abort all requests that are in progress */
2292 for (i=0;i<imax;i++) {
2293 if ((tw_dev->state[i] != TW_S_FINISHED) &&
2294 (tw_dev->state[i] != TW_S_INITIAL) &&
2295 (tw_dev->state[i] != TW_S_COMPLETED)) {
2296 srb = tw_dev->srb[i];
2298 srb->result = (DID_RESET << 16);
2299 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
2300 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[i]);
2305 /* Reset queues and counts */
2306 for (i=0;i<imax;i++) {
2307 tw_dev->free_queue[i] = i;
2308 tw_dev->state[i] = TW_S_INITIAL;
2310 tw_dev->free_head = TW_Q_START;
2311 tw_dev->free_tail = TW_Q_START;
2312 tw_dev->posted_request_count = 0;
2313 tw_dev->pending_request_count = 0;
2314 tw_dev->pending_head = TW_Q_START;
2315 tw_dev->pending_tail = TW_Q_START;
2316 tw_dev->reset_print = 0;
2317 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2320 } /* End tw_reset_device_extension() */
2322 /* This function will reset a controller */
2323 int tw_reset_sequence(TW_Device_Extension *tw_dev)
2328 /* Disable interrupts */
2329 tw_disable_interrupts(tw_dev);
2331 /* Reset the board */
2332 while (tries < TW_MAX_RESET_TRIES) {
2333 tw_soft_reset(tw_dev);
2335 error = tw_aen_drain_queue(tw_dev);
2337 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no);
2342 /* Check for controller errors */
2343 if (tw_check_errors(tw_dev)) {
2344 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no);
2349 /* Now the controller is in a good state */
2353 if (tries >= TW_MAX_RESET_TRIES) {
2354 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no);
2358 error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
2360 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no);
2364 /* Re-enable interrupts */
2365 tw_enable_and_clear_interrupts(tw_dev);
2368 } /* End tw_reset_sequence() */
2370 /* This funciton returns unit geometry in cylinders/heads/sectors */
2371 int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
2372 sector_t capacity, int geom[])
2374 int heads, sectors, cylinders;
2375 TW_Device_Extension *tw_dev;
2377 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n");
2378 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
2382 cylinders = (unsigned long)capacity / (heads * sectors);
2384 if (capacity >= 0x200000) {
2387 cylinders = (unsigned long)capacity / (heads * sectors);
2390 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders);
2393 geom[2] = cylinders;
2396 } /* End tw_scsi_biosparam() */
2398 /* This function will find and initialize any cards */
2399 int tw_scsi_detect(Scsi_Host_Template *tw_host)
2403 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_detect()\n");
2405 printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", tw_driver_version);
2407 ret = tw_findcards(tw_host);
2410 } /* End tw_scsi_detect() */
2412 /* This is the new scsi eh abort function */
2413 int tw_scsi_eh_abort(Scsi_Cmnd *SCpnt)
2415 TW_Device_Extension *tw_dev=NULL;
2418 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_eh_abort()\n");
2421 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_abort(): Invalid Scsi_Cmnd.\n");
2425 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
2426 if (tw_dev == NULL) {
2427 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_abort(): Invalid device extension.\n");
2431 spin_lock(&tw_dev->tw_lock);
2432 tw_dev->num_aborts++;
2434 /* If the command hasn't been posted yet, we can do the abort */
2435 for (i=0;i<TW_Q_LENGTH;i++) {
2436 if (tw_dev->srb[i] == SCpnt) {
2437 if (tw_dev->state[i] == TW_S_STARTED) {
2438 printk(KERN_WARNING "3w-xxxx: scsi%d: Unit #%d: Command (%p) timed out.\n", tw_dev->host->host_no, tw_dev->srb[i]==0 ? 0 : tw_dev->srb[i]->device->id, SCpnt);
2439 tw_dev->state[i] = TW_S_COMPLETED;
2440 tw_state_request_finish(tw_dev, i);
2441 spin_unlock(&tw_dev->tw_lock);
2444 if (tw_dev->state[i] == TW_S_PENDING) {
2445 printk(KERN_WARNING "3w-xxxx: scsi%d: Unit #%d: Command (%p) timed out.\n", tw_dev->host->host_no, tw_dev->srb[i]==0 ? 0 : tw_dev->srb[i]->device->id, SCpnt);
2446 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2447 tw_dev->pending_head = TW_Q_START;
2449 tw_dev->pending_head = tw_dev->pending_head + 1;
2451 tw_dev->pending_request_count--;
2452 tw_dev->state[i] = TW_S_COMPLETED;
2453 tw_state_request_finish(tw_dev, i);
2454 spin_unlock(&tw_dev->tw_lock);
2457 if (tw_dev->state[i] == TW_S_POSTED) {
2458 /* If the command has already been posted, we have to reset the card */
2459 printk(KERN_WARNING "3w-xxxx: scsi%d: Unit #%d: Command (%p) timed out, resetting card.\n", tw_dev->host->host_no, tw_dev->srb[i]==0 ? 0 : tw_dev->srb[i]->device->id, SCpnt);
2460 /* We have to let AEN requests through before the reset */
2461 spin_unlock(&tw_dev->tw_lock);
2462 spin_unlock_irq(tw_dev->host->host_lock);
2463 mdelay(TW_AEN_WAIT_TIME);
2464 spin_lock_irq(tw_dev->host->host_lock);
2465 spin_lock(&tw_dev->tw_lock);
2467 if (tw_reset_device_extension(tw_dev)) {
2468 dprintk(KERN_WARNING "3w-xxxx: tw_scsi_eh_abort(): Reset failed for card %d.\n", tw_dev->host->host_no);
2469 spin_unlock(&tw_dev->tw_lock);
2476 spin_unlock(&tw_dev->tw_lock);
2478 } /* End tw_scsi_eh_abort() */
2480 /* This is the new scsi eh reset function */
2481 int tw_scsi_eh_reset(Scsi_Cmnd *SCpnt)
2483 TW_Device_Extension *tw_dev=NULL;
2485 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_eh_reset()\n");
2488 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_reset(): Invalid Scsi_Cmnd.\n");
2492 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
2493 if (tw_dev == NULL) {
2494 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_reset(): Invalid device extension.\n");
2498 /* We have to let AEN requests through before the reset */
2499 spin_unlock_irq(tw_dev->host->host_lock);
2500 mdelay(TW_AEN_WAIT_TIME);
2501 spin_lock_irq(tw_dev->host->host_lock);
2503 spin_lock(&tw_dev->tw_lock);
2504 tw_dev->num_resets++;
2506 /* Now reset the card and some of the device extension data */
2507 if (tw_reset_device_extension(tw_dev)) {
2508 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no);
2509 spin_unlock(&tw_dev->tw_lock);
2512 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset succeeded.\n", tw_dev->host->host_no);
2513 spin_unlock(&tw_dev->tw_lock);
2516 } /* End tw_scsi_eh_reset() */
2518 /* This function handles input and output from /proc/scsi/3w-xxxx/x */
2519 int tw_scsi_proc_info(struct Scsi_Host *shost, char *buffer, char **start,
2520 off_t offset, int length, int inout)
2522 TW_Device_Extension *tw_dev = NULL;
2527 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_proc_info()\n");
2529 /* Find the correct device extension */
2530 for (i=0;i<tw_device_extension_count;i++)
2531 if (tw_device_extension_list[i]->host->host_no == shost->host_no)
2532 tw_dev = tw_device_extension_list[i];
2533 if (tw_dev == NULL) {
2534 printk(KERN_WARNING "3w-xxxx: tw_scsi_proc_info(): Couldn't locate device extension.\n");
2538 info.buffer = buffer;
2539 info.length = length;
2540 info.offset = offset;
2545 if (strncmp(buffer, "debug", 5) == 0) {
2546 printk(KERN_INFO "3w-xxxx: Posted commands:\n");
2547 for (j=0;j<TW_Q_LENGTH;j++) {
2548 if (tw_dev->state[j] == TW_S_POSTED) {
2549 TW_Command *command = (TW_Command *)tw_dev->command_packet_virtual_address[j];
2550 printk(KERN_INFO "3w-xxxx: Request_id: %d\n", j);
2551 printk(KERN_INFO "Opcode: 0x%x\n", command->byte0.opcode);
2552 printk(KERN_INFO "Block_count: 0x%x\n", command->byte6.block_count);
2553 printk(KERN_INFO "LBA: 0x%x\n", command->byte8.io.lba);
2554 printk(KERN_INFO "Physical command packet addr: 0x%lx\n", tw_dev->command_packet_physical_address[j]);
2555 printk(KERN_INFO "Scsi_Cmnd: %p\n", tw_dev->srb[j]);
2558 printk(KERN_INFO "3w-xxxx: Free_head: %3d\n", tw_dev->free_head);
2559 printk(KERN_INFO "3w-xxxx: Free_tail: %3d\n", tw_dev->free_tail);
2567 tw_copy_info(&info, "scsi%d: 3ware Storage Controller\n", shost->host_no);
2568 tw_copy_info(&info, "Driver version: %s\n", tw_driver_version);
2569 tw_copy_info(&info, "Current commands posted: %3d\n", tw_dev->posted_request_count);
2570 tw_copy_info(&info, "Max commands posted: %3d\n", tw_dev->max_posted_request_count);
2571 tw_copy_info(&info, "Current pending commands: %3d\n", tw_dev->pending_request_count);
2572 tw_copy_info(&info, "Max pending commands: %3d\n", tw_dev->max_pending_request_count);
2573 tw_copy_info(&info, "Last sgl length: %3d\n", tw_dev->sgl_entries);
2574 tw_copy_info(&info, "Max sgl length: %3d\n", tw_dev->max_sgl_entries);
2575 tw_copy_info(&info, "Last sector count: %3d\n", tw_dev->sector_count);
2576 tw_copy_info(&info, "Max sector count: %3d\n", tw_dev->max_sector_count);
2577 tw_copy_info(&info, "Resets: %3d\n", tw_dev->num_resets);
2578 tw_copy_info(&info, "Aborts: %3d\n", tw_dev->num_aborts);
2579 tw_copy_info(&info, "AEN's: %3d\n", tw_dev->aen_count);
2581 if (info.position > info.offset) {
2582 return (info.position - info.offset);
2586 } /* End tw_scsi_proc_info() */
2588 /* This is the main scsi queue function to handle scsi opcodes */
2589 int tw_scsi_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
2591 unsigned char *command = SCpnt->cmnd;
2594 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
2596 if (tw_dev == NULL) {
2597 printk(KERN_WARNING "3w-xxxx: tw_scsi_queue(): Invalid device extension.\n");
2598 SCpnt->result = (DID_ERROR << 16);
2603 spin_lock(&tw_dev->tw_lock);
2604 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue()\n");
2606 /* Skip scsi command if it isn't for us */
2607 if ((SCpnt->device->channel != 0) || (SCpnt->device->lun != 0)) {
2608 SCpnt->result = (DID_BAD_TARGET << 16);
2610 spin_unlock(&tw_dev->tw_lock);
2614 /* Save done function into Scsi_Cmnd struct */
2615 SCpnt->scsi_done = done;
2617 /* Queue the command and get a request id */
2618 tw_state_request_start(tw_dev, &request_id);
2620 /* Save the scsi command for use by the ISR */
2621 tw_dev->srb[request_id] = SCpnt;
2623 /* Initialize phase to zero */
2624 SCpnt->SCp.phase = 0;
2631 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
2632 error = tw_scsiop_read_write(tw_dev, request_id);
2634 case TEST_UNIT_READY:
2635 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
2636 error = tw_scsiop_test_unit_ready(tw_dev, request_id);
2639 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
2640 error = tw_scsiop_inquiry(tw_dev, request_id);
2643 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
2644 error = tw_scsiop_read_capacity(tw_dev, request_id);
2647 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
2648 error = tw_scsiop_request_sense(tw_dev, request_id);
2651 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
2652 error = tw_scsiop_mode_sense(tw_dev, request_id);
2654 case SYNCHRONIZE_CACHE:
2655 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
2656 error = tw_scsiop_synchronize_cache(tw_dev, request_id);
2659 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TW_SCSI_IOCTL.\n");
2660 error = tw_ioctl(tw_dev, request_id);
2663 printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
2664 tw_dev->state[request_id] = TW_S_COMPLETED;
2665 tw_state_request_finish(tw_dev, request_id);
2666 SCpnt->result = (DID_BAD_TARGET << 16);
2670 tw_dev->state[request_id] = TW_S_COMPLETED;
2671 tw_state_request_finish(tw_dev, request_id);
2672 SCpnt->result = (DID_ERROR << 16);
2675 spin_unlock(&tw_dev->tw_lock);
2678 } /* End tw_scsi_queue() */
2680 /* This function will release the resources on an rmmod call */
2681 int tw_scsi_release(struct Scsi_Host *tw_host)
2683 TW_Device_Extension *tw_dev;
2684 tw_dev = (TW_Device_Extension *)tw_host->hostdata;
2686 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_release()\n");
2688 /* Fake like we just shut down, so notify the card that
2689 * we "shut down cleanly".
2691 tw_halt(0, 0, 0); // parameters aren't actually used
2693 /* Free up the IO region */
2694 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
2696 /* Free up the IRQ */
2697 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2699 /* Unregister character device */
2700 if (twe_major >= 0) {
2701 unregister_chrdev(twe_major, "twe");
2705 /* Free up device extension resources */
2706 tw_free_device_extension(tw_dev);
2708 /* Tell kernel scsi-layer we are gone */
2709 scsi_unregister(tw_host);
2712 } /* End tw_scsi_release() */
2714 /* This function handles scsi inquiry commands */
2715 int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id)
2718 TW_Command *command_packet;
2719 unsigned long command_que_value;
2720 u32 command_que_addr;
2721 unsigned long param_value;
2723 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n");
2725 /* Initialize command packet */
2726 command_que_addr = tw_dev->registers.command_que_addr;
2727 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2728 if (command_packet == NULL) {
2729 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n");
2732 memset(command_packet, 0, sizeof(TW_Sector));
2733 command_packet->byte0.opcode = TW_OP_GET_PARAM;
2734 command_packet->byte0.sgl_offset = 2;
2735 command_packet->size = 4;
2736 command_packet->request_id = request_id;
2737 command_packet->byte3.unit = 0;
2738 command_packet->byte3.host_id = 0;
2739 command_packet->status = 0;
2740 command_packet->flags = 0;
2741 command_packet->byte6.parameter_count = 1;
2743 /* Now setup the param */
2744 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
2745 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n");
2748 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2749 memset(param, 0, sizeof(TW_Sector));
2750 param->table_id = 3; /* unit summary table */
2751 param->parameter_id = 3; /* unitsstatus parameter */
2752 param->parameter_size_bytes = TW_MAX_UNITS;
2753 param_value = tw_dev->alignment_physical_address[request_id];
2754 if (param_value == 0) {
2755 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n");
2759 command_packet->byte8.param.sgl[0].address = param_value;
2760 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2761 command_que_value = tw_dev->command_packet_physical_address[request_id];
2762 if (command_que_value == 0) {
2763 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n");
2767 /* Now try to post the command packet */
2768 tw_post_command_packet(tw_dev, request_id);
2771 } /* End tw_scsiop_inquiry() */
2773 /* This function is called by the isr to complete an inquiry command */
2774 int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id)
2776 unsigned char *is_unit_present;
2777 unsigned char *request_buffer;
2780 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n");
2782 /* Fill request buffer */
2783 if (tw_dev->srb[request_id]->request_buffer == NULL) {
2784 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Request buffer NULL.\n");
2787 request_buffer = tw_dev->srb[request_id]->request_buffer;
2788 memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
2789 request_buffer[0] = TYPE_DISK; /* Peripheral device type */
2790 request_buffer[1] = 0; /* Device type modifier */
2791 request_buffer[2] = 0; /* No ansi/iso compliance */
2792 request_buffer[4] = 31; /* Additional length */
2793 memcpy(&request_buffer[8], "3ware ", 8); /* Vendor ID */
2794 sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id);
2795 memcpy(&request_buffer[32], tw_driver_version, 3);
2797 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2798 if (param == NULL) {
2799 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n");
2802 is_unit_present = &(param->data[0]);
2804 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
2805 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = TRUE;
2807 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = FALSE;
2808 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
2809 return TW_ISR_DONT_RESULT;
2813 } /* End tw_scsiop_inquiry_complete() */
2815 /* This function handles scsi mode_sense commands */
2816 int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id)
2819 TW_Command *command_packet;
2820 unsigned long command_que_value;
2821 unsigned long param_value;
2823 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n");
2825 /* Only page control = 0, page code = 0x8 (cache page) supported */
2826 if (tw_dev->srb[request_id]->cmnd[2] != 0x8) {
2827 tw_dev->state[request_id] = TW_S_COMPLETED;
2828 tw_state_request_finish(tw_dev, request_id);
2829 tw_dev->srb[request_id]->result = (DID_OK << 16);
2830 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2834 /* Now read firmware cache setting for this unit */
2835 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2836 if (command_packet == NULL) {
2837 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n");
2841 /* Setup the command packet */
2842 memset(command_packet, 0, sizeof(TW_Sector));
2843 command_packet->byte0.opcode = TW_OP_GET_PARAM;
2844 command_packet->byte0.sgl_offset = 2;
2845 command_packet->size = 4;
2846 command_packet->request_id = request_id;
2847 command_packet->byte3.unit = 0;
2848 command_packet->byte3.host_id = 0;
2849 command_packet->status = 0;
2850 command_packet->flags = 0;
2851 command_packet->byte6.parameter_count = 1;
2853 /* Setup the param */
2854 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
2855 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n");
2859 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2860 memset(param, 0, sizeof(TW_Sector));
2861 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id;
2862 param->parameter_id = 7; /* unit flags */
2863 param->parameter_size_bytes = 1;
2864 param_value = tw_dev->alignment_physical_address[request_id];
2865 if (param_value == 0) {
2866 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n");
2870 command_packet->byte8.param.sgl[0].address = param_value;
2871 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2872 command_que_value = tw_dev->command_packet_physical_address[request_id];
2873 if (command_que_value == 0) {
2874 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n");
2878 /* Now try to post the command packet */
2879 tw_post_command_packet(tw_dev, request_id);
2882 } /* End tw_scsiop_mode_sense() */
2884 /* This function is called by the isr to complete a mode sense command */
2885 int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id)
2888 unsigned char *flags;
2889 unsigned char *request_buffer;
2891 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n");
2893 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2894 if (param == NULL) {
2895 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n");
2898 flags = (char *)&(param->data[0]);
2899 request_buffer = tw_dev->srb[request_id]->buffer;
2900 memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
2902 request_buffer[0] = 0xf; /* mode data length */
2903 request_buffer[1] = 0; /* default medium type */
2904 request_buffer[2] = 0x10; /* dpo/fua support on */
2905 request_buffer[3] = 0; /* no block descriptors */
2906 request_buffer[4] = 0x8; /* caching page */
2907 request_buffer[5] = 0xa; /* page length */
2909 request_buffer[6] = 0x4; /* WCE on */
2911 request_buffer[6] = 0x0; /* WCE off */
2914 } /* End tw_scsiop_mode_sense_complete() */
2916 /* This function handles scsi read_capacity commands */
2917 int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id)
2920 TW_Command *command_packet;
2921 unsigned long command_que_value;
2922 u32 command_que_addr;
2923 unsigned long param_value;
2925 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n");
2927 /* Initialize command packet */
2928 command_que_addr = tw_dev->registers.command_que_addr;
2929 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2931 if (command_packet == NULL) {
2932 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n");
2935 memset(command_packet, 0, sizeof(TW_Sector));
2936 command_packet->byte0.opcode = TW_OP_GET_PARAM;
2937 command_packet->byte0.sgl_offset = 2;
2938 command_packet->size = 4;
2939 command_packet->request_id = request_id;
2940 command_packet->byte3.unit = tw_dev->srb[request_id]->device->id;
2941 command_packet->byte3.host_id = 0;
2942 command_packet->status = 0;
2943 command_packet->flags = 0;
2944 command_packet->byte6.block_count = 1;
2946 /* Now setup the param */
2947 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
2948 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n");
2951 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2952 memset(param, 0, sizeof(TW_Sector));
2953 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE +
2954 tw_dev->srb[request_id]->device->id;
2955 param->parameter_id = 4; /* unitcapacity parameter */
2956 param->parameter_size_bytes = 4;
2957 param_value = tw_dev->alignment_physical_address[request_id];
2958 if (param_value == 0) {
2959 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n");
2963 command_packet->byte8.param.sgl[0].address = param_value;
2964 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2965 command_que_value = tw_dev->command_packet_physical_address[request_id];
2966 if (command_que_value == 0) {
2967 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n");
2971 /* Now try to post the command to the board */
2972 tw_post_command_packet(tw_dev, request_id);
2975 } /* End tw_scsiop_read_capacity() */
2977 /* This function is called by the isr to complete a readcapacity command */
2978 int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id)
2980 unsigned char *param_data;
2985 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n");
2987 buff = tw_dev->srb[request_id]->request_buffer;
2989 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Request buffer NULL.\n");
2992 memset(buff, 0, tw_dev->srb[request_id]->request_bufflen);
2993 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2994 if (param == NULL) {
2995 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n");
2998 param_data = &(param->data[0]);
3000 capacity = (param_data[3] << 24) | (param_data[2] << 16) |
3001 (param_data[1] << 8) | param_data[0];
3003 /* Subtract one sector to fix get last sector ioctl */
3006 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity);
3008 /* Number of LBA's */
3009 buff[0] = (capacity >> 24);
3010 buff[1] = (capacity >> 16) & 0xff;
3011 buff[2] = (capacity >> 8) & 0xff;
3012 buff[3] = capacity & 0xff;
3014 /* Block size in bytes (512) */
3015 buff[4] = (TW_BLOCK_SIZE >> 24);
3016 buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff;
3017 buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff;
3018 buff[7] = TW_BLOCK_SIZE & 0xff;
3021 } /* End tw_scsiop_read_capacity_complete() */
3023 /* This function handles scsi read or write commands */
3024 int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id)
3026 TW_Command *command_packet;
3027 unsigned long command_que_value;
3028 u32 command_que_addr = 0x0;
3029 u32 lba = 0x0, num_sectors = 0x0, buffaddr = 0x0;
3032 struct scatterlist *sglist;
3034 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n");
3036 if (tw_dev->srb[request_id]->request_buffer == NULL) {
3037 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n");
3040 sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
3041 srb = tw_dev->srb[request_id];
3043 /* Initialize command packet */
3044 command_que_addr = tw_dev->registers.command_que_addr;
3045 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3046 if (command_packet == NULL) {
3047 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n");
3051 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) {
3052 command_packet->byte0.opcode = TW_OP_READ;
3054 command_packet->byte0.opcode = TW_OP_WRITE;
3057 command_packet->byte0.sgl_offset = 3;
3058 command_packet->size = 3;
3059 command_packet->request_id = request_id;
3060 command_packet->byte3.unit = srb->device->id;
3061 command_packet->byte3.host_id = 0;
3062 command_packet->status = 0;
3063 command_packet->flags = 0;
3065 if (srb->cmnd[0] == WRITE_10) {
3066 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10))
3067 command_packet->flags = 1;
3070 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) {
3071 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3];
3072 num_sectors = (u32)srb->cmnd[4];
3074 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5];
3075 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
3078 /* Update sector statistic */
3079 tw_dev->sector_count = num_sectors;
3080 if (tw_dev->sector_count > tw_dev->max_sector_count)
3081 tw_dev->max_sector_count = tw_dev->sector_count;
3083 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors);
3084 command_packet->byte8.io.lba = lba;
3085 command_packet->byte6.block_count = num_sectors;
3087 /* Do this if there are no sg list entries */
3088 if (tw_dev->srb[request_id]->use_sg == 0) {
3089 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): SG = 0\n");
3090 buffaddr = tw_map_scsi_single_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
3094 command_packet->byte8.io.sgl[0].address = buffaddr;
3095 command_packet->byte8.io.sgl[0].length = tw_dev->srb[request_id]->request_bufflen;
3096 command_packet->size+=2;
3099 /* Do this if we have multiple sg list entries */
3100 if (tw_dev->srb[request_id]->use_sg > 0) {
3101 use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
3105 for (i=0;i<use_sg; i++) {
3106 command_packet->byte8.io.sgl[i].address = sg_dma_address(&sglist[i]);
3107 command_packet->byte8.io.sgl[i].length = sg_dma_len(&sglist[i]);
3108 command_packet->size+=2;
3112 /* Update SG statistics */
3113 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg;
3114 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
3115 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
3117 command_que_value = tw_dev->command_packet_physical_address[request_id];
3118 if (command_que_value == 0) {
3119 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n");
3123 /* Now try to post the command to the board */
3124 tw_post_command_packet(tw_dev, request_id);
3127 } /* End tw_scsiop_read_write() */
3129 /* This function will handle the request sense scsi command */
3130 int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id)
3132 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n");
3134 /* For now we just zero the request buffer */
3135 memset(tw_dev->srb[request_id]->request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
3136 tw_dev->state[request_id] = TW_S_COMPLETED;
3137 tw_state_request_finish(tw_dev, request_id);
3139 /* If we got a request_sense, we probably want a reset, return error */
3140 tw_dev->srb[request_id]->result = (DID_ERROR << 16);
3141 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
3144 } /* End tw_scsiop_request_sense() */
3146 /* This function will handle synchronize cache scsi command */
3147 int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id)
3149 TW_Command *command_packet;
3150 unsigned long command_que_value;
3152 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n");
3154 /* Send firmware flush command for this unit */
3155 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3156 if (command_packet == NULL) {
3157 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n");
3161 /* Setup the command packet */
3162 memset(command_packet, 0, sizeof(TW_Sector));
3163 command_packet->byte0.opcode = TW_OP_FLUSH_CACHE;
3164 command_packet->byte0.sgl_offset = 0;
3165 command_packet->size = 2;
3166 command_packet->request_id = request_id;
3167 command_packet->byte3.unit = tw_dev->srb[request_id]->device->id;
3168 command_packet->byte3.host_id = 0;
3169 command_packet->status = 0;
3170 command_packet->flags = 0;
3171 command_packet->byte6.parameter_count = 1;
3172 command_que_value = tw_dev->command_packet_physical_address[request_id];
3173 if (command_que_value == 0) {
3174 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n");
3178 /* Now try to post the command packet */
3179 tw_post_command_packet(tw_dev, request_id);
3182 } /* End tw_scsiop_synchronize_cache() */
3184 /* This function will handle test unit ready scsi command */
3185 int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id)
3188 TW_Command *command_packet;
3189 unsigned long command_que_value;
3190 u32 command_que_addr;
3191 unsigned long param_value;
3193 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n");
3195 /* Initialize command packet */
3196 command_que_addr = tw_dev->registers.command_que_addr;
3197 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3198 if (command_packet == NULL) {
3199 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n");
3202 memset(command_packet, 0, sizeof(TW_Sector));
3203 command_packet->byte0.opcode = TW_OP_GET_PARAM;
3204 command_packet->byte0.sgl_offset = 2;
3205 command_packet->size = 4;
3206 command_packet->request_id = request_id;
3207 command_packet->byte3.unit = 0;
3208 command_packet->byte3.host_id = 0;
3209 command_packet->status = 0;
3210 command_packet->flags = 0;
3211 command_packet->byte6.parameter_count = 1;
3213 /* Now setup the param */
3214 if (tw_dev->alignment_virtual_address[request_id] == NULL) {
3215 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n");
3218 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
3219 memset(param, 0, sizeof(TW_Sector));
3220 param->table_id = 3; /* unit summary table */
3221 param->parameter_id = 3; /* unitsstatus parameter */
3222 param->parameter_size_bytes = TW_MAX_UNITS;
3223 param_value = tw_dev->alignment_physical_address[request_id];
3224 if (param_value == 0) {
3225 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n");
3229 command_packet->byte8.param.sgl[0].address = param_value;
3230 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
3231 command_que_value = tw_dev->command_packet_physical_address[request_id];
3232 if (command_que_value == 0) {
3233 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n");
3237 /* Now try to post the command packet */
3238 tw_post_command_packet(tw_dev, request_id);
3241 } /* End tw_scsiop_test_unit_ready() */
3243 /* This function is called by the isr to complete a testunitready command */
3244 int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id)
3246 unsigned char *is_unit_present;
3249 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n");
3251 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
3252 if (param == NULL) {
3253 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n");
3256 is_unit_present = &(param->data[0]);
3258 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
3259 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = TRUE;
3261 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = FALSE;
3262 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
3263 return TW_ISR_DONT_RESULT;
3267 } /* End tw_scsiop_test_unit_ready_complete() */
3269 /* Set a value in the features table */
3270 int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size,
3274 TW_Command *command_packet;
3275 TW_Response_Queue response_queue;
3277 unsigned long command_que_value;
3278 u32 command_que_addr;
3279 u32 response_que_addr;
3280 unsigned long param_value;
3282 /* Initialize SetParam command packet */
3283 if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
3284 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n");
3287 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3288 memset(command_packet, 0, sizeof(TW_Sector));
3289 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
3291 command_packet->byte0.opcode = TW_OP_SET_PARAM;
3292 command_packet->byte0.sgl_offset = 2;
3293 param->table_id = 0x404; /* Features table */
3294 param->parameter_id = parm;
3295 param->parameter_size_bytes = param_size;
3296 memcpy(param->data, val, param_size);
3298 param_value = tw_dev->alignment_physical_address[request_id];
3299 if (param_value == 0) {
3300 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad alignment physical address.\n");
3301 tw_dev->state[request_id] = TW_S_COMPLETED;
3302 tw_state_request_finish(tw_dev, request_id);
3303 tw_dev->srb[request_id]->result = (DID_OK << 16);
3304 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
3306 command_packet->byte8.param.sgl[0].address = param_value;
3307 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
3309 command_packet->size = 4;
3310 command_packet->request_id = request_id;
3311 command_packet->byte6.parameter_count = 1;
3313 command_que_value = tw_dev->command_packet_physical_address[request_id];
3314 if (command_que_value == 0) {
3315 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n");
3318 command_que_addr = tw_dev->registers.command_que_addr;
3319 response_que_addr = tw_dev->registers.response_que_addr;
3321 /* Send command packet to the board */
3322 outl(command_que_value, command_que_addr);
3324 /* Poll for completion */
3325 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
3326 response_queue.value = inl(response_que_addr);
3327 request_id = (unsigned char)response_queue.u.response_id;
3328 if (request_id != 0) {
3329 /* unexpected request id */
3330 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n");
3333 if (command_packet->status != 0) {
3335 tw_decode_sense(tw_dev, request_id, 0);
3341 } /* End tw_setfeature() */
3343 /* This function will setup the interrupt handler */
3344 int tw_setup_irq(TW_Device_Extension *tw_dev)
3346 char *device = TW_DEVICE_NAME;
3349 dprintk(KERN_NOTICE "3w-xxxx: tw_setup_irq()\n");
3350 error = request_irq(tw_dev->tw_pci_dev->irq, tw_interrupt, SA_SHIRQ, device, tw_dev);
3353 printk(KERN_WARNING "3w-xxxx: scsi%d: Error requesting IRQ: %d.\n", tw_dev->host->host_no, tw_dev->tw_pci_dev->irq);
3357 } /* End tw_setup_irq() */
3359 /* This function will tell the controller we're shutting down by sending
3360 initconnection with a 1 */
3361 int tw_shutdown_device(TW_Device_Extension *tw_dev)
3365 /* Disable interrupts */
3366 tw_disable_interrupts(tw_dev);
3368 /* poke the board */
3369 error = tw_initconnection(tw_dev, 1);
3371 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection shutdown failed.\n", tw_dev->host->host_no);
3373 printk(KERN_NOTICE "3w-xxxx: Shutdown complete.\n");
3376 /* Re-enable interrupts */
3377 tw_enable_and_clear_interrupts(tw_dev);
3380 } /* End tw_shutdown_device() */
3382 /* This function will configure individual target parameters */
3383 int tw_slave_configure(Scsi_Device *SDptr)
3387 dprintk(KERN_WARNING "3w-xxxx: tw_slave_configure()\n");
3389 #ifdef CONFIG_3W_XXXX_CMD_PER_LUN
3390 max_cmds = CONFIG_3W_XXXX_CMD_PER_LUN;
3391 if (max_cmds > TW_MAX_CMDS_PER_LUN)
3392 max_cmds = TW_MAX_CMDS_PER_LUN;
3394 max_cmds = TW_MAX_CMDS_PER_LUN;
3396 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, max_cmds);
3399 } /* End tw_slave_configure() */
3401 /* This function will soft reset the controller */
3402 void tw_soft_reset(TW_Device_Extension *tw_dev)
3404 u32 control_reg_addr, control_reg_value;
3406 control_reg_addr = tw_dev->registers.control_reg_addr;
3407 control_reg_value = ( TW_CONTROL_ISSUE_SOFT_RESET |
3408 TW_CONTROL_CLEAR_HOST_INTERRUPT |
3409 TW_CONTROL_CLEAR_ATTENTION_INTERRUPT |
3410 TW_CONTROL_MASK_COMMAND_INTERRUPT |
3411 TW_CONTROL_MASK_RESPONSE_INTERRUPT |
3412 TW_CONTROL_CLEAR_ERROR_STATUS |
3413 TW_CONTROL_DISABLE_INTERRUPTS);
3414 outl(control_reg_value, control_reg_addr);
3415 } /* End tw_soft_reset() */
3417 /* This function will free a request_id */
3418 int tw_state_request_finish(TW_Device_Extension *tw_dev, int request_id)
3420 dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_finish()\n");
3422 tw_dev->free_queue[tw_dev->free_tail] = request_id;
3423 tw_dev->state[request_id] = TW_S_FINISHED;
3424 if (tw_dev->free_tail == tw_dev->free_wrap)
3425 tw_dev->free_tail = TW_Q_START;
3427 tw_dev->free_tail++;
3429 dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_finish(): Freeing request_id %d\n", request_id);
3432 } /* End tw_state_request_finish() */
3434 /* This function will assign an available request_id */
3435 int tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id)
3439 dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_start()\n");
3441 /* Obtain next free request_id */
3442 id = tw_dev->free_queue[tw_dev->free_head];
3443 if (tw_dev->free_head == tw_dev->free_wrap)
3444 tw_dev->free_head = TW_Q_START;
3446 tw_dev->free_head++;
3449 tw_dev->state[id] = TW_S_STARTED;
3451 dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_start(): id = %d.\n", id);
3453 } /* End tw_state_request_start() */
3455 static void tw_unmap_scsi_data(struct pci_dev *pdev, Scsi_Cmnd *cmd)
3457 int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
3459 dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n");
3461 switch(cmd->SCp.phase) {
3463 pci_unmap_page(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, dma_dir);
3466 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, dma_dir);
3469 } /* End tw_unmap_scsi_data() */
3471 /* This function will unmask the command interrupt on the controller */
3472 void tw_unmask_command_interrupt(TW_Device_Extension *tw_dev)
3474 u32 control_reg_addr, control_reg_value;
3476 control_reg_addr = tw_dev->registers.control_reg_addr;
3477 control_reg_value = TW_CONTROL_UNMASK_COMMAND_INTERRUPT;
3478 outl(control_reg_value, control_reg_addr);
3479 } /* End tw_unmask_command_interrupt() */
3481 static Scsi_Host_Template driver_template = {
3482 .proc_name = "3w-xxxx",
3483 .proc_info = tw_scsi_proc_info,
3484 .name = "3ware Storage Controller",
3485 .detect = tw_scsi_detect,
3486 .release = tw_scsi_release,
3487 .queuecommand = tw_scsi_queue,
3488 .eh_abort_handler = tw_scsi_eh_abort,
3489 .eh_host_reset_handler = tw_scsi_eh_reset,
3490 .bios_param = tw_scsi_biosparam,
3491 .can_queue = TW_Q_LENGTH-2,
3493 .sg_tablesize = TW_MAX_SGL_LENGTH,
3494 .max_sectors = TW_MAX_SECTORS,
3495 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
3496 .use_clustering = ENABLE_CLUSTERING,
3499 #include "scsi_module.c"