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