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