xref: /openbmc/linux/drivers/scsi/3w-xxxx.c (revision 2e2fe5ac)
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 */
tw_check_bits(u32 status_reg_value)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 */
tw_decode_bits(TW_Device_Extension * tw_dev,u32 status_reg_value,int print_host)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 */
tw_poll_status(TW_Device_Extension * tw_dev,u32 flag,int seconds)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 */
tw_poll_status_gone(TW_Device_Extension * tw_dev,u32 flag,int seconds)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 */
tw_post_command_packet(TW_Device_Extension * tw_dev,int request_id)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 */
tw_decode_sense(TW_Device_Extension * tw_dev,int request_id,int fill_sense)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) | SAM_STAT_CHECK_CONDITION;
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 */
tw_check_errors(TW_Device_Extension * tw_dev)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 */
tw_empty_response_que(TW_Device_Extension * tw_dev)461 static void tw_empty_response_que(TW_Device_Extension *tw_dev)
462 {
463 	u32 status_reg_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 		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 */
tw_state_request_finish(TW_Device_Extension * tw_dev,int 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 */
tw_state_request_start(TW_Device_Extension * tw_dev,int * 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 */
tw_show_stats(struct device * dev,struct device_attribute * attr,char * buf)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 attribute *tw_host_attrs[] = {
536 	&tw_host_stats_attr.attr,
537 	NULL,
538 };
539 
540 ATTRIBUTE_GROUPS(tw_host);
541 
542 /* This function will read the aen queue from the isr */
tw_aen_read_queue(TW_Device_Extension * tw_dev,int request_id)543 static int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
544 {
545 	TW_Command *command_packet;
546 	TW_Param *param;
547 	unsigned long command_que_value;
548 	u32 status_reg_value;
549 	unsigned long param_value = 0;
550 
551 	dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n");
552 
553 	status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
554 	if (tw_check_bits(status_reg_value)) {
555 		dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n");
556 		tw_decode_bits(tw_dev, status_reg_value, 1);
557 		return 1;
558 	}
559 	if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
560 		printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n");
561 		return 1;
562 	}
563 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
564 	memset(command_packet, 0, sizeof(TW_Sector));
565 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
566 	command_packet->size = 4;
567 	command_packet->request_id = request_id;
568 	command_packet->status = 0;
569 	command_packet->flags = 0;
570 	command_packet->byte6.parameter_count = 1;
571 	command_que_value = tw_dev->command_packet_physical_address[request_id];
572 	if (command_que_value == 0) {
573 		printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n");
574 		return 1;
575 	}
576 	/* Now setup the param */
577 	if (tw_dev->alignment_virtual_address[request_id] == NULL) {
578 		printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n");
579 		return 1;
580 	}
581 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
582 	memset(param, 0, sizeof(TW_Sector));
583 	param->table_id = 0x401; /* AEN table */
584 	param->parameter_id = 2; /* Unit code */
585 	param->parameter_size_bytes = 2;
586 	param_value = tw_dev->alignment_physical_address[request_id];
587 	if (param_value == 0) {
588 		printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n");
589 		return 1;
590 	}
591 	command_packet->byte8.param.sgl[0].address = param_value;
592 	command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
593 
594 	/* Now post the command packet */
595 	if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
596 		dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n");
597 		tw_dev->srb[request_id] = NULL; /* Flag internal command */
598 		tw_dev->state[request_id] = TW_S_POSTED;
599 		outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
600 	} else {
601 		printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n");
602 		return 1;
603 	}
604 
605 	return 0;
606 } /* End tw_aen_read_queue() */
607 
608 /* This function will complete an aen request from the isr */
tw_aen_complete(TW_Device_Extension * tw_dev,int request_id)609 static int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id)
610 {
611 	TW_Param *param;
612 	unsigned short aen;
613 	int error = 0, table_max = 0;
614 
615 	dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n");
616 	if (tw_dev->alignment_virtual_address[request_id] == NULL) {
617 		printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n");
618 		return 1;
619 	}
620 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
621 	aen = *(unsigned short *)(param->data);
622 	dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen);
623 
624 	/* Print some useful info when certain aen codes come out */
625 	if (aen == 0x0ff) {
626 		printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no);
627 	} else {
628 		table_max = ARRAY_SIZE(tw_aen_string);
629 		if ((aen & 0x0ff) < table_max) {
630 			if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
631 				printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8);
632 			} else {
633 				if (aen != 0x0)
634 					printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]);
635 			}
636 		} else {
637 			printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen);
638 		}
639 	}
640 	if (aen != TW_AEN_QUEUE_EMPTY) {
641 		tw_dev->aen_count++;
642 
643 		/* Now queue the code */
644 		tw_dev->aen_queue[tw_dev->aen_tail] = aen;
645 		if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
646 			tw_dev->aen_tail = TW_Q_START;
647 		} else {
648 			tw_dev->aen_tail = tw_dev->aen_tail + 1;
649 		}
650 		if (tw_dev->aen_head == tw_dev->aen_tail) {
651 			if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
652 				tw_dev->aen_head = TW_Q_START;
653 			} else {
654 				tw_dev->aen_head = tw_dev->aen_head + 1;
655 			}
656 		}
657 
658 		error = tw_aen_read_queue(tw_dev, request_id);
659 		if (error) {
660 			printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no);
661 			tw_dev->state[request_id] = TW_S_COMPLETED;
662 			tw_state_request_finish(tw_dev, request_id);
663 		}
664 	} else {
665 		tw_dev->state[request_id] = TW_S_COMPLETED;
666 		tw_state_request_finish(tw_dev, request_id);
667 	}
668 
669 	return 0;
670 } /* End tw_aen_complete() */
671 
672 /* This function will drain the aen queue after a soft reset */
tw_aen_drain_queue(TW_Device_Extension * tw_dev)673 static int tw_aen_drain_queue(TW_Device_Extension *tw_dev)
674 {
675 	TW_Command *command_packet;
676 	TW_Param *param;
677 	int request_id = 0;
678 	unsigned long command_que_value;
679 	unsigned long param_value;
680 	TW_Response_Queue response_queue;
681 	unsigned short aen;
682 	unsigned short aen_code;
683 	int finished = 0;
684 	int first_reset = 0;
685 	int queue = 0;
686 	int found = 0, table_max = 0;
687 
688 	dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n");
689 
690 	if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) {
691 		dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count);
692 		return 1;
693 	}
694 	TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
695 
696 	/* Empty response queue */
697 	tw_empty_response_que(tw_dev);
698 
699 	/* Initialize command packet */
700 	if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
701 		printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n");
702 		return 1;
703 	}
704 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
705 	memset(command_packet, 0, sizeof(TW_Sector));
706 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
707 	command_packet->size = 4;
708 	command_packet->request_id = request_id;
709 	command_packet->status = 0;
710 	command_packet->flags = 0;
711 	command_packet->byte6.parameter_count = 1;
712 	command_que_value = tw_dev->command_packet_physical_address[request_id];
713 	if (command_que_value == 0) {
714 		printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n");
715 		return 1;
716 	}
717 
718 	/* Now setup the param */
719 	if (tw_dev->alignment_virtual_address[request_id] == NULL) {
720 		printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n");
721 		return 1;
722 	}
723 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
724 	memset(param, 0, sizeof(TW_Sector));
725 	param->table_id = 0x401; /* AEN table */
726 	param->parameter_id = 2; /* Unit code */
727 	param->parameter_size_bytes = 2;
728 	param_value = tw_dev->alignment_physical_address[request_id];
729 	if (param_value == 0) {
730 		printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n");
731 		return 1;
732 	}
733 	command_packet->byte8.param.sgl[0].address = param_value;
734 	command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
735 
736 	/* Now drain the controller's aen queue */
737 	do {
738 		/* Post command packet */
739 		outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
740 
741 		/* Now poll for completion */
742 		if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
743 			response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
744 			request_id = TW_RESID_OUT(response_queue.response_id);
745 
746 			if (request_id != 0) {
747 				/* Unexpected request id */
748 				printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n");
749 				return 1;
750 			}
751 
752 			if (command_packet->status != 0) {
753 				if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) {
754 					/* Bad response */
755 					tw_decode_sense(tw_dev, request_id, 0);
756 					return 1;
757 				} else {
758 					/* We know this is a 3w-1x00, and doesn't support aen's */
759 					return 0;
760 				}
761 			}
762 
763 			/* Now check the aen */
764 			aen = *(unsigned short *)(param->data);
765 			aen_code = (aen & 0x0ff);
766 			queue = 0;
767 			switch (aen_code) {
768 				case TW_AEN_QUEUE_EMPTY:
769 					dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
770 					if (first_reset != 1) {
771 						return 1;
772 					} else {
773 						finished = 1;
774 					}
775 					break;
776 				case TW_AEN_SOFT_RESET:
777 					if (first_reset == 0) {
778 						first_reset = 1;
779 					} else {
780 						printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
781 						tw_dev->aen_count++;
782 						queue = 1;
783 					}
784 					break;
785 				default:
786 					if (aen == 0x0ff) {
787 						printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n");
788 					} else {
789 						table_max = ARRAY_SIZE(tw_aen_string);
790 						if ((aen & 0x0ff) < table_max) {
791 							if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
792 								printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8);
793 							} else {
794 								printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
795 							}
796 						} else
797 							printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen);
798 					}
799 					tw_dev->aen_count++;
800 					queue = 1;
801 			}
802 
803 			/* Now put the aen on the aen_queue */
804 			if (queue == 1) {
805 				tw_dev->aen_queue[tw_dev->aen_tail] = aen;
806 				if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
807 					tw_dev->aen_tail = TW_Q_START;
808 				} else {
809 					tw_dev->aen_tail = tw_dev->aen_tail + 1;
810 				}
811 				if (tw_dev->aen_head == tw_dev->aen_tail) {
812 					if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
813 						tw_dev->aen_head = TW_Q_START;
814 					} else {
815 						tw_dev->aen_head = tw_dev->aen_head + 1;
816 					}
817 				}
818 			}
819 			found = 1;
820 		}
821 		if (found == 0) {
822 			printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n");
823 			return 1;
824 		}
825 	} while (finished == 0);
826 
827 	return 0;
828 } /* End tw_aen_drain_queue() */
829 
830 /* This function will allocate memory */
tw_allocate_memory(TW_Device_Extension * tw_dev,int size,int which)831 static int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
832 {
833 	int i;
834 	dma_addr_t dma_handle;
835 	unsigned long *cpu_addr = NULL;
836 
837 	dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");
838 
839 	cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
840 			size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
841 	if (cpu_addr == NULL) {
842 		printk(KERN_WARNING "3w-xxxx: dma_alloc_coherent() failed.\n");
843 		return 1;
844 	}
845 
846 	if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {
847 		printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");
848 		dma_free_coherent(&tw_dev->tw_pci_dev->dev, size * TW_Q_LENGTH,
849 				cpu_addr, dma_handle);
850 		return 1;
851 	}
852 
853 	memset(cpu_addr, 0, size*TW_Q_LENGTH);
854 
855 	for (i=0;i<TW_Q_LENGTH;i++) {
856 		switch(which) {
857 		case 0:
858 			tw_dev->command_packet_physical_address[i] = dma_handle+(i*size);
859 			tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
860 			break;
861 		case 1:
862 			tw_dev->alignment_physical_address[i] = dma_handle+(i*size);
863 			tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
864 			break;
865 		default:
866 			printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n");
867 			return 1;
868 		}
869 	}
870 
871 	return 0;
872 } /* End tw_allocate_memory() */
873 
874 /* This function handles ioctl for the character device */
tw_chrdev_ioctl(struct file * file,unsigned int cmd,unsigned long arg)875 static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
876 {
877 	int request_id;
878 	dma_addr_t dma_handle;
879 	unsigned short tw_aen_code;
880 	unsigned long flags;
881 	unsigned int data_buffer_length = 0;
882 	unsigned long data_buffer_length_adjusted = 0;
883 	struct inode *inode = file_inode(file);
884 	unsigned long *cpu_addr;
885 	long timeout;
886 	TW_New_Ioctl *tw_ioctl;
887 	TW_Passthru *passthru;
888 	TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)];
889 	int retval = -EFAULT;
890 	void __user *argp = (void __user *)arg;
891 
892 	dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
893 
894 	mutex_lock(&tw_mutex);
895 	/* Only let one of these through at a time */
896 	if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
897 		mutex_unlock(&tw_mutex);
898 		return -EINTR;
899 	}
900 
901 	/* First copy down the buffer length */
902 	if (copy_from_user(&data_buffer_length, argp, sizeof(unsigned int)))
903 		goto out;
904 
905 	/* Check size */
906 	if (data_buffer_length > TW_MAX_IOCTL_SECTORS * 512) {
907 		retval = -EINVAL;
908 		goto out;
909 	}
910 
911 	/* Hardware can only do multiple of 512 byte transfers */
912 	data_buffer_length_adjusted = (data_buffer_length + 511) & ~511;
913 
914 	/* Now allocate ioctl buf memory */
915 	cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted + sizeof(TW_New_Ioctl), &dma_handle, GFP_KERNEL);
916 	if (cpu_addr == NULL) {
917 		retval = -ENOMEM;
918 		goto out;
919 	}
920 
921 	tw_ioctl = (TW_New_Ioctl *)cpu_addr;
922 
923 	/* Now copy down the entire ioctl */
924 	if (copy_from_user(tw_ioctl, argp, data_buffer_length + sizeof(TW_New_Ioctl)))
925 		goto out2;
926 
927 	passthru = (TW_Passthru *)&tw_ioctl->firmware_command;
928 
929 	/* See which ioctl we are doing */
930 	switch (cmd) {
931 		case TW_OP_NOP:
932 			dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n");
933 			break;
934 		case TW_OP_AEN_LISTEN:
935 			dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n");
936 			memset(tw_ioctl->data_buffer, 0, data_buffer_length);
937 
938 			spin_lock_irqsave(tw_dev->host->host_lock, flags);
939 			if (tw_dev->aen_head == tw_dev->aen_tail) {
940 				tw_aen_code = TW_AEN_QUEUE_EMPTY;
941 			} else {
942 				tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
943 				if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
944 					tw_dev->aen_head = TW_Q_START;
945 				} else {
946 					tw_dev->aen_head = tw_dev->aen_head + 1;
947 				}
948 			}
949 			spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
950 			memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code));
951 			break;
952 		case TW_CMD_PACKET_WITH_DATA:
953 			dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
954 			spin_lock_irqsave(tw_dev->host->host_lock, flags);
955 
956 			tw_state_request_start(tw_dev, &request_id);
957 
958 			/* Flag internal command */
959 			tw_dev->srb[request_id] = NULL;
960 
961 			/* Flag chrdev ioctl */
962 			tw_dev->chrdev_request_id = request_id;
963 
964 			tw_ioctl->firmware_command.request_id = request_id;
965 
966 			/* Load the sg list */
967 			switch (TW_SGL_OUT(tw_ioctl->firmware_command.opcode__sgloffset)) {
968 			case 2:
969 				tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl);
970 				tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted;
971 				break;
972 			case 3:
973 				tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl);
974 				tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted;
975 				break;
976 			case 5:
977 				passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl);
978 				passthru->sg_list[0].length = data_buffer_length_adjusted;
979 				break;
980 			}
981 
982 			memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command));
983 
984 			/* Now post the command packet to the controller */
985 			tw_post_command_packet(tw_dev, request_id);
986 			spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
987 
988 			timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
989 
990 			/* Now wait for the command to complete */
991 			timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
992 
993 			/* We timed out, and didn't get an interrupt */
994 			if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
995 				/* Now we need to reset the board */
996 				printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd);
997 				retval = -EIO;
998 				if (tw_reset_device_extension(tw_dev)) {
999 					printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no);
1000 				}
1001 				goto out2;
1002 			}
1003 
1004 			/* Now copy in the command packet response */
1005 			memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
1006 
1007 			/* Now complete the io */
1008 			spin_lock_irqsave(tw_dev->host->host_lock, flags);
1009 			tw_dev->posted_request_count--;
1010 			tw_dev->state[request_id] = TW_S_COMPLETED;
1011 			tw_state_request_finish(tw_dev, request_id);
1012 			spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1013 			break;
1014 		default:
1015 			retval = -ENOTTY;
1016 			goto out2;
1017 	}
1018 
1019 	/* Now copy the response to userspace */
1020 	if (copy_to_user(argp, tw_ioctl, sizeof(TW_New_Ioctl) + data_buffer_length))
1021 		goto out2;
1022 	retval = 0;
1023 out2:
1024 	/* Now free ioctl buf memory */
1025 	dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted + sizeof(TW_New_Ioctl), cpu_addr, dma_handle);
1026 out:
1027 	mutex_unlock(&tw_dev->ioctl_lock);
1028 	mutex_unlock(&tw_mutex);
1029 	return retval;
1030 } /* End tw_chrdev_ioctl() */
1031 
1032 /* This function handles open for the character device */
1033 /* NOTE that this function races with remove. */
tw_chrdev_open(struct inode * inode,struct file * file)1034 static int tw_chrdev_open(struct inode *inode, struct file *file)
1035 {
1036 	unsigned int minor_number;
1037 
1038 	dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n");
1039 
1040 	if (!capable(CAP_SYS_ADMIN))
1041 		return -EACCES;
1042 
1043 	minor_number = iminor(inode);
1044 	if (minor_number >= tw_device_extension_count)
1045 		return -ENODEV;
1046 
1047 	return 0;
1048 } /* End tw_chrdev_open() */
1049 
1050 /* File operations struct for character device */
1051 static const struct file_operations tw_fops = {
1052 	.owner		= THIS_MODULE,
1053 	.unlocked_ioctl	= tw_chrdev_ioctl,
1054 	.compat_ioctl   = compat_ptr_ioctl,
1055 	.open		= tw_chrdev_open,
1056 	.release	= NULL,
1057 	.llseek		= noop_llseek,
1058 };
1059 
1060 /* This function will free up device extension resources */
tw_free_device_extension(TW_Device_Extension * tw_dev)1061 static void tw_free_device_extension(TW_Device_Extension *tw_dev)
1062 {
1063 	dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n");
1064 
1065 	/* Free command packet and generic buffer memory */
1066 	if (tw_dev->command_packet_virtual_address[0])
1067 		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1068 				sizeof(TW_Command) * TW_Q_LENGTH,
1069 				tw_dev->command_packet_virtual_address[0],
1070 				tw_dev->command_packet_physical_address[0]);
1071 
1072 	if (tw_dev->alignment_virtual_address[0])
1073 		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1074 				sizeof(TW_Sector) * TW_Q_LENGTH,
1075 				tw_dev->alignment_virtual_address[0],
1076 				tw_dev->alignment_physical_address[0]);
1077 } /* End tw_free_device_extension() */
1078 
1079 /* This function will send an initconnection command to controller */
tw_initconnection(TW_Device_Extension * tw_dev,int message_credits)1080 static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits)
1081 {
1082 	unsigned long command_que_value;
1083 	TW_Command  *command_packet;
1084 	TW_Response_Queue response_queue;
1085 	int request_id = 0;
1086 
1087 	dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n");
1088 
1089 	/* Initialize InitConnection command packet */
1090 	if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1091 		printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n");
1092 		return 1;
1093 	}
1094 
1095 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1096 	memset(command_packet, 0, sizeof(TW_Sector));
1097 	command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION);
1098 	command_packet->size = TW_INIT_COMMAND_PACKET_SIZE;
1099 	command_packet->request_id = request_id;
1100 	command_packet->status = 0x0;
1101 	command_packet->flags = 0x0;
1102 	command_packet->byte6.message_credits = message_credits;
1103 	command_packet->byte8.init_connection.response_queue_pointer = 0x0;
1104 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1105 
1106 	if (command_que_value == 0) {
1107 		printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n");
1108 		return 1;
1109 	}
1110 
1111 	/* Send command packet to the board */
1112 	outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1113 
1114 	/* Poll for completion */
1115 	if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1116 		response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1117 		request_id = TW_RESID_OUT(response_queue.response_id);
1118 
1119 		if (request_id != 0) {
1120 			/* unexpected request id */
1121 			printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n");
1122 			return 1;
1123 		}
1124 		if (command_packet->status != 0) {
1125 			/* bad response */
1126 			tw_decode_sense(tw_dev, request_id, 0);
1127 			return 1;
1128 		}
1129 	}
1130 	return 0;
1131 } /* End tw_initconnection() */
1132 
1133 /* Set a value in the features table */
tw_setfeature(TW_Device_Extension * tw_dev,int parm,int param_size,unsigned char * val)1134 static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size,
1135 			 unsigned char *val)
1136 {
1137 	TW_Param *param;
1138 	TW_Command  *command_packet;
1139 	TW_Response_Queue response_queue;
1140 	int request_id = 0;
1141 	unsigned long command_que_value;
1142 	unsigned long param_value;
1143 
1144 	/* Initialize SetParam command packet */
1145 	if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1146 		printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n");
1147 		return 1;
1148 	}
1149 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1150 	memset(command_packet, 0, sizeof(TW_Sector));
1151 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1152 
1153 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
1154 	param->table_id = 0x404;  /* Features table */
1155 	param->parameter_id = parm;
1156 	param->parameter_size_bytes = param_size;
1157 	memcpy(param->data, val, param_size);
1158 
1159 	param_value = tw_dev->alignment_physical_address[request_id];
1160 	if (param_value == 0) {
1161 		printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n");
1162 		tw_dev->state[request_id] = TW_S_COMPLETED;
1163 		tw_state_request_finish(tw_dev, request_id);
1164 		tw_dev->srb[request_id]->result = (DID_OK << 16);
1165 		scsi_done(tw_dev->srb[request_id]);
1166 	}
1167 	command_packet->byte8.param.sgl[0].address = param_value;
1168 	command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1169 
1170 	command_packet->size = 4;
1171 	command_packet->request_id = request_id;
1172 	command_packet->byte6.parameter_count = 1;
1173 
1174 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1175 	if (command_que_value == 0) {
1176 		printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n");
1177 		return 1;
1178 	}
1179 
1180 	/* Send command packet to the board */
1181 	outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1182 
1183 	/* Poll for completion */
1184 	if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1185 		response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1186 		request_id = TW_RESID_OUT(response_queue.response_id);
1187 
1188 		if (request_id != 0) {
1189 			/* unexpected request id */
1190 			printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n");
1191 			return 1;
1192 		}
1193 		if (command_packet->status != 0) {
1194 			/* bad response */
1195 			tw_decode_sense(tw_dev, request_id, 0);
1196 			return 1;
1197 		}
1198 	}
1199 
1200 	return 0;
1201 } /* End tw_setfeature() */
1202 
1203 /* This function will reset a controller */
tw_reset_sequence(TW_Device_Extension * tw_dev)1204 static int tw_reset_sequence(TW_Device_Extension *tw_dev)
1205 {
1206 	int error = 0;
1207 	int tries = 0;
1208 	unsigned char c = 1;
1209 
1210 	/* Reset the board */
1211 	while (tries < TW_MAX_RESET_TRIES) {
1212 		TW_SOFT_RESET(tw_dev);
1213 
1214 		error = tw_aen_drain_queue(tw_dev);
1215 		if (error) {
1216 			printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no);
1217 			tries++;
1218 			continue;
1219 		}
1220 
1221 		/* Check for controller errors */
1222 		if (tw_check_errors(tw_dev)) {
1223 			printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no);
1224 			tries++;
1225 			continue;
1226 		}
1227 
1228 		/* Now the controller is in a good state */
1229 		break;
1230 	}
1231 
1232 	if (tries >= TW_MAX_RESET_TRIES) {
1233 		printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no);
1234 		return 1;
1235 	}
1236 
1237 	error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
1238 	if (error) {
1239 		printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no);
1240 		return 1;
1241 	}
1242 
1243 	error = tw_setfeature(tw_dev, 2, 1, &c);
1244 	if (error) {
1245 		printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n");
1246 	}
1247 
1248 	return 0;
1249 } /* End tw_reset_sequence() */
1250 
1251 /* This function will initialize the fields of a device extension */
tw_initialize_device_extension(TW_Device_Extension * tw_dev)1252 static int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
1253 {
1254 	int i, error=0;
1255 
1256 	dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n");
1257 
1258 	/* Initialize command packet buffers */
1259 	error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0);
1260 	if (error) {
1261 		printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n");
1262 		return 1;
1263 	}
1264 
1265 	/* Initialize generic buffer */
1266 	error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1);
1267 	if (error) {
1268 		printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n");
1269 		return 1;
1270 	}
1271 
1272 	for (i=0;i<TW_Q_LENGTH;i++) {
1273 		tw_dev->free_queue[i] = i;
1274 		tw_dev->state[i] = TW_S_INITIAL;
1275 	}
1276 
1277 	tw_dev->pending_head = TW_Q_START;
1278 	tw_dev->pending_tail = TW_Q_START;
1279 	tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1280 
1281 	mutex_init(&tw_dev->ioctl_lock);
1282 	init_waitqueue_head(&tw_dev->ioctl_wqueue);
1283 
1284 	return 0;
1285 } /* End tw_initialize_device_extension() */
1286 
1287 /* This function will reset a device extension */
tw_reset_device_extension(TW_Device_Extension * tw_dev)1288 static int tw_reset_device_extension(TW_Device_Extension *tw_dev)
1289 {
1290 	int i = 0;
1291 	struct scsi_cmnd *srb;
1292 	unsigned long flags = 0;
1293 
1294 	dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n");
1295 
1296 	set_bit(TW_IN_RESET, &tw_dev->flags);
1297 	TW_DISABLE_INTERRUPTS(tw_dev);
1298 	TW_MASK_COMMAND_INTERRUPT(tw_dev);
1299 	spin_lock_irqsave(tw_dev->host->host_lock, flags);
1300 
1301 	/* Abort all requests that are in progress */
1302 	for (i=0;i<TW_Q_LENGTH;i++) {
1303 		if ((tw_dev->state[i] != TW_S_FINISHED) &&
1304 		    (tw_dev->state[i] != TW_S_INITIAL) &&
1305 		    (tw_dev->state[i] != TW_S_COMPLETED)) {
1306 			srb = tw_dev->srb[i];
1307 			if (srb != NULL) {
1308 				srb->result = (DID_RESET << 16);
1309 				scsi_dma_unmap(srb);
1310 				scsi_done(srb);
1311 			}
1312 		}
1313 	}
1314 
1315 	/* Reset queues and counts */
1316 	for (i=0;i<TW_Q_LENGTH;i++) {
1317 		tw_dev->free_queue[i] = i;
1318 		tw_dev->state[i] = TW_S_INITIAL;
1319 	}
1320 	tw_dev->free_head = TW_Q_START;
1321 	tw_dev->free_tail = TW_Q_START;
1322 	tw_dev->posted_request_count = 0;
1323 	tw_dev->pending_request_count = 0;
1324 	tw_dev->pending_head = TW_Q_START;
1325 	tw_dev->pending_tail = TW_Q_START;
1326 	tw_dev->reset_print = 0;
1327 
1328 	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1329 
1330 	if (tw_reset_sequence(tw_dev)) {
1331 		printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
1332 		return 1;
1333 	}
1334 
1335 	TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1336 	clear_bit(TW_IN_RESET, &tw_dev->flags);
1337 	tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1338 
1339 	return 0;
1340 } /* End tw_reset_device_extension() */
1341 
1342 /* This funciton returns unit geometry in cylinders/heads/sectors */
tw_scsi_biosparam(struct scsi_device * sdev,struct block_device * bdev,sector_t capacity,int geom[])1343 static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1344 			     sector_t capacity, int geom[])
1345 {
1346 	int heads, sectors, cylinders;
1347 
1348 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n");
1349 
1350 	heads = 64;
1351 	sectors = 32;
1352 	cylinders = sector_div(capacity, heads * sectors);
1353 
1354 	if (capacity >= 0x200000) {
1355 		heads = 255;
1356 		sectors = 63;
1357 		cylinders = sector_div(capacity, heads * sectors);
1358 	}
1359 
1360 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders);
1361 	geom[0] = heads;
1362 	geom[1] = sectors;
1363 	geom[2] = cylinders;
1364 
1365 	return 0;
1366 } /* End tw_scsi_biosparam() */
1367 
1368 /* This is the new scsi eh reset function */
tw_scsi_eh_reset(struct scsi_cmnd * SCpnt)1369 static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1370 {
1371 	TW_Device_Extension *tw_dev=NULL;
1372 	int retval = FAILED;
1373 
1374 	tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1375 
1376 	tw_dev->num_resets++;
1377 
1378 	sdev_printk(KERN_WARNING, SCpnt->device,
1379 		"WARNING: Command (0x%x) timed out, resetting card.\n",
1380 		SCpnt->cmnd[0]);
1381 
1382 	/* Make sure we are not issuing an ioctl or resetting from ioctl */
1383 	mutex_lock(&tw_dev->ioctl_lock);
1384 
1385 	/* Now reset the card and some of the device extension data */
1386 	if (tw_reset_device_extension(tw_dev)) {
1387 		printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no);
1388 		goto out;
1389 	}
1390 
1391 	retval = SUCCESS;
1392 out:
1393 	mutex_unlock(&tw_dev->ioctl_lock);
1394 	return retval;
1395 } /* End tw_scsi_eh_reset() */
1396 
1397 /* This function handles scsi inquiry commands */
tw_scsiop_inquiry(TW_Device_Extension * tw_dev,int request_id)1398 static int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id)
1399 {
1400 	TW_Param *param;
1401 	TW_Command *command_packet;
1402 	unsigned long command_que_value;
1403 	unsigned long param_value;
1404 
1405 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n");
1406 
1407 	/* Initialize command packet */
1408 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1409 	if (command_packet == NULL) {
1410 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n");
1411 		return 1;
1412 	}
1413 	memset(command_packet, 0, sizeof(TW_Sector));
1414 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1415 	command_packet->size = 4;
1416 	command_packet->request_id = request_id;
1417 	command_packet->status = 0;
1418 	command_packet->flags = 0;
1419 	command_packet->byte6.parameter_count = 1;
1420 
1421 	/* Now setup the param */
1422 	if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1423 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n");
1424 		return 1;
1425 	}
1426 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1427 	memset(param, 0, sizeof(TW_Sector));
1428 	param->table_id = 3;	 /* unit summary table */
1429 	param->parameter_id = 3; /* unitsstatus parameter */
1430 	param->parameter_size_bytes = TW_MAX_UNITS;
1431 	param_value = tw_dev->alignment_physical_address[request_id];
1432 	if (param_value == 0) {
1433 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n");
1434 		return 1;
1435 	}
1436 
1437 	command_packet->byte8.param.sgl[0].address = param_value;
1438 	command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1439 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1440 	if (command_que_value == 0) {
1441 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n");
1442 		return 1;
1443 	}
1444 
1445 	/* Now try to post the command packet */
1446 	tw_post_command_packet(tw_dev, request_id);
1447 
1448 	return 0;
1449 } /* End tw_scsiop_inquiry() */
1450 
tw_transfer_internal(TW_Device_Extension * tw_dev,int request_id,void * data,unsigned int len)1451 static void tw_transfer_internal(TW_Device_Extension *tw_dev, int request_id,
1452 				 void *data, unsigned int len)
1453 {
1454 	scsi_sg_copy_from_buffer(tw_dev->srb[request_id], data, len);
1455 }
1456 
1457 /* This function is called by the isr to complete an inquiry command */
tw_scsiop_inquiry_complete(TW_Device_Extension * tw_dev,int request_id)1458 static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id)
1459 {
1460 	unsigned char *is_unit_present;
1461 	unsigned char request_buffer[36];
1462 	TW_Param *param;
1463 
1464 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n");
1465 
1466 	memset(request_buffer, 0, sizeof(request_buffer));
1467 	request_buffer[0] = TYPE_DISK; /* Peripheral device type */
1468 	request_buffer[1] = 0;	       /* Device type modifier */
1469 	request_buffer[2] = 0;	       /* No ansi/iso compliance */
1470 	request_buffer[4] = 31;	       /* Additional length */
1471 	memcpy(&request_buffer[8], "3ware   ", 8);	 /* Vendor ID */
1472 	sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id);
1473 	memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3);
1474 	tw_transfer_internal(tw_dev, request_id, request_buffer,
1475 			     sizeof(request_buffer));
1476 
1477 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1478 	if (param == NULL) {
1479 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n");
1480 		return 1;
1481 	}
1482 	is_unit_present = &(param->data[0]);
1483 
1484 	if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1485 		tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1486 	} else {
1487 		tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1488 		tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1489 		return TW_ISR_DONT_RESULT;
1490 	}
1491 
1492 	return 0;
1493 } /* End tw_scsiop_inquiry_complete() */
1494 
1495 /* This function handles scsi mode_sense commands */
tw_scsiop_mode_sense(TW_Device_Extension * tw_dev,int request_id)1496 static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id)
1497 {
1498 	TW_Param *param;
1499 	TW_Command *command_packet;
1500 	unsigned long command_que_value;
1501 	unsigned long param_value;
1502 
1503 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n");
1504 
1505 	/* Only page control = 0, page code = 0x8 (cache page) supported */
1506 	if (tw_dev->srb[request_id]->cmnd[2] != 0x8) {
1507 		tw_dev->state[request_id] = TW_S_COMPLETED;
1508 		tw_state_request_finish(tw_dev, request_id);
1509 		tw_dev->srb[request_id]->result = (DID_OK << 16);
1510 		scsi_done(tw_dev->srb[request_id]);
1511 		return 0;
1512 	}
1513 
1514 	/* Now read firmware cache setting for this unit */
1515 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1516 	if (command_packet == NULL) {
1517 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n");
1518 		return 1;
1519 	}
1520 
1521 	/* Setup the command packet */
1522 	memset(command_packet, 0, sizeof(TW_Sector));
1523 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1524 	command_packet->size = 4;
1525 	command_packet->request_id = request_id;
1526 	command_packet->status = 0;
1527 	command_packet->flags = 0;
1528 	command_packet->byte6.parameter_count = 1;
1529 
1530 	/* Setup the param */
1531 	if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1532 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n");
1533 		return 1;
1534 	}
1535 
1536 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1537 	memset(param, 0, sizeof(TW_Sector));
1538 	param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id;
1539 	param->parameter_id = 7; /* unit flags */
1540 	param->parameter_size_bytes = 1;
1541 	param_value = tw_dev->alignment_physical_address[request_id];
1542 	if (param_value == 0) {
1543 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n");
1544 		return 1;
1545 	}
1546 
1547 	command_packet->byte8.param.sgl[0].address = param_value;
1548 	command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1549 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1550 	if (command_que_value == 0) {
1551 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n");
1552 		return 1;
1553 	}
1554 
1555 	/* Now try to post the command packet */
1556 	tw_post_command_packet(tw_dev, request_id);
1557 
1558 	return 0;
1559 } /* End tw_scsiop_mode_sense() */
1560 
1561 /* This function is called by the isr to complete a mode sense command */
tw_scsiop_mode_sense_complete(TW_Device_Extension * tw_dev,int request_id)1562 static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id)
1563 {
1564 	TW_Param *param;
1565 	unsigned char *flags;
1566 	unsigned char request_buffer[8];
1567 
1568 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n");
1569 
1570 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1571 	if (param == NULL) {
1572 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n");
1573 		return 1;
1574 	}
1575 	flags = (char *)&(param->data[0]);
1576 	memset(request_buffer, 0, sizeof(request_buffer));
1577 
1578 	request_buffer[0] = 0xf;	/* mode data length */
1579 	request_buffer[1] = 0;		/* default medium type */
1580 	request_buffer[2] = 0x10;	/* dpo/fua support on */
1581 	request_buffer[3] = 0;		/* no block descriptors */
1582 	request_buffer[4] = 0x8;	/* caching page */
1583 	request_buffer[5] = 0xa;	/* page length */
1584 	if (*flags & 0x1)
1585 		request_buffer[6] = 0x5;	/* WCE on, RCD on */
1586 	else
1587 		request_buffer[6] = 0x1;	/* WCE off, RCD on */
1588 	tw_transfer_internal(tw_dev, request_id, request_buffer,
1589 			     sizeof(request_buffer));
1590 
1591 	return 0;
1592 } /* End tw_scsiop_mode_sense_complete() */
1593 
1594 /* This function handles scsi read_capacity commands */
tw_scsiop_read_capacity(TW_Device_Extension * tw_dev,int request_id)1595 static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id)
1596 {
1597 	TW_Param *param;
1598 	TW_Command *command_packet;
1599 	unsigned long command_que_value;
1600 	unsigned long param_value;
1601 
1602 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n");
1603 
1604 	/* Initialize command packet */
1605 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1606 
1607 	if (command_packet == NULL) {
1608 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n");
1609 		return 1;
1610 	}
1611 	memset(command_packet, 0, sizeof(TW_Sector));
1612 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1613 	command_packet->size = 4;
1614 	command_packet->request_id = request_id;
1615 	command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1616 	command_packet->status = 0;
1617 	command_packet->flags = 0;
1618 	command_packet->byte6.block_count = 1;
1619 
1620 	/* Now setup the param */
1621 	if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1622 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n");
1623 		return 1;
1624 	}
1625 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1626 	memset(param, 0, sizeof(TW_Sector));
1627 	param->table_id = TW_UNIT_INFORMATION_TABLE_BASE +
1628 		tw_dev->srb[request_id]->device->id;
1629 	param->parameter_id = 4;	/* unitcapacity parameter */
1630 	param->parameter_size_bytes = 4;
1631 	param_value = tw_dev->alignment_physical_address[request_id];
1632 	if (param_value == 0) {
1633 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n");
1634 		return 1;
1635 	}
1636 
1637 	command_packet->byte8.param.sgl[0].address = param_value;
1638 	command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1639 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1640 	if (command_que_value == 0) {
1641 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n");
1642 		return 1;
1643 	}
1644 
1645 	/* Now try to post the command to the board */
1646 	tw_post_command_packet(tw_dev, request_id);
1647 
1648 	return 0;
1649 } /* End tw_scsiop_read_capacity() */
1650 
1651 /* This function is called by the isr to complete a readcapacity command */
tw_scsiop_read_capacity_complete(TW_Device_Extension * tw_dev,int request_id)1652 static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id)
1653 {
1654 	unsigned char *param_data;
1655 	u32 capacity;
1656 	char buff[8];
1657 	TW_Param *param;
1658 
1659 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n");
1660 
1661 	memset(buff, 0, sizeof(buff));
1662 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1663 	if (param == NULL) {
1664 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n");
1665 		return 1;
1666 	}
1667 	param_data = &(param->data[0]);
1668 
1669 	capacity = (param_data[3] << 24) | (param_data[2] << 16) |
1670 		   (param_data[1] << 8) | param_data[0];
1671 
1672 	/* Subtract one sector to fix get last sector ioctl */
1673 	capacity -= 1;
1674 
1675 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity);
1676 
1677 	/* Number of LBA's */
1678 	buff[0] = (capacity >> 24);
1679 	buff[1] = (capacity >> 16) & 0xff;
1680 	buff[2] = (capacity >> 8) & 0xff;
1681 	buff[3] = capacity & 0xff;
1682 
1683 	/* Block size in bytes (512) */
1684 	buff[4] = (TW_BLOCK_SIZE >> 24);
1685 	buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff;
1686 	buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff;
1687 	buff[7] = TW_BLOCK_SIZE & 0xff;
1688 
1689 	tw_transfer_internal(tw_dev, request_id, buff, sizeof(buff));
1690 
1691 	return 0;
1692 } /* End tw_scsiop_read_capacity_complete() */
1693 
1694 /* This function handles scsi read or write commands */
tw_scsiop_read_write(TW_Device_Extension * tw_dev,int request_id)1695 static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id)
1696 {
1697 	TW_Command *command_packet;
1698 	unsigned long command_que_value;
1699 	u32 lba = 0x0, num_sectors = 0x0;
1700 	int i, use_sg;
1701 	struct scsi_cmnd *srb;
1702 	struct scatterlist *sglist, *sg;
1703 
1704 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n");
1705 
1706 	srb = tw_dev->srb[request_id];
1707 
1708 	sglist = scsi_sglist(srb);
1709 	if (!sglist) {
1710 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n");
1711 		return 1;
1712 	}
1713 
1714 	/* Initialize command packet */
1715 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1716 	if (command_packet == NULL) {
1717 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n");
1718 		return 1;
1719 	}
1720 
1721 	if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) {
1722 		command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ);
1723 	} else {
1724 		command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE);
1725 	}
1726 
1727 	command_packet->size = 3;
1728 	command_packet->request_id = request_id;
1729 	command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id);
1730 	command_packet->status = 0;
1731 	command_packet->flags = 0;
1732 
1733 	if (srb->cmnd[0] == WRITE_10) {
1734 		if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10))
1735 			command_packet->flags = 1;
1736 	}
1737 
1738 	if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) {
1739 		lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3];
1740 		num_sectors = (u32)srb->cmnd[4];
1741 	} else {
1742 		lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5];
1743 		num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1744 	}
1745 
1746 	/* Update sector statistic */
1747 	tw_dev->sector_count = num_sectors;
1748 	if (tw_dev->sector_count > tw_dev->max_sector_count)
1749 		tw_dev->max_sector_count = tw_dev->sector_count;
1750 
1751 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors);
1752 	command_packet->byte8.io.lba = lba;
1753 	command_packet->byte6.block_count = num_sectors;
1754 
1755 	use_sg = scsi_dma_map(srb);
1756 	if (use_sg <= 0)
1757 		return 1;
1758 
1759 	scsi_for_each_sg(tw_dev->srb[request_id], sg, use_sg, i) {
1760 		command_packet->byte8.io.sgl[i].address = sg_dma_address(sg);
1761 		command_packet->byte8.io.sgl[i].length = sg_dma_len(sg);
1762 		command_packet->size+=2;
1763 	}
1764 
1765 	/* Update SG statistics */
1766 	tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1767 	if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1768 		tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1769 
1770 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1771 	if (command_que_value == 0) {
1772 		dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n");
1773 		return 1;
1774 	}
1775 
1776 	/* Now try to post the command to the board */
1777 	tw_post_command_packet(tw_dev, request_id);
1778 
1779 	return 0;
1780 } /* End tw_scsiop_read_write() */
1781 
1782 /* This function will handle the request sense scsi command */
tw_scsiop_request_sense(TW_Device_Extension * tw_dev,int request_id)1783 static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id)
1784 {
1785 	char request_buffer[18];
1786 
1787 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n");
1788 
1789 	memset(request_buffer, 0, sizeof(request_buffer));
1790 	request_buffer[0] = 0x70; /* Immediate fixed format */
1791 	request_buffer[7] = 10;	/* minimum size per SPC: 18 bytes */
1792 	/* leave all other fields zero, giving effectively NO_SENSE return */
1793 	tw_transfer_internal(tw_dev, request_id, request_buffer,
1794 			     sizeof(request_buffer));
1795 
1796 	tw_dev->state[request_id] = TW_S_COMPLETED;
1797 	tw_state_request_finish(tw_dev, request_id);
1798 
1799 	/* If we got a request_sense, we probably want a reset, return error */
1800 	tw_dev->srb[request_id]->result = (DID_ERROR << 16);
1801 	scsi_done(tw_dev->srb[request_id]);
1802 
1803 	return 0;
1804 } /* End tw_scsiop_request_sense() */
1805 
1806 /* This function will handle synchronize cache scsi command */
tw_scsiop_synchronize_cache(TW_Device_Extension * tw_dev,int request_id)1807 static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id)
1808 {
1809 	TW_Command *command_packet;
1810 	unsigned long command_que_value;
1811 
1812 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n");
1813 
1814 	/* Send firmware flush command for this unit */
1815 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1816 	if (command_packet == NULL) {
1817 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n");
1818 		return 1;
1819 	}
1820 
1821 	/* Setup the command packet */
1822 	memset(command_packet, 0, sizeof(TW_Sector));
1823 	command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE);
1824 	command_packet->size = 2;
1825 	command_packet->request_id = request_id;
1826 	command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1827 	command_packet->status = 0;
1828 	command_packet->flags = 0;
1829 	command_packet->byte6.parameter_count = 1;
1830 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1831 	if (command_que_value == 0) {
1832 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n");
1833 		return 1;
1834 	}
1835 
1836 	/* Now try to post the command packet */
1837 	tw_post_command_packet(tw_dev, request_id);
1838 
1839 	return 0;
1840 } /* End tw_scsiop_synchronize_cache() */
1841 
1842 /* This function will handle test unit ready scsi command */
tw_scsiop_test_unit_ready(TW_Device_Extension * tw_dev,int request_id)1843 static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id)
1844 {
1845 	TW_Param *param;
1846 	TW_Command *command_packet;
1847 	unsigned long command_que_value;
1848 	unsigned long param_value;
1849 
1850 	dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n");
1851 
1852 	/* Initialize command packet */
1853 	command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1854 	if (command_packet == NULL) {
1855 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n");
1856 		return 1;
1857 	}
1858 	memset(command_packet, 0, sizeof(TW_Sector));
1859 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1860 	command_packet->size = 4;
1861 	command_packet->request_id = request_id;
1862 	command_packet->status = 0;
1863 	command_packet->flags = 0;
1864 	command_packet->byte6.parameter_count = 1;
1865 
1866 	/* Now setup the param */
1867 	if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1868 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n");
1869 		return 1;
1870 	}
1871 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1872 	memset(param, 0, sizeof(TW_Sector));
1873 	param->table_id = 3;	 /* unit summary table */
1874 	param->parameter_id = 3; /* unitsstatus parameter */
1875 	param->parameter_size_bytes = TW_MAX_UNITS;
1876 	param_value = tw_dev->alignment_physical_address[request_id];
1877 	if (param_value == 0) {
1878 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n");
1879 		return 1;
1880 	}
1881 
1882 	command_packet->byte8.param.sgl[0].address = param_value;
1883 	command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1884 	command_que_value = tw_dev->command_packet_physical_address[request_id];
1885 	if (command_que_value == 0) {
1886 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n");
1887 		return 1;
1888 	}
1889 
1890 	/* Now try to post the command packet */
1891 	tw_post_command_packet(tw_dev, request_id);
1892 
1893 	return 0;
1894 } /* End tw_scsiop_test_unit_ready() */
1895 
1896 /* This function is called by the isr to complete a testunitready command */
tw_scsiop_test_unit_ready_complete(TW_Device_Extension * tw_dev,int request_id)1897 static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id)
1898 {
1899 	unsigned char *is_unit_present;
1900 	TW_Param *param;
1901 
1902 	dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n");
1903 
1904 	param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1905 	if (param == NULL) {
1906 		printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n");
1907 		return 1;
1908 	}
1909 	is_unit_present = &(param->data[0]);
1910 
1911 	if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1912 		tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1913 	} else {
1914 		tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1915 		tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1916 		return TW_ISR_DONT_RESULT;
1917 	}
1918 
1919 	return 0;
1920 } /* End tw_scsiop_test_unit_ready_complete() */
1921 
1922 /* This is the main scsi queue function to handle scsi opcodes */
tw_scsi_queue_lck(struct scsi_cmnd * SCpnt)1923 static int tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1924 {
1925 	void (*done)(struct scsi_cmnd *) = scsi_done;
1926 	unsigned char *command = SCpnt->cmnd;
1927 	int request_id = 0;
1928 	int retval = 1;
1929 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1930 
1931 	/* If we are resetting due to timed out ioctl, report as busy */
1932 	if (test_bit(TW_IN_RESET, &tw_dev->flags))
1933 		return SCSI_MLQUEUE_HOST_BUSY;
1934 
1935 	/* Queue the command and get a request id */
1936 	tw_state_request_start(tw_dev, &request_id);
1937 
1938 	/* Save the scsi command for use by the ISR */
1939 	tw_dev->srb[request_id] = SCpnt;
1940 
1941 	switch (*command) {
1942 	case READ_10:
1943 	case READ_6:
1944 	case WRITE_10:
1945 	case WRITE_6:
1946 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
1947 		retval = tw_scsiop_read_write(tw_dev, request_id);
1948 		break;
1949 	case TEST_UNIT_READY:
1950 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
1951 		retval = tw_scsiop_test_unit_ready(tw_dev, request_id);
1952 		break;
1953 	case INQUIRY:
1954 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
1955 		retval = tw_scsiop_inquiry(tw_dev, request_id);
1956 		break;
1957 	case READ_CAPACITY:
1958 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
1959 		retval = tw_scsiop_read_capacity(tw_dev, request_id);
1960 		break;
1961 	case REQUEST_SENSE:
1962 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
1963 		retval = tw_scsiop_request_sense(tw_dev, request_id);
1964 		break;
1965 	case MODE_SENSE:
1966 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
1967 		retval = tw_scsiop_mode_sense(tw_dev, request_id);
1968 		break;
1969 	case SYNCHRONIZE_CACHE:
1970 		dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
1971 		retval = tw_scsiop_synchronize_cache(tw_dev, request_id);
1972 		break;
1973 	case TW_IOCTL:
1974 		printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n");
1975 		break;
1976 	default:
1977 		printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
1978 		tw_dev->state[request_id] = TW_S_COMPLETED;
1979 		tw_state_request_finish(tw_dev, request_id);
1980 		scsi_build_sense(SCpnt, 1, ILLEGAL_REQUEST, 0x20, 0);
1981 		done(SCpnt);
1982 		retval = 0;
1983 	}
1984 	if (retval) {
1985 		tw_dev->state[request_id] = TW_S_COMPLETED;
1986 		tw_state_request_finish(tw_dev, request_id);
1987 		SCpnt->result = (DID_ERROR << 16);
1988 		done(SCpnt);
1989 		retval = 0;
1990 	}
1991 	return retval;
1992 } /* End tw_scsi_queue() */
1993 
DEF_SCSI_QCMD(tw_scsi_queue)1994 static DEF_SCSI_QCMD(tw_scsi_queue)
1995 
1996 /* This function is the interrupt service routine */
1997 static irqreturn_t tw_interrupt(int irq, void *dev_instance)
1998 {
1999 	int request_id;
2000 	u32 status_reg_value;
2001 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
2002 	TW_Response_Queue response_que;
2003 	int error = 0, retval = 0;
2004 	TW_Command *command_packet;
2005 	int handled = 0;
2006 
2007 	/* Get the host lock for io completions */
2008 	spin_lock(tw_dev->host->host_lock);
2009 
2010 	/* Read the registers */
2011 	status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2012 
2013 	/* Check if this is our interrupt, otherwise bail */
2014 	if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
2015 		goto tw_interrupt_bail;
2016 
2017 	handled = 1;
2018 
2019 	/* If we are resetting, bail */
2020 	if (test_bit(TW_IN_RESET, &tw_dev->flags))
2021 		goto tw_interrupt_bail;
2022 
2023 	/* Check controller for errors */
2024 	if (tw_check_bits(status_reg_value)) {
2025 		dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2026 		if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2027 			TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2028 			goto tw_interrupt_bail;
2029 		}
2030 	}
2031 
2032 	/* Handle host interrupt */
2033 	if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
2034 		dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
2035 		TW_CLEAR_HOST_INTERRUPT(tw_dev);
2036 	}
2037 
2038 	/* Handle attention interrupt */
2039 	if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
2040 		dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
2041 		TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
2042 		tw_state_request_start(tw_dev, &request_id);
2043 		error = tw_aen_read_queue(tw_dev, request_id);
2044 		if (error) {
2045 			printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
2046 			tw_dev->state[request_id] = TW_S_COMPLETED;
2047 			tw_state_request_finish(tw_dev, request_id);
2048 		}
2049 	}
2050 
2051 	/* Handle command interrupt */
2052 	if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
2053 		/* Drain as many pending commands as we can */
2054 		while (tw_dev->pending_request_count > 0) {
2055 			request_id = tw_dev->pending_queue[tw_dev->pending_head];
2056 			if (tw_dev->state[request_id] != TW_S_PENDING) {
2057 				printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
2058 				break;
2059 			}
2060 			if (tw_post_command_packet(tw_dev, request_id)==0) {
2061 				if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2062 					tw_dev->pending_head = TW_Q_START;
2063 				} else {
2064 					tw_dev->pending_head = tw_dev->pending_head + 1;
2065 				}
2066 				tw_dev->pending_request_count--;
2067 			} else {
2068 				/* If we get here, we will continue re-posting on the next command interrupt */
2069 				break;
2070 			}
2071 		}
2072 		/* If there are no more pending requests, we mask command interrupt */
2073 		if (tw_dev->pending_request_count == 0)
2074 			TW_MASK_COMMAND_INTERRUPT(tw_dev);
2075 	}
2076 
2077 	/* Handle response interrupt */
2078 	if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
2079 		/* Drain the response queue from the board */
2080 		while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
2081 			/* Read response queue register */
2082 			response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
2083 			request_id = TW_RESID_OUT(response_que.response_id);
2084 			command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2085 			error = 0;
2086 
2087 			/* Check for bad response */
2088 			if (command_packet->status != 0) {
2089 				/* If internal command, don't error, don't fill sense */
2090 				if (tw_dev->srb[request_id] == NULL) {
2091 					tw_decode_sense(tw_dev, request_id, 0);
2092 				} else {
2093 					error = tw_decode_sense(tw_dev, request_id, 1);
2094 				}
2095 			}
2096 
2097 			/* Check for correct state */
2098 			if (tw_dev->state[request_id] != TW_S_POSTED) {
2099 				if (tw_dev->srb[request_id] != NULL) {
2100 					printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no);
2101 					error = 1;
2102 				}
2103 			}
2104 
2105 			dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
2106 
2107 			/* Check for internal command completion */
2108 			if (tw_dev->srb[request_id] == NULL) {
2109 				dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
2110 				/* Check for chrdev ioctl completion */
2111 				if (request_id != tw_dev->chrdev_request_id) {
2112 					retval = tw_aen_complete(tw_dev, request_id);
2113 					if (retval) {
2114 						printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
2115 					}
2116 				} else {
2117 					tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2118 					wake_up(&tw_dev->ioctl_wqueue);
2119 				}
2120 			} else {
2121 				switch (tw_dev->srb[request_id]->cmnd[0]) {
2122 				case READ_10:
2123 				case READ_6:
2124 					dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
2125 					break;
2126 				case WRITE_10:
2127 				case WRITE_6:
2128 					dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
2129 					break;
2130 				case TEST_UNIT_READY:
2131 					dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
2132 					error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
2133 					break;
2134 				case INQUIRY:
2135 					dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
2136 					error = tw_scsiop_inquiry_complete(tw_dev, request_id);
2137 					break;
2138 				case READ_CAPACITY:
2139 					dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
2140 					error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
2141 					break;
2142 				case MODE_SENSE:
2143 					dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
2144 					error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
2145 					break;
2146 				case SYNCHRONIZE_CACHE:
2147 					dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
2148 					break;
2149 				default:
2150 					printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
2151 					error = 1;
2152 				}
2153 
2154 				/* If no error command was a success */
2155 				if (error == 0) {
2156 					tw_dev->srb[request_id]->result = (DID_OK << 16);
2157 				}
2158 
2159 				/* If error, command failed */
2160 				if (error == 1) {
2161 					/* Ask for a host reset */
2162 					tw_dev->srb[request_id]->result = (DID_OK << 16) | SAM_STAT_CHECK_CONDITION;
2163 				}
2164 
2165 				/* Now complete the io */
2166 				if ((error != TW_ISR_DONT_COMPLETE)) {
2167 					scsi_dma_unmap(tw_dev->srb[request_id]);
2168 					scsi_done(tw_dev->srb[request_id]);
2169 					tw_dev->state[request_id] = TW_S_COMPLETED;
2170 					tw_state_request_finish(tw_dev, request_id);
2171 					tw_dev->posted_request_count--;
2172 				}
2173 			}
2174 
2175 			/* Check for valid status after each drain */
2176 			status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2177 			if (tw_check_bits(status_reg_value)) {
2178 				dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2179 				if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2180 					TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2181 					goto tw_interrupt_bail;
2182 				}
2183 			}
2184 		}
2185 	}
2186 
2187 tw_interrupt_bail:
2188 	spin_unlock(tw_dev->host->host_lock);
2189 	return IRQ_RETVAL(handled);
2190 } /* End tw_interrupt() */
2191 
2192 /* This function tells the controller to shut down */
__tw_shutdown(TW_Device_Extension * tw_dev)2193 static void __tw_shutdown(TW_Device_Extension *tw_dev)
2194 {
2195 	/* Disable interrupts */
2196 	TW_DISABLE_INTERRUPTS(tw_dev);
2197 
2198 	/* Free up the IRQ */
2199 	free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2200 
2201 	printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no);
2202 
2203 	/* Tell the card we are shutting down */
2204 	if (tw_initconnection(tw_dev, 1)) {
2205 		printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n");
2206 	} else {
2207 		printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n");
2208 	}
2209 
2210 	/* Clear all interrupts just before exit */
2211 	TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2212 } /* End __tw_shutdown() */
2213 
2214 /* Wrapper for __tw_shutdown */
tw_shutdown(struct pci_dev * pdev)2215 static void tw_shutdown(struct pci_dev *pdev)
2216 {
2217 	struct Scsi_Host *host = pci_get_drvdata(pdev);
2218 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2219 
2220 	__tw_shutdown(tw_dev);
2221 } /* End tw_shutdown() */
2222 
2223 /* This function gets called when a disk is coming online */
tw_slave_configure(struct scsi_device * sdev)2224 static int tw_slave_configure(struct scsi_device *sdev)
2225 {
2226 	/* Force 60 second timeout */
2227 	blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
2228 
2229 	return 0;
2230 } /* End tw_slave_configure() */
2231 
2232 static const struct scsi_host_template driver_template = {
2233 	.module			= THIS_MODULE,
2234 	.name			= "3ware Storage Controller",
2235 	.queuecommand		= tw_scsi_queue,
2236 	.eh_host_reset_handler	= tw_scsi_eh_reset,
2237 	.bios_param		= tw_scsi_biosparam,
2238 	.change_queue_depth	= scsi_change_queue_depth,
2239 	.can_queue		= TW_Q_LENGTH-2,
2240 	.slave_configure	= tw_slave_configure,
2241 	.this_id		= -1,
2242 	.sg_tablesize		= TW_MAX_SGL_LENGTH,
2243 	.max_sectors		= TW_MAX_SECTORS,
2244 	.cmd_per_lun		= TW_MAX_CMDS_PER_LUN,
2245 	.shost_groups		= tw_host_groups,
2246 	.emulated		= 1,
2247 	.no_write_same		= 1,
2248 };
2249 
2250 /* This function will probe and initialize a card */
tw_probe(struct pci_dev * pdev,const struct pci_device_id * dev_id)2251 static int tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2252 {
2253 	struct Scsi_Host *host = NULL;
2254 	TW_Device_Extension *tw_dev;
2255 	int retval;
2256 
2257 	retval = pci_enable_device(pdev);
2258 	if (retval) {
2259 		printk(KERN_WARNING "3w-xxxx: Failed to enable pci device.");
2260 		goto out_disable_device;
2261 	}
2262 
2263 	pci_set_master(pdev);
2264 
2265 	retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
2266 	if (retval) {
2267 		printk(KERN_WARNING "3w-xxxx: Failed to set dma mask.");
2268 		goto out_disable_device;
2269 	}
2270 
2271 	host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2272 	if (!host) {
2273 		printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension.");
2274 		retval = -ENOMEM;
2275 		goto out_disable_device;
2276 	}
2277 	tw_dev = (TW_Device_Extension *)host->hostdata;
2278 
2279 	/* Save values to device extension */
2280 	tw_dev->host = host;
2281 	tw_dev->tw_pci_dev = pdev;
2282 
2283 	if (tw_initialize_device_extension(tw_dev)) {
2284 		printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension.");
2285 		retval = -ENOMEM;
2286 		goto out_free_device_extension;
2287 	}
2288 
2289 	/* Request IO regions */
2290 	retval = pci_request_regions(pdev, "3w-xxxx");
2291 	if (retval) {
2292 		printk(KERN_WARNING "3w-xxxx: Failed to get mem region.");
2293 		goto out_free_device_extension;
2294 	}
2295 
2296 	/* Save base address */
2297 	tw_dev->base_addr = pci_resource_start(pdev, 0);
2298 	if (!tw_dev->base_addr) {
2299 		printk(KERN_WARNING "3w-xxxx: Failed to get io address.");
2300 		retval = -ENOMEM;
2301 		goto out_release_mem_region;
2302 	}
2303 
2304 	/* Disable interrupts on the card */
2305 	TW_DISABLE_INTERRUPTS(tw_dev);
2306 
2307 	/* Initialize the card */
2308 	if (tw_reset_sequence(tw_dev)) {
2309 		retval = -EINVAL;
2310 		goto out_release_mem_region;
2311 	}
2312 
2313 	/* Set host specific parameters */
2314 	host->max_id = TW_MAX_UNITS;
2315 	host->max_cmd_len = TW_MAX_CDB_LEN;
2316 
2317 	/* Luns and channels aren't supported by adapter */
2318 	host->max_lun = 0;
2319 	host->max_channel = 0;
2320 
2321 	/* Register the card with the kernel SCSI layer */
2322 	retval = scsi_add_host(host, &pdev->dev);
2323 	if (retval) {
2324 		printk(KERN_WARNING "3w-xxxx: scsi add host failed");
2325 		goto out_release_mem_region;
2326 	}
2327 
2328 	pci_set_drvdata(pdev, host);
2329 
2330 	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);
2331 
2332 	/* Now setup the interrupt handler */
2333 	retval = request_irq(pdev->irq, tw_interrupt, IRQF_SHARED, "3w-xxxx", tw_dev);
2334 	if (retval) {
2335 		printk(KERN_WARNING "3w-xxxx: Error requesting IRQ.");
2336 		goto out_remove_host;
2337 	}
2338 
2339 	tw_device_extension_list[tw_device_extension_count] = tw_dev;
2340 	tw_device_extension_count++;
2341 
2342 	/* Re-enable interrupts on the card */
2343 	TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2344 
2345 	/* Finally, scan the host */
2346 	scsi_scan_host(host);
2347 
2348 	if (twe_major == -1) {
2349 		if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0)
2350 			printk(KERN_WARNING "3w-xxxx: Failed to register character device.");
2351 	}
2352 	return 0;
2353 
2354 out_remove_host:
2355 	scsi_remove_host(host);
2356 out_release_mem_region:
2357 	pci_release_regions(pdev);
2358 out_free_device_extension:
2359 	tw_free_device_extension(tw_dev);
2360 	scsi_host_put(host);
2361 out_disable_device:
2362 	pci_disable_device(pdev);
2363 
2364 	return retval;
2365 } /* End tw_probe() */
2366 
2367 /* This function is called to remove a device */
tw_remove(struct pci_dev * pdev)2368 static void tw_remove(struct pci_dev *pdev)
2369 {
2370 	struct Scsi_Host *host = pci_get_drvdata(pdev);
2371 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2372 
2373 	scsi_remove_host(tw_dev->host);
2374 
2375 	/* Unregister character device */
2376 	if (twe_major >= 0) {
2377 		unregister_chrdev(twe_major, "twe");
2378 		twe_major = -1;
2379 	}
2380 
2381 	/* Shutdown the card */
2382 	__tw_shutdown(tw_dev);
2383 
2384 	/* Free up the mem region */
2385 	pci_release_regions(pdev);
2386 
2387 	/* Free up device extension resources */
2388 	tw_free_device_extension(tw_dev);
2389 
2390 	scsi_host_put(tw_dev->host);
2391 	pci_disable_device(pdev);
2392 	tw_device_extension_count--;
2393 } /* End tw_remove() */
2394 
2395 /* PCI Devices supported by this driver */
2396 static struct pci_device_id tw_pci_tbl[] = {
2397 	{ PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000,
2398 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2399 	{ PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000,
2400 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2401 	{ }
2402 };
2403 MODULE_DEVICE_TABLE(pci, tw_pci_tbl);
2404 
2405 /* pci_driver initializer */
2406 static struct pci_driver tw_driver = {
2407 	.name		= "3w-xxxx",
2408 	.id_table	= tw_pci_tbl,
2409 	.probe		= tw_probe,
2410 	.remove		= tw_remove,
2411 	.shutdown	= tw_shutdown,
2412 };
2413 
2414 /* This function is called on driver initialization */
tw_init(void)2415 static int __init tw_init(void)
2416 {
2417 	printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2418 
2419 	return pci_register_driver(&tw_driver);
2420 } /* End tw_init() */
2421 
2422 /* This function is called on driver exit */
tw_exit(void)2423 static void __exit tw_exit(void)
2424 {
2425 	pci_unregister_driver(&tw_driver);
2426 } /* End tw_exit() */
2427 
2428 module_init(tw_init);
2429 module_exit(tw_exit);
2430 
2431