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