1 /*
2    3w-sas.c -- LSI 3ware SAS/SATA-RAID Controller device driver for Linux.
3 
4    Written By: Adam Radford <aradford@gmail.com>
5 
6    Copyright (C) 2009 LSI Corporation.
7 
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; version 2 of the License.
11 
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16 
17    NO WARRANTY
18    THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
19    CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
20    LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
21    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
22    solely responsible for determining the appropriateness of using and
23    distributing the Program and assumes all risks associated with its
24    exercise of rights under this Agreement, including but not limited to
25    the risks and costs of program errors, damage to or loss of data,
26    programs or equipment, and unavailability or interruption of operations.
27 
28    DISCLAIMER OF LIABILITY
29    NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
30    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31    DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
32    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
33    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
34    USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
35    HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
36 
37    You should have received a copy of the GNU General Public License
38    along with this program; if not, write to the Free Software
39    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
40 
41    Controllers supported by this driver:
42 
43    LSI 3ware 9750 6Gb/s SAS/SATA-RAID
44 
45    Bugs/Comments/Suggestions should be mailed to:
46    aradford@gmail.com
47 
48    History
49    -------
50    3.26.02.000 - Initial driver release.
51 */
52 
53 #include <linux/module.h>
54 #include <linux/reboot.h>
55 #include <linux/spinlock.h>
56 #include <linux/interrupt.h>
57 #include <linux/moduleparam.h>
58 #include <linux/errno.h>
59 #include <linux/types.h>
60 #include <linux/delay.h>
61 #include <linux/pci.h>
62 #include <linux/time.h>
63 #include <linux/mutex.h>
64 #include <linux/slab.h>
65 #include <asm/io.h>
66 #include <asm/irq.h>
67 #include <linux/uaccess.h>
68 #include <scsi/scsi.h>
69 #include <scsi/scsi_host.h>
70 #include <scsi/scsi_tcq.h>
71 #include <scsi/scsi_cmnd.h>
72 #include "3w-sas.h"
73 
74 /* Globals */
75 #define TW_DRIVER_VERSION "3.26.02.000"
76 static DEFINE_MUTEX(twl_chrdev_mutex);
77 static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT];
78 static unsigned int twl_device_extension_count;
79 static int twl_major = -1;
80 extern struct timezone sys_tz;
81 
82 /* Module parameters */
83 MODULE_AUTHOR ("LSI");
84 MODULE_DESCRIPTION ("LSI 3ware SAS/SATA-RAID Linux Driver");
85 MODULE_LICENSE("GPL");
86 MODULE_VERSION(TW_DRIVER_VERSION);
87 
88 static int use_msi;
89 module_param(use_msi, int, S_IRUGO);
90 MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0");
91 
92 /* Function prototypes */
93 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
94 
95 /* Functions */
96 
97 /* This function returns AENs through sysfs */
twl_sysfs_aen_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * outbuf,loff_t offset,size_t count)98 static ssize_t twl_sysfs_aen_read(struct file *filp, struct kobject *kobj,
99 				  struct bin_attribute *bin_attr,
100 				  char *outbuf, loff_t offset, size_t count)
101 {
102 	struct device *dev = container_of(kobj, struct device, kobj);
103 	struct Scsi_Host *shost = class_to_shost(dev);
104 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
105 	unsigned long flags = 0;
106 	ssize_t ret;
107 
108 	if (!capable(CAP_SYS_ADMIN))
109 		return -EACCES;
110 
111 	spin_lock_irqsave(tw_dev->host->host_lock, flags);
112 	ret = memory_read_from_buffer(outbuf, count, &offset, tw_dev->event_queue[0], sizeof(TW_Event) * TW_Q_LENGTH);
113 	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
114 
115 	return ret;
116 } /* End twl_sysfs_aen_read() */
117 
118 /* aen_read sysfs attribute initializer */
119 static struct bin_attribute twl_sysfs_aen_read_attr = {
120 	.attr = {
121 		.name = "3ware_aen_read",
122 		.mode = S_IRUSR,
123 	},
124 	.size = 0,
125 	.read = twl_sysfs_aen_read
126 };
127 
128 /* This function returns driver compatibility info through sysfs */
twl_sysfs_compat_info(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * outbuf,loff_t offset,size_t count)129 static ssize_t twl_sysfs_compat_info(struct file *filp, struct kobject *kobj,
130 				     struct bin_attribute *bin_attr,
131 				     char *outbuf, loff_t offset, size_t count)
132 {
133 	struct device *dev = container_of(kobj, struct device, kobj);
134 	struct Scsi_Host *shost = class_to_shost(dev);
135 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
136 	unsigned long flags = 0;
137 	ssize_t ret;
138 
139 	if (!capable(CAP_SYS_ADMIN))
140 		return -EACCES;
141 
142 	spin_lock_irqsave(tw_dev->host->host_lock, flags);
143 	ret = memory_read_from_buffer(outbuf, count, &offset, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
144 	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
145 
146 	return ret;
147 } /* End twl_sysfs_compat_info() */
148 
149 /* compat_info sysfs attribute initializer */
150 static struct bin_attribute twl_sysfs_compat_info_attr = {
151 	.attr = {
152 		.name = "3ware_compat_info",
153 		.mode = S_IRUSR,
154 	},
155 	.size = 0,
156 	.read = twl_sysfs_compat_info
157 };
158 
159 /* Show some statistics about the card */
twl_show_stats(struct device * dev,struct device_attribute * attr,char * buf)160 static ssize_t twl_show_stats(struct device *dev,
161 			      struct device_attribute *attr, char *buf)
162 {
163 	struct Scsi_Host *host = class_to_shost(dev);
164 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
165 	unsigned long flags = 0;
166 	ssize_t len;
167 
168 	spin_lock_irqsave(tw_dev->host->host_lock, flags);
169 	len = snprintf(buf, PAGE_SIZE, "3w-sas Driver version: %s\n"
170 		       "Current commands posted:   %4d\n"
171 		       "Max commands posted:       %4d\n"
172 		       "Last sgl length:           %4d\n"
173 		       "Max sgl length:            %4d\n"
174 		       "Last sector count:         %4d\n"
175 		       "Max sector count:          %4d\n"
176 		       "SCSI Host Resets:          %4d\n"
177 		       "AEN's:                     %4d\n",
178 		       TW_DRIVER_VERSION,
179 		       tw_dev->posted_request_count,
180 		       tw_dev->max_posted_request_count,
181 		       tw_dev->sgl_entries,
182 		       tw_dev->max_sgl_entries,
183 		       tw_dev->sector_count,
184 		       tw_dev->max_sector_count,
185 		       tw_dev->num_resets,
186 		       tw_dev->aen_count);
187 	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
188 	return len;
189 } /* End twl_show_stats() */
190 
191 /* stats sysfs attribute initializer */
192 static struct device_attribute twl_host_stats_attr = {
193 	.attr = {
194 		.name =		"3ware_stats",
195 		.mode =		S_IRUGO,
196 	},
197 	.show = twl_show_stats
198 };
199 
200 /* Host attributes initializer */
201 static struct attribute *twl_host_attrs[] = {
202 	&twl_host_stats_attr.attr,
203 	NULL,
204 };
205 
206 ATTRIBUTE_GROUPS(twl_host);
207 
208 /* This function will look up an AEN severity string */
twl_aen_severity_lookup(unsigned char severity_code)209 static char *twl_aen_severity_lookup(unsigned char severity_code)
210 {
211 	char *retval = NULL;
212 
213 	if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
214 	    (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
215 		goto out;
216 
217 	retval = twl_aen_severity_table[severity_code];
218 out:
219 	return retval;
220 } /* End twl_aen_severity_lookup() */
221 
222 /* This function will queue an event */
twl_aen_queue_event(TW_Device_Extension * tw_dev,TW_Command_Apache_Header * header)223 static void twl_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
224 {
225 	u32 local_time;
226 	TW_Event *event;
227 	unsigned short aen;
228 	char host[16];
229 	char *error_str;
230 
231 	tw_dev->aen_count++;
232 
233 	/* Fill out event info */
234 	event = tw_dev->event_queue[tw_dev->error_index];
235 
236 	host[0] = '\0';
237 	if (tw_dev->host)
238 		sprintf(host, " scsi%d:", tw_dev->host->host_no);
239 
240 	aen = le16_to_cpu(header->status_block.error);
241 	memset(event, 0, sizeof(TW_Event));
242 
243 	event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
244 	/* event->time_stamp_sec overflows in y2106 */
245 	local_time = (u32)(ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
246 	event->time_stamp_sec = local_time;
247 	event->aen_code = aen;
248 	event->retrieved = TW_AEN_NOT_RETRIEVED;
249 	event->sequence_id = tw_dev->error_sequence_id;
250 	tw_dev->error_sequence_id++;
251 
252 	/* Check for embedded error string */
253 	error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
254 
255 	header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
256 	event->parameter_len = strlen(header->err_specific_desc);
257 	memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + 1 + strlen(error_str));
258 	if (event->severity != TW_AEN_SEVERITY_DEBUG)
259 		printk(KERN_WARNING "3w-sas:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
260 		       host,
261 		       twl_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
262 		       TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, error_str,
263 		       header->err_specific_desc);
264 	else
265 		tw_dev->aen_count--;
266 
267 	tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
268 } /* End twl_aen_queue_event() */
269 
270 /* This function will attempt to post a command packet to the board */
twl_post_command_packet(TW_Device_Extension * tw_dev,int request_id)271 static int twl_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
272 {
273 	dma_addr_t command_que_value;
274 
275 	command_que_value = tw_dev->command_packet_phys[request_id];
276 	command_que_value += TW_COMMAND_OFFSET;
277 
278 	/* First write upper 4 bytes */
279 	writel((u32)((u64)command_que_value >> 32), TWL_HIBQPH_REG_ADDR(tw_dev));
280 	/* Then the lower 4 bytes */
281 	writel((u32)(command_que_value | TWL_PULL_MODE), TWL_HIBQPL_REG_ADDR(tw_dev));
282 
283 	tw_dev->state[request_id] = TW_S_POSTED;
284 	tw_dev->posted_request_count++;
285 	if (tw_dev->posted_request_count > tw_dev->max_posted_request_count)
286 		tw_dev->max_posted_request_count = tw_dev->posted_request_count;
287 
288 	return 0;
289 } /* End twl_post_command_packet() */
290 
291 /* This function hands scsi cdb's to the firmware */
twl_scsiop_execute_scsi(TW_Device_Extension * tw_dev,int request_id,unsigned char * cdb,int use_sg,TW_SG_Entry_ISO * sglistarg)292 static int twl_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id,
293 				   unsigned char *cdb, int use_sg,
294 				   TW_SG_Entry_ISO *sglistarg)
295 {
296 	TW_Command_Full *full_command_packet;
297 	TW_Command_Apache *command_packet;
298 	int i, sg_count;
299 	struct scsi_cmnd *srb = NULL;
300 	struct scatterlist *sg;
301 	int retval = 1;
302 
303 	if (tw_dev->srb[request_id])
304 		srb = tw_dev->srb[request_id];
305 
306 	/* Initialize command packet */
307 	full_command_packet = tw_dev->command_packet_virt[request_id];
308 	full_command_packet->header.header_desc.size_header = 128;
309 	full_command_packet->header.status_block.error = 0;
310 	full_command_packet->header.status_block.severity__reserved = 0;
311 
312 	command_packet = &full_command_packet->command.newcommand;
313 	command_packet->status = 0;
314 	command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
315 
316 	/* We forced 16 byte cdb use earlier */
317 	if (!cdb)
318 		memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
319 	else
320 		memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
321 
322 	if (srb) {
323 		command_packet->unit = srb->device->id;
324 		command_packet->request_id__lunl =
325 			cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
326 	} else {
327 		command_packet->request_id__lunl =
328 			cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
329 		command_packet->unit = 0;
330 	}
331 
332 	command_packet->sgl_offset = 16;
333 
334 	if (!sglistarg) {
335 		/* Map sglist from scsi layer to cmd packet */
336 		if (scsi_sg_count(srb)) {
337 			sg_count = scsi_dma_map(srb);
338 			if (sg_count <= 0)
339 				goto out;
340 
341 			scsi_for_each_sg(srb, sg, sg_count, i) {
342 				command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
343 				command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg));
344 			}
345 			command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
346 		}
347 	} else {
348 		/* Internal cdb post */
349 		for (i = 0; i < use_sg; i++) {
350 			command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
351 			command_packet->sg_list[i].length = TW_CPU_TO_SGL(sglistarg[i].length);
352 		}
353 		command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
354 	}
355 
356 	/* Update some stats */
357 	if (srb) {
358 		tw_dev->sector_count = scsi_bufflen(srb) / 512;
359 		if (tw_dev->sector_count > tw_dev->max_sector_count)
360 			tw_dev->max_sector_count = tw_dev->sector_count;
361 		tw_dev->sgl_entries = scsi_sg_count(srb);
362 		if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
363 			tw_dev->max_sgl_entries = tw_dev->sgl_entries;
364 	}
365 
366 	/* Now post the command to the board */
367 	retval = twl_post_command_packet(tw_dev, request_id);
368 
369 out:
370 	return retval;
371 } /* End twl_scsiop_execute_scsi() */
372 
373 /* This function will read the aen queue from the isr */
twl_aen_read_queue(TW_Device_Extension * tw_dev,int request_id)374 static int twl_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
375 {
376 	unsigned char cdb[TW_MAX_CDB_LEN];
377 	TW_SG_Entry_ISO sglist[1];
378 	TW_Command_Full *full_command_packet;
379 	int retval = 1;
380 
381 	full_command_packet = tw_dev->command_packet_virt[request_id];
382 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
383 
384 	/* Initialize cdb */
385 	memset(&cdb, 0, TW_MAX_CDB_LEN);
386 	cdb[0] = REQUEST_SENSE; /* opcode */
387 	cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
388 
389 	/* Initialize sglist */
390 	memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
391 	sglist[0].length = TW_SECTOR_SIZE;
392 	sglist[0].address = tw_dev->generic_buffer_phys[request_id];
393 
394 	/* Mark internal command */
395 	tw_dev->srb[request_id] = NULL;
396 
397 	/* Now post the command packet */
398 	if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
399 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Post failed while reading AEN queue");
400 		goto out;
401 	}
402 	retval = 0;
403 out:
404 	return retval;
405 } /* End twl_aen_read_queue() */
406 
407 /* This function will sync firmware time with the host time */
twl_aen_sync_time(TW_Device_Extension * tw_dev,int request_id)408 static void twl_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
409 {
410 	u32 schedulertime;
411 	TW_Command_Full *full_command_packet;
412 	TW_Command *command_packet;
413 	TW_Param_Apache *param;
414 	time64_t local_time;
415 
416 	/* Fill out the command packet */
417 	full_command_packet = tw_dev->command_packet_virt[request_id];
418 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
419 	command_packet = &full_command_packet->command.oldcommand;
420 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
421 	command_packet->request_id = request_id;
422 	command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
423 	command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
424 	command_packet->size = TW_COMMAND_SIZE;
425 	command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
426 
427 	/* Setup the param */
428 	param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
429 	memset(param, 0, TW_SECTOR_SIZE);
430 	param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
431 	param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
432 	param->parameter_size_bytes = cpu_to_le16(4);
433 
434 	/* Convert system time in UTC to local time seconds since last
435            Sunday 12:00AM */
436 	local_time = (ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
437 	div_u64_rem(local_time - (3 * 86400), 604800, &schedulertime);
438 	schedulertime = cpu_to_le32(schedulertime);
439 
440 	memcpy(param->data, &schedulertime, sizeof(u32));
441 
442 	/* Mark internal command */
443 	tw_dev->srb[request_id] = NULL;
444 
445 	/* Now post the command */
446 	twl_post_command_packet(tw_dev, request_id);
447 } /* End twl_aen_sync_time() */
448 
449 /* This function will assign an available request id */
twl_get_request_id(TW_Device_Extension * tw_dev,int * request_id)450 static void twl_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
451 {
452 	*request_id = tw_dev->free_queue[tw_dev->free_head];
453 	tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
454 	tw_dev->state[*request_id] = TW_S_STARTED;
455 } /* End twl_get_request_id() */
456 
457 /* This function will free a request id */
twl_free_request_id(TW_Device_Extension * tw_dev,int request_id)458 static void twl_free_request_id(TW_Device_Extension *tw_dev, int request_id)
459 {
460 	tw_dev->free_queue[tw_dev->free_tail] = request_id;
461 	tw_dev->state[request_id] = TW_S_FINISHED;
462 	tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
463 } /* End twl_free_request_id() */
464 
465 /* This function will complete an aen request from the isr */
twl_aen_complete(TW_Device_Extension * tw_dev,int request_id)466 static int twl_aen_complete(TW_Device_Extension *tw_dev, int request_id)
467 {
468 	TW_Command_Full *full_command_packet;
469 	TW_Command *command_packet;
470 	TW_Command_Apache_Header *header;
471 	unsigned short aen;
472 	int retval = 1;
473 
474 	header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
475 	tw_dev->posted_request_count--;
476 	aen = le16_to_cpu(header->status_block.error);
477 	full_command_packet = tw_dev->command_packet_virt[request_id];
478 	command_packet = &full_command_packet->command.oldcommand;
479 
480 	/* First check for internal completion of set param for time sync */
481 	if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
482 		/* Keep reading the queue in case there are more aen's */
483 		if (twl_aen_read_queue(tw_dev, request_id))
484 			goto out2;
485 		else {
486 			retval = 0;
487 			goto out;
488 		}
489 	}
490 
491 	switch (aen) {
492 	case TW_AEN_QUEUE_EMPTY:
493 		/* Quit reading the queue if this is the last one */
494 		break;
495 	case TW_AEN_SYNC_TIME_WITH_HOST:
496 		twl_aen_sync_time(tw_dev, request_id);
497 		retval = 0;
498 		goto out;
499 	default:
500 		twl_aen_queue_event(tw_dev, header);
501 
502 		/* If there are more aen's, keep reading the queue */
503 		if (twl_aen_read_queue(tw_dev, request_id))
504 			goto out2;
505 		else {
506 			retval = 0;
507 			goto out;
508 		}
509 	}
510 	retval = 0;
511 out2:
512 	tw_dev->state[request_id] = TW_S_COMPLETED;
513 	twl_free_request_id(tw_dev, request_id);
514 	clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
515 out:
516 	return retval;
517 } /* End twl_aen_complete() */
518 
519 /* This function will poll for a response */
twl_poll_response(TW_Device_Extension * tw_dev,int request_id,int seconds)520 static int twl_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
521 {
522 	unsigned long before;
523 	dma_addr_t mfa;
524 	u32 regh, regl;
525 	u32 response;
526 	int retval = 1;
527 	int found = 0;
528 
529 	before = jiffies;
530 
531 	while (!found) {
532 		if (sizeof(dma_addr_t) > 4) {
533 			regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
534 			regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
535 			mfa = ((u64)regh << 32) | regl;
536 		} else
537 			mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
538 
539 		response = (u32)mfa;
540 
541 		if (TW_RESID_OUT(response) == request_id)
542 			found = 1;
543 
544 		if (time_after(jiffies, before + HZ * seconds))
545 			goto out;
546 
547 		msleep(50);
548 	}
549 	retval = 0;
550 out:
551 	return retval;
552 } /* End twl_poll_response() */
553 
554 /* This function will drain the aen queue */
twl_aen_drain_queue(TW_Device_Extension * tw_dev,int no_check_reset)555 static int twl_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
556 {
557 	int request_id = 0;
558 	unsigned char cdb[TW_MAX_CDB_LEN];
559 	TW_SG_Entry_ISO sglist[1];
560 	int finished = 0, count = 0;
561 	TW_Command_Full *full_command_packet;
562 	TW_Command_Apache_Header *header;
563 	unsigned short aen;
564 	int first_reset = 0, queue = 0, retval = 1;
565 
566 	if (no_check_reset)
567 		first_reset = 0;
568 	else
569 		first_reset = 1;
570 
571 	full_command_packet = tw_dev->command_packet_virt[request_id];
572 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
573 
574 	/* Initialize cdb */
575 	memset(&cdb, 0, TW_MAX_CDB_LEN);
576 	cdb[0] = REQUEST_SENSE; /* opcode */
577 	cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
578 
579 	/* Initialize sglist */
580 	memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
581 	sglist[0].length = TW_SECTOR_SIZE;
582 	sglist[0].address = tw_dev->generic_buffer_phys[request_id];
583 
584 	/* Mark internal command */
585 	tw_dev->srb[request_id] = NULL;
586 
587 	do {
588 		/* Send command to the board */
589 		if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
590 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "Error posting request sense");
591 			goto out;
592 		}
593 
594 		/* Now poll for completion */
595 		if (twl_poll_response(tw_dev, request_id, 30)) {
596 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "No valid response while draining AEN queue");
597 			tw_dev->posted_request_count--;
598 			goto out;
599 		}
600 
601 		tw_dev->posted_request_count--;
602 		header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
603 		aen = le16_to_cpu(header->status_block.error);
604 		queue = 0;
605 		count++;
606 
607 		switch (aen) {
608 		case TW_AEN_QUEUE_EMPTY:
609 			if (first_reset != 1)
610 				goto out;
611 			else
612 				finished = 1;
613 			break;
614 		case TW_AEN_SOFT_RESET:
615 			if (first_reset == 0)
616 				first_reset = 1;
617 			else
618 				queue = 1;
619 			break;
620 		case TW_AEN_SYNC_TIME_WITH_HOST:
621 			break;
622 		default:
623 			queue = 1;
624 		}
625 
626 		/* Now queue an event info */
627 		if (queue)
628 			twl_aen_queue_event(tw_dev, header);
629 	} while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
630 
631 	if (count == TW_MAX_AEN_DRAIN)
632 		goto out;
633 
634 	retval = 0;
635 out:
636 	tw_dev->state[request_id] = TW_S_INITIAL;
637 	return retval;
638 } /* End twl_aen_drain_queue() */
639 
640 /* This function will allocate memory and check if it is correctly aligned */
twl_allocate_memory(TW_Device_Extension * tw_dev,int size,int which)641 static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
642 {
643 	int i;
644 	dma_addr_t dma_handle;
645 	unsigned long *cpu_addr;
646 	int retval = 1;
647 
648 	cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
649 				      size * TW_Q_LENGTH, &dma_handle,
650 				      GFP_KERNEL);
651 	if (!cpu_addr) {
652 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
653 		goto out;
654 	}
655 
656 	for (i = 0; i < TW_Q_LENGTH; i++) {
657 		switch(which) {
658 		case 0:
659 			tw_dev->command_packet_phys[i] = dma_handle+(i*size);
660 			tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
661 			break;
662 		case 1:
663 			tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
664 			tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
665 			break;
666 		case 2:
667 			tw_dev->sense_buffer_phys[i] = dma_handle+(i*size);
668 			tw_dev->sense_buffer_virt[i] = (TW_Command_Apache_Header *)((unsigned char *)cpu_addr + (i*size));
669 			break;
670 		}
671 	}
672 	retval = 0;
673 out:
674 	return retval;
675 } /* End twl_allocate_memory() */
676 
677 /* This function will load the request id and various sgls for ioctls */
twl_load_sgl(TW_Device_Extension * tw_dev,TW_Command_Full * full_command_packet,int request_id,dma_addr_t dma_handle,int length)678 static void twl_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
679 {
680 	TW_Command *oldcommand;
681 	TW_Command_Apache *newcommand;
682 	TW_SG_Entry_ISO *sgl;
683 	unsigned int pae = 0;
684 
685 	if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
686 		pae = 1;
687 
688 	if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
689 		newcommand = &full_command_packet->command.newcommand;
690 		newcommand->request_id__lunl =
691 			cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
692 		if (length) {
693 			newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
694 			newcommand->sg_list[0].length = TW_CPU_TO_SGL(length);
695 		}
696 		newcommand->sgl_entries__lunh =
697 			cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
698 	} else {
699 		oldcommand = &full_command_packet->command.oldcommand;
700 		oldcommand->request_id = request_id;
701 
702 		if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
703 			/* Load the sg list */
704 			sgl = (TW_SG_Entry_ISO *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry_ISO)/4) + pae + (sizeof(dma_addr_t) > 4 ? 1 : 0));
705 			sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
706 			sgl->length = TW_CPU_TO_SGL(length);
707 			oldcommand->size += pae;
708 			oldcommand->size += sizeof(dma_addr_t) > 4 ? 1 : 0;
709 		}
710 	}
711 } /* End twl_load_sgl() */
712 
713 /* This function handles ioctl for the character device
714    This interface is used by smartmontools open source software */
twl_chrdev_ioctl(struct file * file,unsigned int cmd,unsigned long arg)715 static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
716 {
717 	long timeout;
718 	unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
719 	dma_addr_t dma_handle;
720 	int request_id = 0;
721 	TW_Ioctl_Driver_Command driver_command;
722 	struct inode *inode = file_inode(file);
723 	TW_Ioctl_Buf_Apache *tw_ioctl;
724 	TW_Command_Full *full_command_packet;
725 	TW_Device_Extension *tw_dev = twl_device_extension_list[iminor(inode)];
726 	int retval = -EFAULT;
727 	void __user *argp = (void __user *)arg;
728 
729 	mutex_lock(&twl_chrdev_mutex);
730 
731 	/* Only let one of these through at a time */
732 	if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
733 		retval = -EINTR;
734 		goto out;
735 	}
736 
737 	/* First copy down the driver command */
738 	if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
739 		goto out2;
740 
741 	/* Check data buffer size */
742 	if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
743 		retval = -EINVAL;
744 		goto out2;
745 	}
746 
747 	/* Hardware can only do multiple of 512 byte transfers */
748 	data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
749 
750 	/* Now allocate ioctl buf memory */
751 	cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, &dma_handle, GFP_KERNEL);
752 	if (!cpu_addr) {
753 		retval = -ENOMEM;
754 		goto out2;
755 	}
756 
757 	tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
758 
759 	/* Now copy down the entire ioctl */
760 	if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
761 		goto out3;
762 
763 	/* See which ioctl we are doing */
764 	switch (cmd) {
765 	case TW_IOCTL_FIRMWARE_PASS_THROUGH:
766 		spin_lock_irqsave(tw_dev->host->host_lock, flags);
767 		twl_get_request_id(tw_dev, &request_id);
768 
769 		/* Flag internal command */
770 		tw_dev->srb[request_id] = NULL;
771 
772 		/* Flag chrdev ioctl */
773 		tw_dev->chrdev_request_id = request_id;
774 
775 		full_command_packet = (TW_Command_Full *)&tw_ioctl->firmware_command;
776 
777 		/* Load request id and sglist for both command types */
778 		twl_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
779 
780 		memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
781 
782 		/* Now post the command packet to the controller */
783 		twl_post_command_packet(tw_dev, request_id);
784 		spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
785 
786 		timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
787 
788 		/* Now wait for command to complete */
789 		timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
790 
791 		/* We timed out, and didn't get an interrupt */
792 		if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
793 			/* Now we need to reset the board */
794 			printk(KERN_WARNING "3w-sas: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
795 			       tw_dev->host->host_no, TW_DRIVER, 0x6,
796 			       cmd);
797 			retval = -EIO;
798 			twl_reset_device_extension(tw_dev, 1);
799 			goto out3;
800 		}
801 
802 		/* Now copy in the command packet response */
803 		memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
804 
805 		/* Now complete the io */
806 		spin_lock_irqsave(tw_dev->host->host_lock, flags);
807 		tw_dev->posted_request_count--;
808 		tw_dev->state[request_id] = TW_S_COMPLETED;
809 		twl_free_request_id(tw_dev, request_id);
810 		spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
811 		break;
812 	default:
813 		retval = -ENOTTY;
814 		goto out3;
815 	}
816 
817 	/* Now copy the entire response to userspace */
818 	if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
819 		retval = 0;
820 out3:
821 	/* Now free ioctl buf memory */
822 	dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
823 out2:
824 	mutex_unlock(&tw_dev->ioctl_lock);
825 out:
826 	mutex_unlock(&twl_chrdev_mutex);
827 	return retval;
828 } /* End twl_chrdev_ioctl() */
829 
830 /* This function handles open for the character device */
twl_chrdev_open(struct inode * inode,struct file * file)831 static int twl_chrdev_open(struct inode *inode, struct file *file)
832 {
833 	unsigned int minor_number;
834 	int retval = -ENODEV;
835 
836 	if (!capable(CAP_SYS_ADMIN)) {
837 		retval = -EACCES;
838 		goto out;
839 	}
840 
841 	minor_number = iminor(inode);
842 	if (minor_number >= twl_device_extension_count)
843 		goto out;
844 	retval = 0;
845 out:
846 	return retval;
847 } /* End twl_chrdev_open() */
848 
849 /* File operations struct for character device */
850 static const struct file_operations twl_fops = {
851 	.owner		= THIS_MODULE,
852 	.unlocked_ioctl	= twl_chrdev_ioctl,
853 	.open		= twl_chrdev_open,
854 	.release	= NULL,
855 	.llseek		= noop_llseek,
856 };
857 
858 /* This function passes sense data from firmware to scsi layer */
twl_fill_sense(TW_Device_Extension * tw_dev,int i,int request_id,int copy_sense,int print_host)859 static int twl_fill_sense(TW_Device_Extension *tw_dev, int i, int request_id, int copy_sense, int print_host)
860 {
861 	TW_Command_Apache_Header *header;
862 	TW_Command_Full *full_command_packet;
863 	unsigned short error;
864 	char *error_str;
865 
866 	header = tw_dev->sense_buffer_virt[i];
867 	full_command_packet = tw_dev->command_packet_virt[request_id];
868 
869 	/* Get embedded firmware error string */
870 	error_str = &(header->err_specific_desc[strlen(header->err_specific_desc) + 1]);
871 
872 	/* Don't print error for Logical unit not supported during rollcall */
873 	error = le16_to_cpu(header->status_block.error);
874 	if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE) && (error != TW_ERROR_INVALID_FIELD_IN_CDB)) {
875 		if (print_host)
876 			printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
877 			       tw_dev->host->host_no,
878 			       TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
879 			       header->status_block.error,
880 			       error_str,
881 			       header->err_specific_desc);
882 		else
883 			printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s:%s.\n",
884 			       TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
885 			       header->status_block.error,
886 			       error_str,
887 			       header->err_specific_desc);
888 	}
889 
890 	if (copy_sense) {
891 		memcpy(tw_dev->srb[request_id]->sense_buffer, header->sense_data, TW_SENSE_DATA_LENGTH);
892 		tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
893 		goto out;
894 	}
895 out:
896 	return 1;
897 } /* End twl_fill_sense() */
898 
899 /* This function will free up device extension resources */
twl_free_device_extension(TW_Device_Extension * tw_dev)900 static void twl_free_device_extension(TW_Device_Extension *tw_dev)
901 {
902 	if (tw_dev->command_packet_virt[0])
903 		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
904 				    sizeof(TW_Command_Full)*TW_Q_LENGTH,
905 				    tw_dev->command_packet_virt[0],
906 				    tw_dev->command_packet_phys[0]);
907 
908 	if (tw_dev->generic_buffer_virt[0])
909 		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
910 				    TW_SECTOR_SIZE*TW_Q_LENGTH,
911 				    tw_dev->generic_buffer_virt[0],
912 				    tw_dev->generic_buffer_phys[0]);
913 
914 	if (tw_dev->sense_buffer_virt[0])
915 		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
916 				    sizeof(TW_Command_Apache_Header)*
917 				    TW_Q_LENGTH,
918 				    tw_dev->sense_buffer_virt[0],
919 				    tw_dev->sense_buffer_phys[0]);
920 
921 	kfree(tw_dev->event_queue[0]);
922 } /* End twl_free_device_extension() */
923 
924 /* This function will get parameter table entries from the firmware */
twl_get_param(TW_Device_Extension * tw_dev,int request_id,int table_id,int parameter_id,int parameter_size_bytes)925 static void *twl_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
926 {
927 	TW_Command_Full *full_command_packet;
928 	TW_Command *command_packet;
929 	TW_Param_Apache *param;
930 	void *retval = NULL;
931 
932 	/* Setup the command packet */
933 	full_command_packet = tw_dev->command_packet_virt[request_id];
934 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
935 	command_packet = &full_command_packet->command.oldcommand;
936 
937 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
938 	command_packet->size		  = TW_COMMAND_SIZE;
939 	command_packet->request_id	  = request_id;
940 	command_packet->byte6_offset.block_count = cpu_to_le16(1);
941 
942 	/* Now setup the param */
943 	param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
944 	memset(param, 0, TW_SECTOR_SIZE);
945 	param->table_id = cpu_to_le16(table_id | 0x8000);
946 	param->parameter_id = cpu_to_le16(parameter_id);
947 	param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
948 
949 	command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
950 	command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
951 
952 	/* Post the command packet to the board */
953 	twl_post_command_packet(tw_dev, request_id);
954 
955 	/* Poll for completion */
956 	if (twl_poll_response(tw_dev, request_id, 30))
957 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "No valid response during get param")
958 	else
959 		retval = (void *)&(param->data[0]);
960 
961 	tw_dev->posted_request_count--;
962 	tw_dev->state[request_id] = TW_S_INITIAL;
963 
964 	return retval;
965 } /* End twl_get_param() */
966 
967 /* This function will send an initconnection command to controller */
twl_initconnection(TW_Device_Extension * tw_dev,int message_credits,u32 set_features,unsigned short current_fw_srl,unsigned short current_fw_arch_id,unsigned short current_fw_branch,unsigned short current_fw_build,unsigned short * fw_on_ctlr_srl,unsigned short * fw_on_ctlr_arch_id,unsigned short * fw_on_ctlr_branch,unsigned short * fw_on_ctlr_build,u32 * init_connect_result)968 static int twl_initconnection(TW_Device_Extension *tw_dev, int message_credits,
969 			      u32 set_features, unsigned short current_fw_srl,
970 			      unsigned short current_fw_arch_id,
971 			      unsigned short current_fw_branch,
972 			      unsigned short current_fw_build,
973 			      unsigned short *fw_on_ctlr_srl,
974 			      unsigned short *fw_on_ctlr_arch_id,
975 			      unsigned short *fw_on_ctlr_branch,
976 			      unsigned short *fw_on_ctlr_build,
977 			      u32 *init_connect_result)
978 {
979 	TW_Command_Full *full_command_packet;
980 	TW_Initconnect *tw_initconnect;
981 	int request_id = 0, retval = 1;
982 
983 	/* Initialize InitConnection command packet */
984 	full_command_packet = tw_dev->command_packet_virt[request_id];
985 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
986 	full_command_packet->header.header_desc.size_header = 128;
987 
988 	tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
989 	tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
990 	tw_initconnect->request_id = request_id;
991 	tw_initconnect->message_credits = cpu_to_le16(message_credits);
992 	tw_initconnect->features = set_features;
993 
994 	/* Turn on 64-bit sgl support if we need to */
995 	tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
996 
997 	tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
998 
999 	if (set_features & TW_EXTENDED_INIT_CONNECT) {
1000 		tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1001 		tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1002 		tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1003 		tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1004 		tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1005 	} else
1006 		tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1007 
1008 	/* Send command packet to the board */
1009 	twl_post_command_packet(tw_dev, request_id);
1010 
1011 	/* Poll for completion */
1012 	if (twl_poll_response(tw_dev, request_id, 30)) {
1013 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x8, "No valid response during init connection");
1014 	} else {
1015 		if (set_features & TW_EXTENDED_INIT_CONNECT) {
1016 			*fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1017 			*fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1018 			*fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1019 			*fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1020 			*init_connect_result = le32_to_cpu(tw_initconnect->result);
1021 		}
1022 		retval = 0;
1023 	}
1024 
1025 	tw_dev->posted_request_count--;
1026 	tw_dev->state[request_id] = TW_S_INITIAL;
1027 
1028 	return retval;
1029 } /* End twl_initconnection() */
1030 
1031 /* This function will initialize the fields of a device extension */
twl_initialize_device_extension(TW_Device_Extension * tw_dev)1032 static int twl_initialize_device_extension(TW_Device_Extension *tw_dev)
1033 {
1034 	int i, retval = 1;
1035 
1036 	/* Initialize command packet buffers */
1037 	if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1038 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x9, "Command packet memory allocation failed");
1039 		goto out;
1040 	}
1041 
1042 	/* Initialize generic buffer */
1043 	if (twl_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1044 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Generic memory allocation failed");
1045 		goto out;
1046 	}
1047 
1048 	/* Allocate sense buffers */
1049 	if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Apache_Header), 2)) {
1050 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xb, "Sense buffer allocation failed");
1051 		goto out;
1052 	}
1053 
1054 	/* Allocate event info space */
1055 	tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1056 	if (!tw_dev->event_queue[0]) {
1057 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "Event info memory allocation failed");
1058 		goto out;
1059 	}
1060 
1061 	for (i = 0; i < TW_Q_LENGTH; i++) {
1062 		tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1063 		tw_dev->free_queue[i] = i;
1064 		tw_dev->state[i] = TW_S_INITIAL;
1065 	}
1066 
1067 	tw_dev->free_head = TW_Q_START;
1068 	tw_dev->free_tail = TW_Q_START;
1069 	tw_dev->error_sequence_id = 1;
1070 	tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1071 
1072 	mutex_init(&tw_dev->ioctl_lock);
1073 	init_waitqueue_head(&tw_dev->ioctl_wqueue);
1074 
1075 	retval = 0;
1076 out:
1077 	return retval;
1078 } /* End twl_initialize_device_extension() */
1079 
1080 /* This function will handle attention interrupts */
twl_handle_attention_interrupt(TW_Device_Extension * tw_dev)1081 static int twl_handle_attention_interrupt(TW_Device_Extension *tw_dev)
1082 {
1083 	int retval = 1;
1084 	u32 request_id, doorbell;
1085 
1086 	/* Read doorbell status */
1087 	doorbell = readl(TWL_HOBDB_REG_ADDR(tw_dev));
1088 
1089 	/* Check for controller errors */
1090 	if (doorbell & TWL_DOORBELL_CONTROLLER_ERROR) {
1091 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "Microcontroller Error: clearing");
1092 		goto out;
1093 	}
1094 
1095 	/* Check if we need to perform an AEN drain */
1096 	if (doorbell & TWL_DOORBELL_ATTENTION_INTERRUPT) {
1097 		if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1098 			twl_get_request_id(tw_dev, &request_id);
1099 			if (twl_aen_read_queue(tw_dev, request_id)) {
1100 				tw_dev->state[request_id] = TW_S_COMPLETED;
1101 				twl_free_request_id(tw_dev, request_id);
1102 				clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1103 			}
1104 		}
1105 	}
1106 
1107 	retval = 0;
1108 out:
1109 	/* Clear doorbell interrupt */
1110 	TWL_CLEAR_DB_INTERRUPT(tw_dev);
1111 
1112 	/* Make sure the clear was flushed by reading it back */
1113 	readl(TWL_HOBDBC_REG_ADDR(tw_dev));
1114 
1115 	return retval;
1116 } /* End twl_handle_attention_interrupt() */
1117 
1118 /* Interrupt service routine */
twl_interrupt(int irq,void * dev_instance)1119 static irqreturn_t twl_interrupt(int irq, void *dev_instance)
1120 {
1121 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1122 	int i, handled = 0, error = 0;
1123 	dma_addr_t mfa = 0;
1124 	u32 reg, regl, regh, response, request_id = 0;
1125 	struct scsi_cmnd *cmd;
1126 	TW_Command_Full *full_command_packet;
1127 
1128 	spin_lock(tw_dev->host->host_lock);
1129 
1130 	/* Read host interrupt status */
1131 	reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1132 
1133 	/* Check if this is our interrupt, otherwise bail */
1134 	if (!(reg & TWL_HISTATUS_VALID_INTERRUPT))
1135 		goto twl_interrupt_bail;
1136 
1137 	handled = 1;
1138 
1139 	/* If we are resetting, bail */
1140 	if (test_bit(TW_IN_RESET, &tw_dev->flags))
1141 		goto twl_interrupt_bail;
1142 
1143 	/* Attention interrupt */
1144 	if (reg & TWL_HISTATUS_ATTENTION_INTERRUPT) {
1145 		if (twl_handle_attention_interrupt(tw_dev)) {
1146 			TWL_MASK_INTERRUPTS(tw_dev);
1147 			goto twl_interrupt_bail;
1148 		}
1149 	}
1150 
1151 	/* Response interrupt */
1152 	while (reg & TWL_HISTATUS_RESPONSE_INTERRUPT) {
1153 		if (sizeof(dma_addr_t) > 4) {
1154 			regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
1155 			regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1156 			mfa = ((u64)regh << 32) | regl;
1157 		} else
1158 			mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1159 
1160 		error = 0;
1161 		response = (u32)mfa;
1162 
1163 		/* Check for command packet error */
1164 		if (!TW_NOTMFA_OUT(response)) {
1165 			for (i=0;i<TW_Q_LENGTH;i++) {
1166 				if (tw_dev->sense_buffer_phys[i] == mfa) {
1167 					request_id = le16_to_cpu(tw_dev->sense_buffer_virt[i]->header_desc.request_id);
1168 					if (tw_dev->srb[request_id] != NULL)
1169 						error = twl_fill_sense(tw_dev, i, request_id, 1, 1);
1170 					else {
1171 						/* Skip ioctl error prints */
1172 						if (request_id != tw_dev->chrdev_request_id)
1173 							error = twl_fill_sense(tw_dev, i, request_id, 0, 1);
1174 						else
1175 							memcpy(tw_dev->command_packet_virt[request_id], tw_dev->sense_buffer_virt[i], sizeof(TW_Command_Apache_Header));
1176 					}
1177 
1178 					/* Now re-post the sense buffer */
1179 					writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1180 					writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1181 					break;
1182 				}
1183 			}
1184 		} else
1185 			request_id = TW_RESID_OUT(response);
1186 
1187 		full_command_packet = tw_dev->command_packet_virt[request_id];
1188 
1189 		/* Check for correct state */
1190 		if (tw_dev->state[request_id] != TW_S_POSTED) {
1191 			if (tw_dev->srb[request_id] != NULL) {
1192 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Received a request id that wasn't posted");
1193 				TWL_MASK_INTERRUPTS(tw_dev);
1194 				goto twl_interrupt_bail;
1195 			}
1196 		}
1197 
1198 		/* Check for internal command completion */
1199 		if (tw_dev->srb[request_id] == NULL) {
1200 			if (request_id != tw_dev->chrdev_request_id) {
1201 				if (twl_aen_complete(tw_dev, request_id))
1202 					TW_PRINTK(tw_dev->host, TW_DRIVER, 0xf, "Error completing AEN during attention interrupt");
1203 			} else {
1204 				tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1205 				wake_up(&tw_dev->ioctl_wqueue);
1206 			}
1207 		} else {
1208 			cmd = tw_dev->srb[request_id];
1209 
1210 			if (!error)
1211 				cmd->result = (DID_OK << 16);
1212 
1213 			/* Report residual bytes for single sgl */
1214 			if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1215 				if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1216 					scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1217 			}
1218 
1219 			/* Now complete the io */
1220 			scsi_dma_unmap(cmd);
1221 			scsi_done(cmd);
1222 			tw_dev->state[request_id] = TW_S_COMPLETED;
1223 			twl_free_request_id(tw_dev, request_id);
1224 			tw_dev->posted_request_count--;
1225 		}
1226 
1227 		/* Check for another response interrupt */
1228 		reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1229 	}
1230 
1231 twl_interrupt_bail:
1232 	spin_unlock(tw_dev->host->host_lock);
1233 	return IRQ_RETVAL(handled);
1234 } /* End twl_interrupt() */
1235 
1236 /* This function will poll for a register change */
twl_poll_register(TW_Device_Extension * tw_dev,void * reg,u32 value,u32 result,int seconds)1237 static int twl_poll_register(TW_Device_Extension *tw_dev, void *reg, u32 value, u32 result, int seconds)
1238 {
1239 	unsigned long before;
1240 	int retval = 1;
1241 	u32 reg_value;
1242 
1243 	reg_value = readl(reg);
1244 	before = jiffies;
1245 
1246 	while ((reg_value & value) != result) {
1247 		reg_value = readl(reg);
1248 		if (time_after(jiffies, before + HZ * seconds))
1249 			goto out;
1250 		msleep(50);
1251 	}
1252 	retval = 0;
1253 out:
1254 	return retval;
1255 } /* End twl_poll_register() */
1256 
1257 /* This function will reset a controller */
twl_reset_sequence(TW_Device_Extension * tw_dev,int soft_reset)1258 static int twl_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1259 {
1260 	int retval = 1;
1261 	int i = 0;
1262 	u32 status = 0;
1263 	unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
1264 	unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
1265 	u32 init_connect_result = 0;
1266 	int tries = 0;
1267 	int do_soft_reset = soft_reset;
1268 
1269 	while (tries < TW_MAX_RESET_TRIES) {
1270 		/* Do a soft reset if one is needed */
1271 		if (do_soft_reset) {
1272 			TWL_SOFT_RESET(tw_dev);
1273 
1274 			/* Make sure controller is in a good state */
1275 			if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, 0x0, 30)) {
1276 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Controller never went non-ready during reset sequence");
1277 				tries++;
1278 				continue;
1279 			}
1280 			if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, TWL_CONTROLLER_READY, 60)) {
1281 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x11, "Controller not ready during reset sequence");
1282 				tries++;
1283 				continue;
1284 			}
1285 		}
1286 
1287 		/* Initconnect */
1288 		if (twl_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
1289 				       TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
1290 				       TW_9750_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
1291 				       TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
1292 				       &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
1293 				       &fw_on_ctlr_build, &init_connect_result)) {
1294 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x12, "Initconnection failed while checking SRL");
1295 			do_soft_reset = 1;
1296 			tries++;
1297 			continue;
1298 		}
1299 
1300 		/* Load sense buffers */
1301 		while (i < TW_Q_LENGTH) {
1302 			writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1303 			writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1304 
1305 			/* Check status for over-run after each write */
1306 			status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1307 			if (!(status & TWL_STATUS_OVERRUN_SUBMIT))
1308 			    i++;
1309 		}
1310 
1311 		/* Now check status */
1312 		status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1313 		if (status) {
1314 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "Bad controller status after loading sense buffers");
1315 			do_soft_reset = 1;
1316 			tries++;
1317 			continue;
1318 		}
1319 
1320 		/* Drain the AEN queue */
1321 		if (twl_aen_drain_queue(tw_dev, soft_reset)) {
1322 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x14, "AEN drain failed during reset sequence");
1323 			do_soft_reset = 1;
1324 			tries++;
1325 			continue;
1326 		}
1327 
1328 		/* Load rest of compatibility struct */
1329 		strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
1330 		tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
1331 		tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
1332 		tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
1333 		tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
1334 		tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
1335 		tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
1336 		tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
1337 		tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
1338 		tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
1339 
1340 		/* If we got here, controller is in a good state */
1341 		retval = 0;
1342 		goto out;
1343 	}
1344 out:
1345 	return retval;
1346 } /* End twl_reset_sequence() */
1347 
1348 /* This function will reset a device extension */
twl_reset_device_extension(TW_Device_Extension * tw_dev,int ioctl_reset)1349 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1350 {
1351 	int i = 0, retval = 1;
1352 	unsigned long flags = 0;
1353 
1354 	/* Block SCSI requests while we are resetting */
1355 	if (ioctl_reset)
1356 		scsi_block_requests(tw_dev->host);
1357 
1358 	set_bit(TW_IN_RESET, &tw_dev->flags);
1359 	TWL_MASK_INTERRUPTS(tw_dev);
1360 	TWL_CLEAR_DB_INTERRUPT(tw_dev);
1361 
1362 	spin_lock_irqsave(tw_dev->host->host_lock, flags);
1363 
1364 	/* Abort all requests that are in progress */
1365 	for (i = 0; i < TW_Q_LENGTH; i++) {
1366 		if ((tw_dev->state[i] != TW_S_FINISHED) &&
1367 		    (tw_dev->state[i] != TW_S_INITIAL) &&
1368 		    (tw_dev->state[i] != TW_S_COMPLETED)) {
1369 			struct scsi_cmnd *cmd = tw_dev->srb[i];
1370 
1371 			if (cmd) {
1372 				cmd->result = (DID_RESET << 16);
1373 				scsi_dma_unmap(cmd);
1374 				scsi_done(cmd);
1375 			}
1376 		}
1377 	}
1378 
1379 	/* Reset queues and counts */
1380 	for (i = 0; i < TW_Q_LENGTH; i++) {
1381 		tw_dev->free_queue[i] = i;
1382 		tw_dev->state[i] = TW_S_INITIAL;
1383 	}
1384 	tw_dev->free_head = TW_Q_START;
1385 	tw_dev->free_tail = TW_Q_START;
1386 	tw_dev->posted_request_count = 0;
1387 
1388 	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1389 
1390 	if (twl_reset_sequence(tw_dev, 1))
1391 		goto out;
1392 
1393 	TWL_UNMASK_INTERRUPTS(tw_dev);
1394 
1395 	clear_bit(TW_IN_RESET, &tw_dev->flags);
1396 	tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1397 
1398 	retval = 0;
1399 out:
1400 	if (ioctl_reset)
1401 		scsi_unblock_requests(tw_dev->host);
1402 	return retval;
1403 } /* End twl_reset_device_extension() */
1404 
1405 /* This funciton returns unit geometry in cylinders/heads/sectors */
twl_scsi_biosparam(struct scsi_device * sdev,struct block_device * bdev,sector_t capacity,int geom[])1406 static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1407 {
1408 	int heads, sectors;
1409 
1410 	if (capacity >= 0x200000) {
1411 		heads = 255;
1412 		sectors = 63;
1413 	} else {
1414 		heads = 64;
1415 		sectors = 32;
1416 	}
1417 
1418 	geom[0] = heads;
1419 	geom[1] = sectors;
1420 	geom[2] = sector_div(capacity, heads * sectors); /* cylinders */
1421 
1422 	return 0;
1423 } /* End twl_scsi_biosparam() */
1424 
1425 /* This is the new scsi eh reset function */
twl_scsi_eh_reset(struct scsi_cmnd * SCpnt)1426 static int twl_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1427 {
1428 	TW_Device_Extension *tw_dev = NULL;
1429 	int retval = FAILED;
1430 
1431 	tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1432 
1433 	tw_dev->num_resets++;
1434 
1435 	sdev_printk(KERN_WARNING, SCpnt->device,
1436 		"WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1437 		TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1438 
1439 	/* Make sure we are not issuing an ioctl or resetting from ioctl */
1440 	mutex_lock(&tw_dev->ioctl_lock);
1441 
1442 	/* Now reset the card and some of the device extension data */
1443 	if (twl_reset_device_extension(tw_dev, 0)) {
1444 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "Controller reset failed during scsi host reset");
1445 		goto out;
1446 	}
1447 
1448 	retval = SUCCESS;
1449 out:
1450 	mutex_unlock(&tw_dev->ioctl_lock);
1451 	return retval;
1452 } /* End twl_scsi_eh_reset() */
1453 
1454 /* This is the main scsi queue function to handle scsi opcodes */
twl_scsi_queue_lck(struct scsi_cmnd * SCpnt)1455 static int twl_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1456 {
1457 	void (*done)(struct scsi_cmnd *) = scsi_done;
1458 	int request_id, retval;
1459 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1460 
1461 	/* If we are resetting due to timed out ioctl, report as busy */
1462 	if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1463 		retval = SCSI_MLQUEUE_HOST_BUSY;
1464 		goto out;
1465 	}
1466 
1467 	/* Get a free request id */
1468 	twl_get_request_id(tw_dev, &request_id);
1469 
1470 	/* Save the scsi command for use by the ISR */
1471 	tw_dev->srb[request_id] = SCpnt;
1472 
1473 	retval = twl_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1474 	if (retval) {
1475 		tw_dev->state[request_id] = TW_S_COMPLETED;
1476 		twl_free_request_id(tw_dev, request_id);
1477 		SCpnt->result = (DID_ERROR << 16);
1478 		done(SCpnt);
1479 		retval = 0;
1480 	}
1481 out:
1482 	return retval;
1483 } /* End twl_scsi_queue() */
1484 
DEF_SCSI_QCMD(twl_scsi_queue)1485 static DEF_SCSI_QCMD(twl_scsi_queue)
1486 
1487 /* This function tells the controller to shut down */
1488 static void __twl_shutdown(TW_Device_Extension *tw_dev)
1489 {
1490 	/* Disable interrupts */
1491 	TWL_MASK_INTERRUPTS(tw_dev);
1492 
1493 	/* Free up the IRQ */
1494 	free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1495 
1496 	printk(KERN_WARNING "3w-sas: Shutting down host %d.\n", tw_dev->host->host_no);
1497 
1498 	/* Tell the card we are shutting down */
1499 	if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1500 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Connection shutdown failed");
1501 	} else {
1502 		printk(KERN_WARNING "3w-sas: Shutdown complete.\n");
1503 	}
1504 
1505 	/* Clear doorbell interrupt just before exit */
1506 	TWL_CLEAR_DB_INTERRUPT(tw_dev);
1507 } /* End __twl_shutdown() */
1508 
1509 /* Wrapper for __twl_shutdown */
twl_shutdown(struct pci_dev * pdev)1510 static void twl_shutdown(struct pci_dev *pdev)
1511 {
1512 	struct Scsi_Host *host = pci_get_drvdata(pdev);
1513 	TW_Device_Extension *tw_dev;
1514 
1515 	if (!host)
1516 		return;
1517 
1518 	tw_dev = (TW_Device_Extension *)host->hostdata;
1519 
1520 	if (tw_dev->online)
1521 		__twl_shutdown(tw_dev);
1522 } /* End twl_shutdown() */
1523 
1524 /* This function configures unit settings when a unit is coming on-line */
twl_slave_configure(struct scsi_device * sdev)1525 static int twl_slave_configure(struct scsi_device *sdev)
1526 {
1527 	/* Force 60 second timeout */
1528 	blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
1529 
1530 	return 0;
1531 } /* End twl_slave_configure() */
1532 
1533 /* scsi_host_template initializer */
1534 static struct scsi_host_template driver_template = {
1535 	.module			= THIS_MODULE,
1536 	.name			= "3w-sas",
1537 	.queuecommand		= twl_scsi_queue,
1538 	.eh_host_reset_handler	= twl_scsi_eh_reset,
1539 	.bios_param		= twl_scsi_biosparam,
1540 	.change_queue_depth	= scsi_change_queue_depth,
1541 	.can_queue		= TW_Q_LENGTH-2,
1542 	.slave_configure	= twl_slave_configure,
1543 	.this_id		= -1,
1544 	.sg_tablesize		= TW_LIBERATOR_MAX_SGL_LENGTH,
1545 	.max_sectors		= TW_MAX_SECTORS,
1546 	.cmd_per_lun		= TW_MAX_CMDS_PER_LUN,
1547 	.shost_groups		= twl_host_groups,
1548 	.emulated		= 1,
1549 	.no_write_same		= 1,
1550 };
1551 
1552 /* This function will probe and initialize a card */
twl_probe(struct pci_dev * pdev,const struct pci_device_id * dev_id)1553 static int twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1554 {
1555 	struct Scsi_Host *host = NULL;
1556 	TW_Device_Extension *tw_dev;
1557 	int retval = -ENODEV;
1558 	int *ptr_phycount, phycount=0;
1559 
1560 	retval = pci_enable_device(pdev);
1561 	if (retval) {
1562 		TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device");
1563 		goto out_disable_device;
1564 	}
1565 
1566 	pci_set_master(pdev);
1567 	pci_try_set_mwi(pdev);
1568 
1569 	retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
1570 	if (retval) {
1571 		TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
1572 		retval = -ENODEV;
1573 		goto out_disable_device;
1574 	}
1575 
1576 	host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
1577 	if (!host) {
1578 		TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension");
1579 		retval = -ENOMEM;
1580 		goto out_disable_device;
1581 	}
1582 	tw_dev = shost_priv(host);
1583 
1584 	/* Save values to device extension */
1585 	tw_dev->host = host;
1586 	tw_dev->tw_pci_dev = pdev;
1587 
1588 	if (twl_initialize_device_extension(tw_dev)) {
1589 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension");
1590 		retval = -ENOMEM;
1591 		goto out_free_device_extension;
1592 	}
1593 
1594 	/* Request IO regions */
1595 	retval = pci_request_regions(pdev, "3w-sas");
1596 	if (retval) {
1597 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region");
1598 		goto out_free_device_extension;
1599 	}
1600 
1601 	/* Save base address, use region 1 */
1602 	tw_dev->base_addr = pci_iomap(pdev, 1, 0);
1603 	if (!tw_dev->base_addr) {
1604 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap");
1605 		retval = -ENOMEM;
1606 		goto out_release_mem_region;
1607 	}
1608 
1609 	/* Disable interrupts on the card */
1610 	TWL_MASK_INTERRUPTS(tw_dev);
1611 
1612 	/* Initialize the card */
1613 	if (twl_reset_sequence(tw_dev, 0)) {
1614 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe");
1615 		retval = -ENOMEM;
1616 		goto out_iounmap;
1617 	}
1618 
1619 	/* Set host specific parameters */
1620 	host->max_id = TW_MAX_UNITS;
1621 	host->max_cmd_len = TW_MAX_CDB_LEN;
1622 	host->max_lun = TW_MAX_LUNS;
1623 	host->max_channel = 0;
1624 
1625 	/* Register the card with the kernel SCSI layer */
1626 	retval = scsi_add_host(host, &pdev->dev);
1627 	if (retval) {
1628 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed");
1629 		goto out_iounmap;
1630 	}
1631 
1632 	pci_set_drvdata(pdev, host);
1633 
1634 	printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n",
1635 	       host->host_no,
1636 	       (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1637 				     TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH),
1638 	       (u64)pci_resource_start(pdev, 1), pdev->irq);
1639 
1640 	ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE,
1641 				     TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH);
1642 	if (ptr_phycount)
1643 		phycount = le32_to_cpu(*(int *)ptr_phycount);
1644 
1645 	printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n",
1646 	       host->host_no,
1647 	       (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1648 				     TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
1649 	       (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE,
1650 				     TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
1651 	       phycount);
1652 
1653 	/* Try to enable MSI */
1654 	if (use_msi && !pci_enable_msi(pdev))
1655 		set_bit(TW_USING_MSI, &tw_dev->flags);
1656 
1657 	/* Now setup the interrupt handler */
1658 	retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1659 	if (retval) {
1660 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ");
1661 		goto out_remove_host;
1662 	}
1663 
1664 	twl_device_extension_list[twl_device_extension_count] = tw_dev;
1665 	twl_device_extension_count++;
1666 
1667 	/* Re-enable interrupts on the card */
1668 	TWL_UNMASK_INTERRUPTS(tw_dev);
1669 
1670 	/* Finally, scan the host */
1671 	scsi_scan_host(host);
1672 
1673 	/* Add sysfs binary files */
1674 	if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr))
1675 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read");
1676 	if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr))
1677 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info");
1678 
1679 	if (twl_major == -1) {
1680 		if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0)
1681 			TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device");
1682 	}
1683 	tw_dev->online = 1;
1684 	return 0;
1685 
1686 out_remove_host:
1687 	if (test_bit(TW_USING_MSI, &tw_dev->flags))
1688 		pci_disable_msi(pdev);
1689 	scsi_remove_host(host);
1690 out_iounmap:
1691 	iounmap(tw_dev->base_addr);
1692 out_release_mem_region:
1693 	pci_release_regions(pdev);
1694 out_free_device_extension:
1695 	twl_free_device_extension(tw_dev);
1696 	scsi_host_put(host);
1697 out_disable_device:
1698 	pci_disable_device(pdev);
1699 
1700 	return retval;
1701 } /* End twl_probe() */
1702 
1703 /* This function is called to remove a device */
twl_remove(struct pci_dev * pdev)1704 static void twl_remove(struct pci_dev *pdev)
1705 {
1706 	struct Scsi_Host *host = pci_get_drvdata(pdev);
1707 	TW_Device_Extension *tw_dev;
1708 
1709 	if (!host)
1710 		return;
1711 
1712 	tw_dev = (TW_Device_Extension *)host->hostdata;
1713 
1714 	if (!tw_dev->online)
1715 		return;
1716 
1717 	/* Remove sysfs binary files */
1718 	sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr);
1719 	sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr);
1720 
1721 	scsi_remove_host(tw_dev->host);
1722 
1723 	/* Unregister character device */
1724 	if (twl_major >= 0) {
1725 		unregister_chrdev(twl_major, "twl");
1726 		twl_major = -1;
1727 	}
1728 
1729 	/* Shutdown the card */
1730 	__twl_shutdown(tw_dev);
1731 
1732 	/* Disable MSI if enabled */
1733 	if (test_bit(TW_USING_MSI, &tw_dev->flags))
1734 		pci_disable_msi(pdev);
1735 
1736 	/* Free IO remapping */
1737 	iounmap(tw_dev->base_addr);
1738 
1739 	/* Free up the mem region */
1740 	pci_release_regions(pdev);
1741 
1742 	/* Free up device extension resources */
1743 	twl_free_device_extension(tw_dev);
1744 
1745 	scsi_host_put(tw_dev->host);
1746 	pci_disable_device(pdev);
1747 	twl_device_extension_count--;
1748 } /* End twl_remove() */
1749 
1750 /* This function is called on PCI suspend */
twl_suspend(struct device * dev)1751 static int __maybe_unused twl_suspend(struct device *dev)
1752 {
1753 	struct Scsi_Host *host = dev_get_drvdata(dev);
1754 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1755 
1756 	printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no);
1757 	/* Disable interrupts */
1758 	TWL_MASK_INTERRUPTS(tw_dev);
1759 
1760 	free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1761 
1762 	/* Tell the card we are shutting down */
1763 	if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1764 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend");
1765 	} else {
1766 		printk(KERN_WARNING "3w-sas: Suspend complete.\n");
1767 	}
1768 
1769 	/* Clear doorbell interrupt */
1770 	TWL_CLEAR_DB_INTERRUPT(tw_dev);
1771 
1772 	return 0;
1773 } /* End twl_suspend() */
1774 
1775 /* This function is called on PCI resume */
twl_resume(struct device * dev)1776 static int __maybe_unused twl_resume(struct device *dev)
1777 {
1778 	int retval = 0;
1779 	struct pci_dev *pdev = to_pci_dev(dev);
1780 	struct Scsi_Host *host = pci_get_drvdata(pdev);
1781 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1782 
1783 	printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no);
1784 	pci_try_set_mwi(pdev);
1785 
1786 	retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
1787 	if (retval) {
1788 		TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
1789 		retval = -ENODEV;
1790 		goto out_disable_device;
1791 	}
1792 
1793 	/* Initialize the card */
1794 	if (twl_reset_sequence(tw_dev, 0)) {
1795 		retval = -ENODEV;
1796 		goto out_disable_device;
1797 	}
1798 
1799 	/* Now setup the interrupt handler */
1800 	retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1801 	if (retval) {
1802 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume");
1803 		retval = -ENODEV;
1804 		goto out_disable_device;
1805 	}
1806 
1807 	/* Now enable MSI if enabled */
1808 	if (test_bit(TW_USING_MSI, &tw_dev->flags))
1809 		pci_enable_msi(pdev);
1810 
1811 	/* Re-enable interrupts on the card */
1812 	TWL_UNMASK_INTERRUPTS(tw_dev);
1813 
1814 	printk(KERN_WARNING "3w-sas: Resume complete.\n");
1815 	return 0;
1816 
1817 out_disable_device:
1818 	scsi_remove_host(host);
1819 
1820 	return retval;
1821 } /* End twl_resume() */
1822 
1823 /* PCI Devices supported by this driver */
1824 static struct pci_device_id twl_pci_tbl[] = {
1825 	{ PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) },
1826 	{ }
1827 };
1828 MODULE_DEVICE_TABLE(pci, twl_pci_tbl);
1829 
1830 static SIMPLE_DEV_PM_OPS(twl_pm_ops, twl_suspend, twl_resume);
1831 
1832 /* pci_driver initializer */
1833 static struct pci_driver twl_driver = {
1834 	.name		= "3w-sas",
1835 	.id_table	= twl_pci_tbl,
1836 	.probe		= twl_probe,
1837 	.remove		= twl_remove,
1838 	.driver.pm	= &twl_pm_ops,
1839 	.shutdown	= twl_shutdown
1840 };
1841 
1842 /* This function is called on driver initialization */
twl_init(void)1843 static int __init twl_init(void)
1844 {
1845 	printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
1846 
1847 	return pci_register_driver(&twl_driver);
1848 } /* End twl_init() */
1849 
1850 /* This function is called on driver exit */
twl_exit(void)1851 static void __exit twl_exit(void)
1852 {
1853 	pci_unregister_driver(&twl_driver);
1854 } /* End twl_exit() */
1855 
1856 module_init(twl_init);
1857 module_exit(twl_exit);
1858 
1859