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