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