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