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