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