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