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