1 /*
2  *  linux/drivers/scsi/esas2r/esas2r_main.c
3  *      For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
4  *
5  *  Copyright (c) 2001-2013 ATTO Technology, Inc.
6  *  (mailto:linuxdrivers@attotech.com)
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * NO WARRANTY
19  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
20  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
21  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
22  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
23  * solely responsible for determining the appropriateness of using and
24  * distributing the Program and assumes all risks associated with its
25  * exercise of rights under this Agreement, including but not limited to
26  * the risks and costs of program errors, damage to or loss of data,
27  * programs or equipment, and unavailability or interruption of operations.
28  *
29  * DISCLAIMER OF LIABILITY
30  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
31  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
33  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
35  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
36  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
37  *
38  * You should have received a copy of the GNU General Public License
39  * along with this program; if not, write to the Free Software
40  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
41  * USA.
42  */
43 
44 #include "esas2r.h"
45 
46 MODULE_DESCRIPTION(ESAS2R_DRVR_NAME ": " ESAS2R_LONGNAME " driver");
47 MODULE_AUTHOR("ATTO Technology, Inc.");
48 MODULE_LICENSE("GPL");
49 MODULE_VERSION(ESAS2R_VERSION_STR);
50 
51 /* global definitions */
52 
53 static int found_adapters;
54 struct esas2r_adapter *esas2r_adapters[MAX_ADAPTERS];
55 
56 #define ESAS2R_VDA_EVENT_PORT1       54414
57 #define ESAS2R_VDA_EVENT_PORT2       54415
58 #define ESAS2R_VDA_EVENT_SOCK_COUNT  2
59 
60 static struct esas2r_adapter *esas2r_adapter_from_kobj(struct kobject *kobj)
61 {
62 	struct device *dev = container_of(kobj, struct device, kobj);
63 	struct Scsi_Host *host = class_to_shost(dev);
64 
65 	return (struct esas2r_adapter *)host->hostdata;
66 }
67 
68 static ssize_t read_fw(struct file *file, struct kobject *kobj,
69 		       struct bin_attribute *attr,
70 		       char *buf, loff_t off, size_t count)
71 {
72 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
73 
74 	return esas2r_read_fw(a, buf, off, count);
75 }
76 
77 static ssize_t write_fw(struct file *file, struct kobject *kobj,
78 			struct bin_attribute *attr,
79 			char *buf, loff_t off, size_t count)
80 {
81 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
82 
83 	return esas2r_write_fw(a, buf, off, count);
84 }
85 
86 static ssize_t read_fs(struct file *file, struct kobject *kobj,
87 		       struct bin_attribute *attr,
88 		       char *buf, loff_t off, size_t count)
89 {
90 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
91 
92 	return esas2r_read_fs(a, buf, off, count);
93 }
94 
95 static ssize_t write_fs(struct file *file, struct kobject *kobj,
96 			struct bin_attribute *attr,
97 			char *buf, loff_t off, size_t count)
98 {
99 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
100 	int length = min(sizeof(struct esas2r_ioctl_fs), count);
101 	int result = 0;
102 
103 	result = esas2r_write_fs(a, buf, off, count);
104 
105 	if (result < 0)
106 		result = 0;
107 
108 	return length;
109 }
110 
111 static ssize_t read_vda(struct file *file, struct kobject *kobj,
112 			struct bin_attribute *attr,
113 			char *buf, loff_t off, size_t count)
114 {
115 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
116 
117 	return esas2r_read_vda(a, buf, off, count);
118 }
119 
120 static ssize_t write_vda(struct file *file, struct kobject *kobj,
121 			 struct bin_attribute *attr,
122 			 char *buf, loff_t off, size_t count)
123 {
124 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
125 
126 	return esas2r_write_vda(a, buf, off, count);
127 }
128 
129 static ssize_t read_live_nvram(struct file *file, struct kobject *kobj,
130 			       struct bin_attribute *attr,
131 			       char *buf, loff_t off, size_t count)
132 {
133 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
134 	int length = min_t(size_t, sizeof(struct esas2r_sas_nvram), PAGE_SIZE);
135 
136 	memcpy(buf, a->nvram, length);
137 	return length;
138 }
139 
140 static ssize_t write_live_nvram(struct file *file, struct kobject *kobj,
141 				struct bin_attribute *attr,
142 				char *buf, loff_t off, size_t count)
143 {
144 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
145 	struct esas2r_request *rq;
146 	int result = -EFAULT;
147 
148 	rq = esas2r_alloc_request(a);
149 	if (rq == NULL)
150 		return -ENOMEM;
151 
152 	if (esas2r_write_params(a, rq, (struct esas2r_sas_nvram *)buf))
153 		result = count;
154 
155 	esas2r_free_request(a, rq);
156 
157 	return result;
158 }
159 
160 static ssize_t read_default_nvram(struct file *file, struct kobject *kobj,
161 				  struct bin_attribute *attr,
162 				  char *buf, loff_t off, size_t count)
163 {
164 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
165 
166 	esas2r_nvram_get_defaults(a, (struct esas2r_sas_nvram *)buf);
167 
168 	return sizeof(struct esas2r_sas_nvram);
169 }
170 
171 static ssize_t read_hw(struct file *file, struct kobject *kobj,
172 		       struct bin_attribute *attr,
173 		       char *buf, loff_t off, size_t count)
174 {
175 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
176 	int length = min_t(size_t, sizeof(struct atto_ioctl), PAGE_SIZE);
177 
178 	if (!a->local_atto_ioctl)
179 		return -ENOMEM;
180 
181 	if (handle_hba_ioctl(a, a->local_atto_ioctl) != IOCTL_SUCCESS)
182 		return -ENOMEM;
183 
184 	memcpy(buf, a->local_atto_ioctl, length);
185 
186 	return length;
187 }
188 
189 static ssize_t write_hw(struct file *file, struct kobject *kobj,
190 			struct bin_attribute *attr,
191 			char *buf, loff_t off, size_t count)
192 {
193 	struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
194 	int length = min(sizeof(struct atto_ioctl), count);
195 
196 	if (!a->local_atto_ioctl) {
197 		a->local_atto_ioctl = kzalloc(sizeof(struct atto_ioctl),
198 					      GFP_KERNEL);
199 		if (a->local_atto_ioctl == NULL) {
200 			esas2r_log(ESAS2R_LOG_WARN,
201 				   "write_hw kzalloc failed for %d bytes",
202 				   sizeof(struct atto_ioctl));
203 			return -ENOMEM;
204 		}
205 	}
206 
207 	memset(a->local_atto_ioctl, 0, sizeof(struct atto_ioctl));
208 	memcpy(a->local_atto_ioctl, buf, length);
209 
210 	return length;
211 }
212 
213 #define ESAS2R_RW_BIN_ATTR(_name) \
214 	struct bin_attribute bin_attr_ ## _name = { \
215 		.attr	= \
216 		{ .name = __stringify(_name), .mode  = S_IRUSR | S_IWUSR }, \
217 		.size	= 0, \
218 		.read	= read_ ## _name, \
219 		.write	= write_ ## _name }
220 
221 ESAS2R_RW_BIN_ATTR(fw);
222 ESAS2R_RW_BIN_ATTR(fs);
223 ESAS2R_RW_BIN_ATTR(vda);
224 ESAS2R_RW_BIN_ATTR(hw);
225 ESAS2R_RW_BIN_ATTR(live_nvram);
226 
227 struct bin_attribute bin_attr_default_nvram = {
228 	.attr	= { .name = "default_nvram", .mode = S_IRUGO },
229 	.size	= 0,
230 	.read	= read_default_nvram,
231 	.write	= NULL
232 };
233 
234 static struct scsi_host_template driver_template = {
235 	.module				= THIS_MODULE,
236 	.show_info			= esas2r_show_info,
237 	.name				= ESAS2R_LONGNAME,
238 	.release			= esas2r_release,
239 	.info				= esas2r_info,
240 	.ioctl				= esas2r_ioctl,
241 	.queuecommand			= esas2r_queuecommand,
242 	.eh_abort_handler		= esas2r_eh_abort,
243 	.eh_device_reset_handler	= esas2r_device_reset,
244 	.eh_bus_reset_handler		= esas2r_bus_reset,
245 	.eh_host_reset_handler		= esas2r_host_reset,
246 	.eh_target_reset_handler	= esas2r_target_reset,
247 	.can_queue			= 128,
248 	.this_id			= -1,
249 	.sg_tablesize			= SCSI_MAX_SG_SEGMENTS,
250 	.cmd_per_lun			=
251 		ESAS2R_DEFAULT_CMD_PER_LUN,
252 	.present			= 0,
253 	.unchecked_isa_dma		= 0,
254 	.use_clustering			= ENABLE_CLUSTERING,
255 	.emulated			= 0,
256 	.proc_name			= ESAS2R_DRVR_NAME,
257 	.change_queue_depth		= scsi_change_queue_depth,
258 	.max_sectors			= 0xFFFF,
259 };
260 
261 int sgl_page_size = 512;
262 module_param(sgl_page_size, int, 0);
263 MODULE_PARM_DESC(sgl_page_size,
264 		 "Scatter/gather list (SGL) page size in number of S/G "
265 		 "entries.  If your application is doing a lot of very large "
266 		 "transfers, you may want to increase the SGL page size.  "
267 		 "Default 512.");
268 
269 int num_sg_lists = 1024;
270 module_param(num_sg_lists, int, 0);
271 MODULE_PARM_DESC(num_sg_lists,
272 		 "Number of scatter/gather lists.  Default 1024.");
273 
274 int sg_tablesize = SCSI_MAX_SG_SEGMENTS;
275 module_param(sg_tablesize, int, 0);
276 MODULE_PARM_DESC(sg_tablesize,
277 		 "Maximum number of entries in a scatter/gather table.");
278 
279 int num_requests = 256;
280 module_param(num_requests, int, 0);
281 MODULE_PARM_DESC(num_requests,
282 		 "Number of requests.  Default 256.");
283 
284 int num_ae_requests = 4;
285 module_param(num_ae_requests, int, 0);
286 MODULE_PARM_DESC(num_ae_requests,
287 		 "Number of VDA asynchromous event requests.  Default 4.");
288 
289 int cmd_per_lun = ESAS2R_DEFAULT_CMD_PER_LUN;
290 module_param(cmd_per_lun, int, 0);
291 MODULE_PARM_DESC(cmd_per_lun,
292 		 "Maximum number of commands per LUN.  Default "
293 		 DEFINED_NUM_TO_STR(ESAS2R_DEFAULT_CMD_PER_LUN) ".");
294 
295 int can_queue = 128;
296 module_param(can_queue, int, 0);
297 MODULE_PARM_DESC(can_queue,
298 		 "Maximum number of commands per adapter.  Default 128.");
299 
300 int esas2r_max_sectors = 0xFFFF;
301 module_param(esas2r_max_sectors, int, 0);
302 MODULE_PARM_DESC(esas2r_max_sectors,
303 		 "Maximum number of disk sectors in a single data transfer.  "
304 		 "Default 65535 (largest possible setting).");
305 
306 int interrupt_mode = 1;
307 module_param(interrupt_mode, int, 0);
308 MODULE_PARM_DESC(interrupt_mode,
309 		 "Defines the interrupt mode to use.  0 for legacy"
310 		 ", 1 for MSI.  Default is MSI (1).");
311 
312 static struct pci_device_id
313 	esas2r_pci_table[] = {
314 	{ ATTO_VENDOR_ID, 0x0049,	  ATTO_VENDOR_ID, 0x0049,
315 	  0,
316 	  0, 0 },
317 	{ ATTO_VENDOR_ID, 0x0049,	  ATTO_VENDOR_ID, 0x004A,
318 	  0,
319 	  0, 0 },
320 	{ ATTO_VENDOR_ID, 0x0049,	  ATTO_VENDOR_ID, 0x004B,
321 	  0,
322 	  0, 0 },
323 	{ ATTO_VENDOR_ID, 0x0049,	  ATTO_VENDOR_ID, 0x004C,
324 	  0,
325 	  0, 0 },
326 	{ ATTO_VENDOR_ID, 0x0049,	  ATTO_VENDOR_ID, 0x004D,
327 	  0,
328 	  0, 0 },
329 	{ ATTO_VENDOR_ID, 0x0049,	  ATTO_VENDOR_ID, 0x004E,
330 	  0,
331 	  0, 0 },
332 	{ 0,		  0,		  0,		  0,
333 	  0,
334 	  0, 0 }
335 };
336 
337 MODULE_DEVICE_TABLE(pci, esas2r_pci_table);
338 
339 static int
340 esas2r_probe(struct pci_dev *pcid, const struct pci_device_id *id);
341 
342 static void
343 esas2r_remove(struct pci_dev *pcid);
344 
345 static struct pci_driver
346 	esas2r_pci_driver = {
347 	.name		= ESAS2R_DRVR_NAME,
348 	.id_table	= esas2r_pci_table,
349 	.probe		= esas2r_probe,
350 	.remove		= esas2r_remove,
351 	.suspend	= esas2r_suspend,
352 	.resume		= esas2r_resume,
353 };
354 
355 static int esas2r_probe(struct pci_dev *pcid,
356 			const struct pci_device_id *id)
357 {
358 	struct Scsi_Host *host = NULL;
359 	struct esas2r_adapter *a;
360 	int err;
361 
362 	size_t host_alloc_size = sizeof(struct esas2r_adapter)
363 				 + ((num_requests) +
364 				    1) * sizeof(struct esas2r_request);
365 
366 	esas2r_log_dev(ESAS2R_LOG_DEBG, &(pcid->dev),
367 		       "esas2r_probe() 0x%02x 0x%02x 0x%02x 0x%02x",
368 		       pcid->vendor,
369 		       pcid->device,
370 		       pcid->subsystem_vendor,
371 		       pcid->subsystem_device);
372 
373 	esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
374 		       "before pci_enable_device() "
375 		       "enable_cnt: %d",
376 		       pcid->enable_cnt.counter);
377 
378 	err = pci_enable_device(pcid);
379 	if (err != 0) {
380 		esas2r_log_dev(ESAS2R_LOG_CRIT, &(pcid->dev),
381 			       "pci_enable_device() FAIL (%d)",
382 			       err);
383 		return -ENODEV;
384 	}
385 
386 	esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
387 		       "pci_enable_device() OK");
388 	esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
389 		       "after pci_enable_device() enable_cnt: %d",
390 		       pcid->enable_cnt.counter);
391 
392 	host = scsi_host_alloc(&driver_template, host_alloc_size);
393 	if (host == NULL) {
394 		esas2r_log(ESAS2R_LOG_CRIT, "scsi_host_alloc() FAIL");
395 		return -ENODEV;
396 	}
397 
398 	memset(host->hostdata, 0, host_alloc_size);
399 
400 	a = (struct esas2r_adapter *)host->hostdata;
401 
402 	esas2r_log(ESAS2R_LOG_INFO, "scsi_host_alloc() OK host: %p", host);
403 
404 	/* override max LUN and max target id */
405 
406 	host->max_id = ESAS2R_MAX_ID + 1;
407 	host->max_lun = 255;
408 
409 	/* we can handle 16-byte CDbs */
410 
411 	host->max_cmd_len = 16;
412 
413 	host->can_queue = can_queue;
414 	host->cmd_per_lun = cmd_per_lun;
415 	host->this_id = host->max_id + 1;
416 	host->max_channel = 0;
417 	host->unique_id = found_adapters;
418 	host->sg_tablesize = sg_tablesize;
419 	host->max_sectors = esas2r_max_sectors;
420 
421 	/* set to bus master for BIOses that don't do it for us */
422 
423 	esas2r_log(ESAS2R_LOG_INFO, "pci_set_master() called");
424 
425 	pci_set_master(pcid);
426 
427 	if (!esas2r_init_adapter(host, pcid, found_adapters)) {
428 		esas2r_log(ESAS2R_LOG_CRIT,
429 			   "unable to initialize device at PCI bus %x:%x",
430 			   pcid->bus->number,
431 			   pcid->devfn);
432 
433 		esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
434 			       "scsi_host_put() called");
435 
436 		scsi_host_put(host);
437 
438 		return 0;
439 
440 	}
441 
442 	esas2r_log(ESAS2R_LOG_INFO, "pci_set_drvdata(%p, %p) called", pcid,
443 		   host->hostdata);
444 
445 	pci_set_drvdata(pcid, host);
446 
447 	esas2r_log(ESAS2R_LOG_INFO, "scsi_add_host() called");
448 
449 	err = scsi_add_host(host, &pcid->dev);
450 
451 	if (err) {
452 		esas2r_log(ESAS2R_LOG_CRIT, "scsi_add_host returned %d", err);
453 		esas2r_log_dev(ESAS2R_LOG_CRIT, &(host->shost_gendev),
454 			       "scsi_add_host() FAIL");
455 
456 		esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
457 			       "scsi_host_put() called");
458 
459 		scsi_host_put(host);
460 
461 		esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
462 			       "pci_set_drvdata(%p, NULL) called",
463 			       pcid);
464 
465 		pci_set_drvdata(pcid, NULL);
466 
467 		return -ENODEV;
468 	}
469 
470 
471 	esas2r_fw_event_on(a);
472 
473 	esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
474 		       "scsi_scan_host() called");
475 
476 	scsi_scan_host(host);
477 
478 	/* Add sysfs binary files */
479 	if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fw))
480 		esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
481 			       "Failed to create sysfs binary file: fw");
482 	else
483 		a->sysfs_fw_created = 1;
484 
485 	if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fs))
486 		esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
487 			       "Failed to create sysfs binary file: fs");
488 	else
489 		a->sysfs_fs_created = 1;
490 
491 	if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_vda))
492 		esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
493 			       "Failed to create sysfs binary file: vda");
494 	else
495 		a->sysfs_vda_created = 1;
496 
497 	if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_hw))
498 		esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
499 			       "Failed to create sysfs binary file: hw");
500 	else
501 		a->sysfs_hw_created = 1;
502 
503 	if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_live_nvram))
504 		esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
505 			       "Failed to create sysfs binary file: live_nvram");
506 	else
507 		a->sysfs_live_nvram_created = 1;
508 
509 	if (sysfs_create_bin_file(&host->shost_dev.kobj,
510 				  &bin_attr_default_nvram))
511 		esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
512 			       "Failed to create sysfs binary file: default_nvram");
513 	else
514 		a->sysfs_default_nvram_created = 1;
515 
516 	found_adapters++;
517 
518 	return 0;
519 }
520 
521 static void esas2r_remove(struct pci_dev *pdev)
522 {
523 	struct Scsi_Host *host;
524 	int index;
525 
526 	if (pdev == NULL) {
527 		esas2r_log(ESAS2R_LOG_WARN, "esas2r_remove pdev==NULL");
528 		return;
529 	}
530 
531 	host = pci_get_drvdata(pdev);
532 
533 	if (host == NULL) {
534 		/*
535 		 * this can happen if pci_set_drvdata was already called
536 		 * to clear the host pointer.  if this is the case, we
537 		 * are okay; this channel has already been cleaned up.
538 		 */
539 
540 		return;
541 	}
542 
543 	esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
544 		       "esas2r_remove(%p) called; "
545 		       "host:%p", pdev,
546 		       host);
547 
548 	index = esas2r_cleanup(host);
549 
550 	if (index < 0)
551 		esas2r_log_dev(ESAS2R_LOG_WARN, &(pdev->dev),
552 			       "unknown host in %s",
553 			       __func__);
554 
555 	found_adapters--;
556 
557 	/* if this was the last adapter, clean up the rest of the driver */
558 
559 	if (found_adapters == 0)
560 		esas2r_cleanup(NULL);
561 }
562 
563 static int __init esas2r_init(void)
564 {
565 	int i;
566 
567 	esas2r_log(ESAS2R_LOG_INFO, "%s called", __func__);
568 
569 	/* verify valid parameters */
570 
571 	if (can_queue < 1) {
572 		esas2r_log(ESAS2R_LOG_WARN,
573 			   "warning: can_queue must be at least 1, value "
574 			   "forced.");
575 		can_queue = 1;
576 	} else if (can_queue > 2048) {
577 		esas2r_log(ESAS2R_LOG_WARN,
578 			   "warning: can_queue must be no larger than 2048, "
579 			   "value forced.");
580 		can_queue = 2048;
581 	}
582 
583 	if (cmd_per_lun < 1) {
584 		esas2r_log(ESAS2R_LOG_WARN,
585 			   "warning: cmd_per_lun must be at least 1, value "
586 			   "forced.");
587 		cmd_per_lun = 1;
588 	} else if (cmd_per_lun > 2048) {
589 		esas2r_log(ESAS2R_LOG_WARN,
590 			   "warning: cmd_per_lun must be no larger than "
591 			   "2048, value forced.");
592 		cmd_per_lun = 2048;
593 	}
594 
595 	if (sg_tablesize < 32) {
596 		esas2r_log(ESAS2R_LOG_WARN,
597 			   "warning: sg_tablesize must be at least 32, "
598 			   "value forced.");
599 		sg_tablesize = 32;
600 	}
601 
602 	if (esas2r_max_sectors < 1) {
603 		esas2r_log(ESAS2R_LOG_WARN,
604 			   "warning: esas2r_max_sectors must be at least "
605 			   "1, value forced.");
606 		esas2r_max_sectors = 1;
607 	} else if (esas2r_max_sectors > 0xffff) {
608 		esas2r_log(ESAS2R_LOG_WARN,
609 			   "warning: esas2r_max_sectors must be no larger "
610 			   "than 0xffff, value forced.");
611 		esas2r_max_sectors = 0xffff;
612 	}
613 
614 	sgl_page_size &= ~(ESAS2R_SGL_ALIGN - 1);
615 
616 	if (sgl_page_size < SGL_PG_SZ_MIN)
617 		sgl_page_size = SGL_PG_SZ_MIN;
618 	else if (sgl_page_size > SGL_PG_SZ_MAX)
619 		sgl_page_size = SGL_PG_SZ_MAX;
620 
621 	if (num_sg_lists < NUM_SGL_MIN)
622 		num_sg_lists = NUM_SGL_MIN;
623 	else if (num_sg_lists > NUM_SGL_MAX)
624 		num_sg_lists = NUM_SGL_MAX;
625 
626 	if (num_requests < NUM_REQ_MIN)
627 		num_requests = NUM_REQ_MIN;
628 	else if (num_requests > NUM_REQ_MAX)
629 		num_requests = NUM_REQ_MAX;
630 
631 	if (num_ae_requests < NUM_AE_MIN)
632 		num_ae_requests = NUM_AE_MIN;
633 	else if (num_ae_requests > NUM_AE_MAX)
634 		num_ae_requests = NUM_AE_MAX;
635 
636 	/* set up other globals */
637 
638 	for (i = 0; i < MAX_ADAPTERS; i++)
639 		esas2r_adapters[i] = NULL;
640 
641 	/* initialize */
642 
643 	driver_template.module = THIS_MODULE;
644 
645 	if (pci_register_driver(&esas2r_pci_driver) != 0)
646 		esas2r_log(ESAS2R_LOG_CRIT, "pci_register_driver FAILED");
647 	else
648 		esas2r_log(ESAS2R_LOG_INFO, "pci_register_driver() OK");
649 
650 	if (!found_adapters) {
651 		pci_unregister_driver(&esas2r_pci_driver);
652 		esas2r_cleanup(NULL);
653 
654 		esas2r_log(ESAS2R_LOG_CRIT,
655 			   "driver will not be loaded because no ATTO "
656 			   "%s devices were found",
657 			   ESAS2R_DRVR_NAME);
658 		return -1;
659 	} else {
660 		esas2r_log(ESAS2R_LOG_INFO, "found %d adapters",
661 			   found_adapters);
662 	}
663 
664 	return 0;
665 }
666 
667 /* Handle ioctl calls to "/proc/scsi/esas2r/ATTOnode" */
668 static const struct file_operations esas2r_proc_fops = {
669 	.compat_ioctl	= esas2r_proc_ioctl,
670 	.unlocked_ioctl = esas2r_proc_ioctl,
671 };
672 
673 static struct Scsi_Host *esas2r_proc_host;
674 static int esas2r_proc_major;
675 
676 long esas2r_proc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
677 {
678 	return esas2r_ioctl_handler(esas2r_proc_host->hostdata,
679 				    (int)cmd, (void __user *)arg);
680 }
681 
682 static void __exit esas2r_exit(void)
683 {
684 	esas2r_log(ESAS2R_LOG_INFO, "%s called", __func__);
685 
686 	if (esas2r_proc_major > 0) {
687 		esas2r_log(ESAS2R_LOG_INFO, "unregister proc");
688 
689 		remove_proc_entry(ATTONODE_NAME,
690 				  esas2r_proc_host->hostt->proc_dir);
691 		unregister_chrdev(esas2r_proc_major, ESAS2R_DRVR_NAME);
692 
693 		esas2r_proc_major = 0;
694 	}
695 
696 	esas2r_log(ESAS2R_LOG_INFO, "pci_unregister_driver() called");
697 
698 	pci_unregister_driver(&esas2r_pci_driver);
699 }
700 
701 int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh)
702 {
703 	struct esas2r_adapter *a = (struct esas2r_adapter *)sh->hostdata;
704 
705 	struct esas2r_target *t;
706 	int dev_count = 0;
707 
708 	esas2r_log(ESAS2R_LOG_DEBG, "esas2r_show_info (%p,%d)", m, sh->host_no);
709 
710 	seq_printf(m, ESAS2R_LONGNAME "\n"
711 		   "Driver version: "ESAS2R_VERSION_STR "\n"
712 		   "Flash version: %s\n"
713 		   "Firmware version: %s\n"
714 		   "Copyright "ESAS2R_COPYRIGHT_YEARS "\n"
715 		   "http://www.attotech.com\n"
716 		   "\n",
717 		   a->flash_rev,
718 		   a->fw_rev[0] ? a->fw_rev : "(none)");
719 
720 
721 	seq_printf(m, "Adapter information:\n"
722 		   "--------------------\n"
723 		   "Model: %s\n"
724 		   "SAS address: %02X%02X%02X%02X:%02X%02X%02X%02X\n",
725 		   esas2r_get_model_name(a),
726 		   a->nvram->sas_addr[0],
727 		   a->nvram->sas_addr[1],
728 		   a->nvram->sas_addr[2],
729 		   a->nvram->sas_addr[3],
730 		   a->nvram->sas_addr[4],
731 		   a->nvram->sas_addr[5],
732 		   a->nvram->sas_addr[6],
733 		   a->nvram->sas_addr[7]);
734 
735 	seq_puts(m, "\n"
736 		   "Discovered devices:\n"
737 		   "\n"
738 		   "   #  Target ID\n"
739 		   "---------------\n");
740 
741 	for (t = a->targetdb; t < a->targetdb_end; t++)
742 		if (t->buffered_target_state == TS_PRESENT) {
743 			seq_printf(m, " %3d   %3d\n",
744 				   ++dev_count,
745 				   (u16)(uintptr_t)(t - a->targetdb));
746 		}
747 
748 	if (dev_count == 0)
749 		seq_puts(m, "none\n");
750 
751 	seq_putc(m, '\n');
752 	return 0;
753 
754 }
755 
756 int esas2r_release(struct Scsi_Host *sh)
757 {
758 	esas2r_log_dev(ESAS2R_LOG_INFO, &(sh->shost_gendev),
759 		       "esas2r_release() called");
760 
761 	esas2r_cleanup(sh);
762 	if (sh->irq)
763 		free_irq(sh->irq, NULL);
764 	scsi_unregister(sh);
765 	return 0;
766 }
767 
768 const char *esas2r_info(struct Scsi_Host *sh)
769 {
770 	struct esas2r_adapter *a = (struct esas2r_adapter *)sh->hostdata;
771 	static char esas2r_info_str[512];
772 
773 	esas2r_log_dev(ESAS2R_LOG_INFO, &(sh->shost_gendev),
774 		       "esas2r_info() called");
775 
776 	/*
777 	 * if we haven't done so already, register as a char driver
778 	 * and stick a node under "/proc/scsi/esas2r/ATTOnode"
779 	 */
780 
781 	if (esas2r_proc_major <= 0) {
782 		esas2r_proc_host = sh;
783 
784 		esas2r_proc_major = register_chrdev(0, ESAS2R_DRVR_NAME,
785 						    &esas2r_proc_fops);
786 
787 		esas2r_log_dev(ESAS2R_LOG_DEBG, &(sh->shost_gendev),
788 			       "register_chrdev (major %d)",
789 			       esas2r_proc_major);
790 
791 		if (esas2r_proc_major > 0) {
792 			struct proc_dir_entry *pde;
793 
794 			pde = proc_create(ATTONODE_NAME, 0,
795 					  sh->hostt->proc_dir,
796 					  &esas2r_proc_fops);
797 
798 			if (!pde) {
799 				esas2r_log_dev(ESAS2R_LOG_WARN,
800 					       &(sh->shost_gendev),
801 					       "failed to create_proc_entry");
802 				esas2r_proc_major = -1;
803 			}
804 		}
805 	}
806 
807 	sprintf(esas2r_info_str,
808 		ESAS2R_LONGNAME " (bus 0x%02X, device 0x%02X, IRQ 0x%02X)"
809 		" driver version: "ESAS2R_VERSION_STR "  firmware version: "
810 		"%s\n",
811 		a->pcid->bus->number, a->pcid->devfn, a->pcid->irq,
812 		a->fw_rev[0] ? a->fw_rev : "(none)");
813 
814 	return esas2r_info_str;
815 }
816 
817 /* Callback for building a request scatter/gather list */
818 static u32 get_physaddr_from_sgc(struct esas2r_sg_context *sgc, u64 *addr)
819 {
820 	u32 len;
821 
822 	if (likely(sgc->cur_offset == sgc->exp_offset)) {
823 		/*
824 		 * the normal case: caller used all bytes from previous call, so
825 		 * expected offset is the same as the current offset.
826 		 */
827 
828 		if (sgc->sgel_count < sgc->num_sgel) {
829 			/* retrieve next segment, except for first time */
830 			if (sgc->exp_offset > (u8 *)0) {
831 				/* advance current segment */
832 				sgc->cur_sgel = sg_next(sgc->cur_sgel);
833 				++(sgc->sgel_count);
834 			}
835 
836 
837 			len = sg_dma_len(sgc->cur_sgel);
838 			(*addr) = sg_dma_address(sgc->cur_sgel);
839 
840 			/* save the total # bytes returned to caller so far */
841 			sgc->exp_offset += len;
842 
843 		} else {
844 			len = 0;
845 		}
846 	} else if (sgc->cur_offset < sgc->exp_offset) {
847 		/*
848 		 * caller did not use all bytes from previous call. need to
849 		 * compute the address based on current segment.
850 		 */
851 
852 		len = sg_dma_len(sgc->cur_sgel);
853 		(*addr) = sg_dma_address(sgc->cur_sgel);
854 
855 		sgc->exp_offset -= len;
856 
857 		/* calculate PA based on prev segment address and offsets */
858 		*addr = *addr +
859 			(sgc->cur_offset - sgc->exp_offset);
860 
861 		sgc->exp_offset += len;
862 
863 		/* re-calculate length based on offset */
864 		len = lower_32_bits(
865 			sgc->exp_offset - sgc->cur_offset);
866 	} else {   /* if ( sgc->cur_offset > sgc->exp_offset ) */
867 		   /*
868 		    * we don't expect the caller to skip ahead.
869 		    * cur_offset will never exceed the len we return
870 		    */
871 		len = 0;
872 	}
873 
874 	return len;
875 }
876 
877 int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
878 {
879 	struct esas2r_adapter *a =
880 		(struct esas2r_adapter *)cmd->device->host->hostdata;
881 	struct esas2r_request *rq;
882 	struct esas2r_sg_context sgc;
883 	unsigned bufflen;
884 
885 	/* Assume success, if it fails we will fix the result later. */
886 	cmd->result = DID_OK << 16;
887 
888 	if (unlikely(test_bit(AF_DEGRADED_MODE, &a->flags))) {
889 		cmd->result = DID_NO_CONNECT << 16;
890 		cmd->scsi_done(cmd);
891 		return 0;
892 	}
893 
894 	rq = esas2r_alloc_request(a);
895 	if (unlikely(rq == NULL)) {
896 		esas2r_debug("esas2r_alloc_request failed");
897 		return SCSI_MLQUEUE_HOST_BUSY;
898 	}
899 
900 	rq->cmd = cmd;
901 	bufflen = scsi_bufflen(cmd);
902 
903 	if (likely(bufflen != 0)) {
904 		if (cmd->sc_data_direction == DMA_TO_DEVICE)
905 			rq->vrq->scsi.flags |= cpu_to_le32(FCP_CMND_WRD);
906 		else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
907 			rq->vrq->scsi.flags |= cpu_to_le32(FCP_CMND_RDD);
908 	}
909 
910 	memcpy(rq->vrq->scsi.cdb, cmd->cmnd, cmd->cmd_len);
911 	rq->vrq->scsi.length = cpu_to_le32(bufflen);
912 	rq->target_id = cmd->device->id;
913 	rq->vrq->scsi.flags |= cpu_to_le32(cmd->device->lun);
914 	rq->sense_buf = cmd->sense_buffer;
915 	rq->sense_len = SCSI_SENSE_BUFFERSIZE;
916 
917 	esas2r_sgc_init(&sgc, a, rq, NULL);
918 
919 	sgc.length = bufflen;
920 	sgc.cur_offset = NULL;
921 
922 	sgc.cur_sgel = scsi_sglist(cmd);
923 	sgc.exp_offset = NULL;
924 	sgc.num_sgel = scsi_dma_map(cmd);
925 	sgc.sgel_count = 0;
926 
927 	if (unlikely(sgc.num_sgel < 0)) {
928 		esas2r_free_request(a, rq);
929 		return SCSI_MLQUEUE_HOST_BUSY;
930 	}
931 
932 	sgc.get_phys_addr = (PGETPHYSADDR)get_physaddr_from_sgc;
933 
934 	if (unlikely(!esas2r_build_sg_list(a, rq, &sgc))) {
935 		scsi_dma_unmap(cmd);
936 		esas2r_free_request(a, rq);
937 		return SCSI_MLQUEUE_HOST_BUSY;
938 	}
939 
940 	esas2r_debug("start request %p to %d:%d\n", rq, (int)cmd->device->id,
941 		     (int)cmd->device->lun);
942 
943 	esas2r_start_request(a, rq);
944 
945 	return 0;
946 }
947 
948 static void complete_task_management_request(struct esas2r_adapter *a,
949 					     struct esas2r_request *rq)
950 {
951 	(*rq->task_management_status_ptr) = rq->req_stat;
952 	esas2r_free_request(a, rq);
953 }
954 
955 /**
956  * Searches the specified queue for the specified queue for the command
957  * to abort.
958  *
959  * @param [in] a
960  * @param [in] abort_request
961  * @param [in] cmd
962  * t
963  * @return 0 on failure, 1 if command was not found, 2 if command was found
964  */
965 static int esas2r_check_active_queue(struct esas2r_adapter *a,
966 				     struct esas2r_request **abort_request,
967 				     struct scsi_cmnd *cmd,
968 				     struct list_head *queue)
969 {
970 	bool found = false;
971 	struct esas2r_request *ar = *abort_request;
972 	struct esas2r_request *rq;
973 	struct list_head *element, *next;
974 
975 	list_for_each_safe(element, next, queue) {
976 
977 		rq = list_entry(element, struct esas2r_request, req_list);
978 
979 		if (rq->cmd == cmd) {
980 
981 			/* Found the request.  See what to do with it. */
982 			if (queue == &a->active_list) {
983 				/*
984 				 * We are searching the active queue, which
985 				 * means that we need to send an abort request
986 				 * to the firmware.
987 				 */
988 				ar = esas2r_alloc_request(a);
989 				if (ar == NULL) {
990 					esas2r_log_dev(ESAS2R_LOG_WARN,
991 						       &(a->host->shost_gendev),
992 						       "unable to allocate an abort request for cmd %p",
993 						       cmd);
994 					return 0; /* Failure */
995 				}
996 
997 				/*
998 				 * Task management request must be formatted
999 				 * with a lock held.
1000 				 */
1001 				ar->sense_len = 0;
1002 				ar->vrq->scsi.length = 0;
1003 				ar->target_id = rq->target_id;
1004 				ar->vrq->scsi.flags |= cpu_to_le32(
1005 					(u8)le32_to_cpu(rq->vrq->scsi.flags));
1006 
1007 				memset(ar->vrq->scsi.cdb, 0,
1008 				       sizeof(ar->vrq->scsi.cdb));
1009 
1010 				ar->vrq->scsi.flags |= cpu_to_le32(
1011 					FCP_CMND_TRM);
1012 				ar->vrq->scsi.u.abort_handle =
1013 					rq->vrq->scsi.handle;
1014 			} else {
1015 				/*
1016 				 * The request is pending but not active on
1017 				 * the firmware.  Just free it now and we'll
1018 				 * report the successful abort below.
1019 				 */
1020 				list_del_init(&rq->req_list);
1021 				esas2r_free_request(a, rq);
1022 			}
1023 
1024 			found = true;
1025 			break;
1026 		}
1027 
1028 	}
1029 
1030 	if (!found)
1031 		return 1;       /* Not found */
1032 
1033 	return 2;               /* found */
1034 
1035 
1036 }
1037 
1038 int esas2r_eh_abort(struct scsi_cmnd *cmd)
1039 {
1040 	struct esas2r_adapter *a =
1041 		(struct esas2r_adapter *)cmd->device->host->hostdata;
1042 	struct esas2r_request *abort_request = NULL;
1043 	unsigned long flags;
1044 	struct list_head *queue;
1045 	int result;
1046 
1047 	esas2r_log(ESAS2R_LOG_INFO, "eh_abort (%p)", cmd);
1048 
1049 	if (test_bit(AF_DEGRADED_MODE, &a->flags)) {
1050 		cmd->result = DID_ABORT << 16;
1051 
1052 		scsi_set_resid(cmd, 0);
1053 
1054 		cmd->scsi_done(cmd);
1055 
1056 		return SUCCESS;
1057 	}
1058 
1059 	spin_lock_irqsave(&a->queue_lock, flags);
1060 
1061 	/*
1062 	 * Run through the defer and active queues looking for the request
1063 	 * to abort.
1064 	 */
1065 
1066 	queue = &a->defer_list;
1067 
1068 check_active_queue:
1069 
1070 	result = esas2r_check_active_queue(a, &abort_request, cmd, queue);
1071 
1072 	if (!result) {
1073 		spin_unlock_irqrestore(&a->queue_lock, flags);
1074 		return FAILED;
1075 	} else if (result == 2 && (queue == &a->defer_list)) {
1076 		queue = &a->active_list;
1077 		goto check_active_queue;
1078 	}
1079 
1080 	spin_unlock_irqrestore(&a->queue_lock, flags);
1081 
1082 	if (abort_request) {
1083 		u8 task_management_status = RS_PENDING;
1084 
1085 		/*
1086 		 * the request is already active, so we need to tell
1087 		 * the firmware to abort it and wait for the response.
1088 		 */
1089 
1090 		abort_request->comp_cb = complete_task_management_request;
1091 		abort_request->task_management_status_ptr =
1092 			&task_management_status;
1093 
1094 		esas2r_start_request(a, abort_request);
1095 
1096 		if (atomic_read(&a->disable_cnt) == 0)
1097 			esas2r_do_deferred_processes(a);
1098 
1099 		while (task_management_status == RS_PENDING)
1100 			msleep(10);
1101 
1102 		/*
1103 		 * Once we get here, the original request will have been
1104 		 * completed by the firmware and the abort request will have
1105 		 * been cleaned up.  we're done!
1106 		 */
1107 
1108 		return SUCCESS;
1109 	}
1110 
1111 	/*
1112 	 * If we get here, either we found the inactive request and
1113 	 * freed it, or we didn't find it at all.  Either way, success!
1114 	 */
1115 
1116 	cmd->result = DID_ABORT << 16;
1117 
1118 	scsi_set_resid(cmd, 0);
1119 
1120 	cmd->scsi_done(cmd);
1121 
1122 	return SUCCESS;
1123 }
1124 
1125 static int esas2r_host_bus_reset(struct scsi_cmnd *cmd, bool host_reset)
1126 {
1127 	struct esas2r_adapter *a =
1128 		(struct esas2r_adapter *)cmd->device->host->hostdata;
1129 
1130 	if (test_bit(AF_DEGRADED_MODE, &a->flags))
1131 		return FAILED;
1132 
1133 	if (host_reset)
1134 		esas2r_reset_adapter(a);
1135 	else
1136 		esas2r_reset_bus(a);
1137 
1138 	/* above call sets the AF_OS_RESET flag.  wait for it to clear. */
1139 
1140 	while (test_bit(AF_OS_RESET, &a->flags)) {
1141 		msleep(10);
1142 
1143 		if (test_bit(AF_DEGRADED_MODE, &a->flags))
1144 			return FAILED;
1145 	}
1146 
1147 	if (test_bit(AF_DEGRADED_MODE, &a->flags))
1148 		return FAILED;
1149 
1150 	return SUCCESS;
1151 }
1152 
1153 int esas2r_host_reset(struct scsi_cmnd *cmd)
1154 {
1155 	esas2r_log(ESAS2R_LOG_INFO, "host_reset (%p)", cmd);
1156 
1157 	return esas2r_host_bus_reset(cmd, true);
1158 }
1159 
1160 int esas2r_bus_reset(struct scsi_cmnd *cmd)
1161 {
1162 	esas2r_log(ESAS2R_LOG_INFO, "bus_reset (%p)", cmd);
1163 
1164 	return esas2r_host_bus_reset(cmd, false);
1165 }
1166 
1167 static int esas2r_dev_targ_reset(struct scsi_cmnd *cmd, bool target_reset)
1168 {
1169 	struct esas2r_adapter *a =
1170 		(struct esas2r_adapter *)cmd->device->host->hostdata;
1171 	struct esas2r_request *rq;
1172 	u8 task_management_status = RS_PENDING;
1173 	bool completed;
1174 
1175 	if (test_bit(AF_DEGRADED_MODE, &a->flags))
1176 		return FAILED;
1177 
1178 retry:
1179 	rq = esas2r_alloc_request(a);
1180 	if (rq == NULL) {
1181 		if (target_reset) {
1182 			esas2r_log(ESAS2R_LOG_CRIT,
1183 				   "unable to allocate a request for a "
1184 				   "target reset (%d)!",
1185 				   cmd->device->id);
1186 		} else {
1187 			esas2r_log(ESAS2R_LOG_CRIT,
1188 				   "unable to allocate a request for a "
1189 				   "device reset (%d:%d)!",
1190 				   cmd->device->id,
1191 				   cmd->device->lun);
1192 		}
1193 
1194 
1195 		return FAILED;
1196 	}
1197 
1198 	rq->target_id = cmd->device->id;
1199 	rq->vrq->scsi.flags |= cpu_to_le32(cmd->device->lun);
1200 	rq->req_stat = RS_PENDING;
1201 
1202 	rq->comp_cb = complete_task_management_request;
1203 	rq->task_management_status_ptr = &task_management_status;
1204 
1205 	if (target_reset) {
1206 		esas2r_debug("issuing target reset (%p) to id %d", rq,
1207 			     cmd->device->id);
1208 		completed = esas2r_send_task_mgmt(a, rq, 0x20);
1209 	} else {
1210 		esas2r_debug("issuing device reset (%p) to id %d lun %d", rq,
1211 			     cmd->device->id, cmd->device->lun);
1212 		completed = esas2r_send_task_mgmt(a, rq, 0x10);
1213 	}
1214 
1215 	if (completed) {
1216 		/* Task management cmd completed right away, need to free it. */
1217 
1218 		esas2r_free_request(a, rq);
1219 	} else {
1220 		/*
1221 		 * Wait for firmware to complete the request.  Completion
1222 		 * callback will free it.
1223 		 */
1224 		while (task_management_status == RS_PENDING)
1225 			msleep(10);
1226 	}
1227 
1228 	if (test_bit(AF_DEGRADED_MODE, &a->flags))
1229 		return FAILED;
1230 
1231 	if (task_management_status == RS_BUSY) {
1232 		/*
1233 		 * Busy, probably because we are flashing.  Wait a bit and
1234 		 * try again.
1235 		 */
1236 		msleep(100);
1237 		goto retry;
1238 	}
1239 
1240 	return SUCCESS;
1241 }
1242 
1243 int esas2r_device_reset(struct scsi_cmnd *cmd)
1244 {
1245 	esas2r_log(ESAS2R_LOG_INFO, "device_reset (%p)", cmd);
1246 
1247 	return esas2r_dev_targ_reset(cmd, false);
1248 
1249 }
1250 
1251 int esas2r_target_reset(struct scsi_cmnd *cmd)
1252 {
1253 	esas2r_log(ESAS2R_LOG_INFO, "target_reset (%p)", cmd);
1254 
1255 	return esas2r_dev_targ_reset(cmd, true);
1256 }
1257 
1258 void esas2r_log_request_failure(struct esas2r_adapter *a,
1259 				struct esas2r_request *rq)
1260 {
1261 	u8 reqstatus = rq->req_stat;
1262 
1263 	if (reqstatus == RS_SUCCESS)
1264 		return;
1265 
1266 	if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
1267 		if (reqstatus == RS_SCSI_ERROR) {
1268 			if (rq->func_rsp.scsi_rsp.sense_len >= 13) {
1269 				esas2r_log(ESAS2R_LOG_WARN,
1270 					   "request failure - SCSI error %x ASC:%x ASCQ:%x CDB:%x",
1271 					   rq->sense_buf[2], rq->sense_buf[12],
1272 					   rq->sense_buf[13],
1273 					   rq->vrq->scsi.cdb[0]);
1274 			} else {
1275 				esas2r_log(ESAS2R_LOG_WARN,
1276 					   "request failure - SCSI error CDB:%x\n",
1277 					   rq->vrq->scsi.cdb[0]);
1278 			}
1279 		} else if ((rq->vrq->scsi.cdb[0] != INQUIRY
1280 			    && rq->vrq->scsi.cdb[0] != REPORT_LUNS)
1281 			   || (reqstatus != RS_SEL
1282 			       && reqstatus != RS_SEL2)) {
1283 			if ((reqstatus == RS_UNDERRUN) &&
1284 			    (rq->vrq->scsi.cdb[0] == INQUIRY)) {
1285 				/* Don't log inquiry underruns */
1286 			} else {
1287 				esas2r_log(ESAS2R_LOG_WARN,
1288 					   "request failure - cdb:%x reqstatus:%d target:%d",
1289 					   rq->vrq->scsi.cdb[0], reqstatus,
1290 					   rq->target_id);
1291 			}
1292 		}
1293 	}
1294 }
1295 
1296 void esas2r_wait_request(struct esas2r_adapter *a, struct esas2r_request *rq)
1297 {
1298 	u32 starttime;
1299 	u32 timeout;
1300 
1301 	starttime = jiffies_to_msecs(jiffies);
1302 	timeout = rq->timeout ? rq->timeout : 5000;
1303 
1304 	while (true) {
1305 		esas2r_polled_interrupt(a);
1306 
1307 		if (rq->req_stat != RS_STARTED)
1308 			break;
1309 
1310 		schedule_timeout_interruptible(msecs_to_jiffies(100));
1311 
1312 		if ((jiffies_to_msecs(jiffies) - starttime) > timeout) {
1313 			esas2r_hdebug("request TMO");
1314 			esas2r_bugon();
1315 
1316 			rq->req_stat = RS_TIMEOUT;
1317 
1318 			esas2r_local_reset_adapter(a);
1319 			return;
1320 		}
1321 	}
1322 }
1323 
1324 u32 esas2r_map_data_window(struct esas2r_adapter *a, u32 addr_lo)
1325 {
1326 	u32 offset = addr_lo & (MW_DATA_WINDOW_SIZE - 1);
1327 	u32 base = addr_lo & -(signed int)MW_DATA_WINDOW_SIZE;
1328 
1329 	if (a->window_base != base) {
1330 		esas2r_write_register_dword(a, MVR_PCI_WIN1_REMAP,
1331 					    base | MVRPW1R_ENABLE);
1332 		esas2r_flush_register_dword(a, MVR_PCI_WIN1_REMAP);
1333 		a->window_base = base;
1334 	}
1335 
1336 	return offset;
1337 }
1338 
1339 /* Read a block of data from chip memory */
1340 bool esas2r_read_mem_block(struct esas2r_adapter *a,
1341 			   void *to,
1342 			   u32 from,
1343 			   u32 size)
1344 {
1345 	u8 *end = (u8 *)to;
1346 
1347 	while (size) {
1348 		u32 len;
1349 		u32 offset;
1350 		u32 iatvr;
1351 
1352 		iatvr = (from & -(signed int)MW_DATA_WINDOW_SIZE);
1353 
1354 		esas2r_map_data_window(a, iatvr);
1355 
1356 		offset = from & (MW_DATA_WINDOW_SIZE - 1);
1357 		len = size;
1358 
1359 		if (len > MW_DATA_WINDOW_SIZE - offset)
1360 			len = MW_DATA_WINDOW_SIZE - offset;
1361 
1362 		from += len;
1363 		size -= len;
1364 
1365 		while (len--) {
1366 			*end++ = esas2r_read_data_byte(a, offset);
1367 			offset++;
1368 		}
1369 	}
1370 
1371 	return true;
1372 }
1373 
1374 void esas2r_nuxi_mgt_data(u8 function, void *data)
1375 {
1376 	struct atto_vda_grp_info *g;
1377 	struct atto_vda_devinfo *d;
1378 	struct atto_vdapart_info *p;
1379 	struct atto_vda_dh_info *h;
1380 	struct atto_vda_metrics_info *m;
1381 	struct atto_vda_schedule_info *s;
1382 	struct atto_vda_buzzer_info *b;
1383 	u8 i;
1384 
1385 	switch (function) {
1386 	case VDAMGT_BUZZER_INFO:
1387 	case VDAMGT_BUZZER_SET:
1388 
1389 		b = (struct atto_vda_buzzer_info *)data;
1390 
1391 		b->duration = le32_to_cpu(b->duration);
1392 		break;
1393 
1394 	case VDAMGT_SCHEDULE_INFO:
1395 	case VDAMGT_SCHEDULE_EVENT:
1396 
1397 		s = (struct atto_vda_schedule_info *)data;
1398 
1399 		s->id = le32_to_cpu(s->id);
1400 
1401 		break;
1402 
1403 	case VDAMGT_DEV_INFO:
1404 	case VDAMGT_DEV_CLEAN:
1405 	case VDAMGT_DEV_PT_INFO:
1406 	case VDAMGT_DEV_FEATURES:
1407 	case VDAMGT_DEV_PT_FEATURES:
1408 	case VDAMGT_DEV_OPERATION:
1409 
1410 		d = (struct atto_vda_devinfo *)data;
1411 
1412 		d->capacity = le64_to_cpu(d->capacity);
1413 		d->block_size = le32_to_cpu(d->block_size);
1414 		d->ses_dev_index = le16_to_cpu(d->ses_dev_index);
1415 		d->target_id = le16_to_cpu(d->target_id);
1416 		d->lun = le16_to_cpu(d->lun);
1417 		d->features = le16_to_cpu(d->features);
1418 		break;
1419 
1420 	case VDAMGT_GRP_INFO:
1421 	case VDAMGT_GRP_CREATE:
1422 	case VDAMGT_GRP_DELETE:
1423 	case VDAMGT_ADD_STORAGE:
1424 	case VDAMGT_MEMBER_ADD:
1425 	case VDAMGT_GRP_COMMIT:
1426 	case VDAMGT_GRP_REBUILD:
1427 	case VDAMGT_GRP_COMMIT_INIT:
1428 	case VDAMGT_QUICK_RAID:
1429 	case VDAMGT_GRP_FEATURES:
1430 	case VDAMGT_GRP_COMMIT_INIT_AUTOMAP:
1431 	case VDAMGT_QUICK_RAID_INIT_AUTOMAP:
1432 	case VDAMGT_SPARE_LIST:
1433 	case VDAMGT_SPARE_ADD:
1434 	case VDAMGT_SPARE_REMOVE:
1435 	case VDAMGT_LOCAL_SPARE_ADD:
1436 	case VDAMGT_GRP_OPERATION:
1437 
1438 		g = (struct atto_vda_grp_info *)data;
1439 
1440 		g->capacity = le64_to_cpu(g->capacity);
1441 		g->block_size = le32_to_cpu(g->block_size);
1442 		g->interleave = le32_to_cpu(g->interleave);
1443 		g->features = le16_to_cpu(g->features);
1444 
1445 		for (i = 0; i < 32; i++)
1446 			g->members[i] = le16_to_cpu(g->members[i]);
1447 
1448 		break;
1449 
1450 	case VDAMGT_PART_INFO:
1451 	case VDAMGT_PART_MAP:
1452 	case VDAMGT_PART_UNMAP:
1453 	case VDAMGT_PART_AUTOMAP:
1454 	case VDAMGT_PART_SPLIT:
1455 	case VDAMGT_PART_MERGE:
1456 
1457 		p = (struct atto_vdapart_info *)data;
1458 
1459 		p->part_size = le64_to_cpu(p->part_size);
1460 		p->start_lba = le32_to_cpu(p->start_lba);
1461 		p->block_size = le32_to_cpu(p->block_size);
1462 		p->target_id = le16_to_cpu(p->target_id);
1463 		break;
1464 
1465 	case VDAMGT_DEV_HEALTH_REQ:
1466 
1467 		h = (struct atto_vda_dh_info *)data;
1468 
1469 		h->med_defect_cnt = le32_to_cpu(h->med_defect_cnt);
1470 		h->info_exc_cnt = le32_to_cpu(h->info_exc_cnt);
1471 		break;
1472 
1473 	case VDAMGT_DEV_METRICS:
1474 
1475 		m = (struct atto_vda_metrics_info *)data;
1476 
1477 		for (i = 0; i < 32; i++)
1478 			m->dev_indexes[i] = le16_to_cpu(m->dev_indexes[i]);
1479 
1480 		break;
1481 
1482 	default:
1483 		break;
1484 	}
1485 }
1486 
1487 void esas2r_nuxi_cfg_data(u8 function, void *data)
1488 {
1489 	struct atto_vda_cfg_init *ci;
1490 
1491 	switch (function) {
1492 	case VDA_CFG_INIT:
1493 	case VDA_CFG_GET_INIT:
1494 	case VDA_CFG_GET_INIT2:
1495 
1496 		ci = (struct atto_vda_cfg_init *)data;
1497 
1498 		ci->date_time.year = le16_to_cpu(ci->date_time.year);
1499 		ci->sgl_page_size = le32_to_cpu(ci->sgl_page_size);
1500 		ci->vda_version = le32_to_cpu(ci->vda_version);
1501 		ci->epoch_time = le32_to_cpu(ci->epoch_time);
1502 		ci->ioctl_tunnel = le32_to_cpu(ci->ioctl_tunnel);
1503 		ci->num_targets_backend = le32_to_cpu(ci->num_targets_backend);
1504 		break;
1505 
1506 	default:
1507 		break;
1508 	}
1509 }
1510 
1511 void esas2r_nuxi_ae_data(union atto_vda_ae *ae)
1512 {
1513 	struct atto_vda_ae_raid *r = &ae->raid;
1514 	struct atto_vda_ae_lu *l = &ae->lu;
1515 
1516 	switch (ae->hdr.bytype) {
1517 	case VDAAE_HDR_TYPE_RAID:
1518 
1519 		r->dwflags = le32_to_cpu(r->dwflags);
1520 		break;
1521 
1522 	case VDAAE_HDR_TYPE_LU:
1523 
1524 		l->dwevent = le32_to_cpu(l->dwevent);
1525 		l->wphys_target_id = le16_to_cpu(l->wphys_target_id);
1526 		l->id.tgtlun.wtarget_id = le16_to_cpu(l->id.tgtlun.wtarget_id);
1527 
1528 		if (l->hdr.bylength >= offsetof(struct atto_vda_ae_lu, id)
1529 		    + sizeof(struct atto_vda_ae_lu_tgt_lun_raid)) {
1530 			l->id.tgtlun_raid.dwinterleave
1531 				= le32_to_cpu(l->id.tgtlun_raid.dwinterleave);
1532 			l->id.tgtlun_raid.dwblock_size
1533 				= le32_to_cpu(l->id.tgtlun_raid.dwblock_size);
1534 		}
1535 
1536 		break;
1537 
1538 	case VDAAE_HDR_TYPE_DISK:
1539 	default:
1540 		break;
1541 	}
1542 }
1543 
1544 void esas2r_free_request(struct esas2r_adapter *a, struct esas2r_request *rq)
1545 {
1546 	unsigned long flags;
1547 
1548 	esas2r_rq_destroy_request(rq, a);
1549 	spin_lock_irqsave(&a->request_lock, flags);
1550 	list_add(&rq->comp_list, &a->avail_request);
1551 	spin_unlock_irqrestore(&a->request_lock, flags);
1552 }
1553 
1554 struct esas2r_request *esas2r_alloc_request(struct esas2r_adapter *a)
1555 {
1556 	struct esas2r_request *rq;
1557 	unsigned long flags;
1558 
1559 	spin_lock_irqsave(&a->request_lock, flags);
1560 
1561 	if (unlikely(list_empty(&a->avail_request))) {
1562 		spin_unlock_irqrestore(&a->request_lock, flags);
1563 		return NULL;
1564 	}
1565 
1566 	rq = list_first_entry(&a->avail_request, struct esas2r_request,
1567 			      comp_list);
1568 	list_del(&rq->comp_list);
1569 	spin_unlock_irqrestore(&a->request_lock, flags);
1570 	esas2r_rq_init_request(rq, a);
1571 
1572 	return rq;
1573 
1574 }
1575 
1576 void esas2r_complete_request_cb(struct esas2r_adapter *a,
1577 				struct esas2r_request *rq)
1578 {
1579 	esas2r_debug("completing request %p\n", rq);
1580 
1581 	scsi_dma_unmap(rq->cmd);
1582 
1583 	if (unlikely(rq->req_stat != RS_SUCCESS)) {
1584 		esas2r_debug("[%x STATUS %x:%x (%x)]", rq->target_id,
1585 			     rq->req_stat,
1586 			     rq->func_rsp.scsi_rsp.scsi_stat,
1587 			     rq->cmd);
1588 
1589 		rq->cmd->result =
1590 			((esas2r_req_status_to_error(rq->req_stat) << 16)
1591 			 | (rq->func_rsp.scsi_rsp.scsi_stat & STATUS_MASK));
1592 
1593 		if (rq->req_stat == RS_UNDERRUN)
1594 			scsi_set_resid(rq->cmd,
1595 				       le32_to_cpu(rq->func_rsp.scsi_rsp.
1596 						   residual_length));
1597 		else
1598 			scsi_set_resid(rq->cmd, 0);
1599 	}
1600 
1601 	rq->cmd->scsi_done(rq->cmd);
1602 
1603 	esas2r_free_request(a, rq);
1604 }
1605 
1606 /* Run tasklet to handle stuff outside of interrupt context. */
1607 void esas2r_adapter_tasklet(unsigned long context)
1608 {
1609 	struct esas2r_adapter *a = (struct esas2r_adapter *)context;
1610 
1611 	if (unlikely(test_bit(AF2_TIMER_TICK, &a->flags2))) {
1612 		clear_bit(AF2_TIMER_TICK, &a->flags2);
1613 		esas2r_timer_tick(a);
1614 	}
1615 
1616 	if (likely(test_bit(AF2_INT_PENDING, &a->flags2))) {
1617 		clear_bit(AF2_INT_PENDING, &a->flags2);
1618 		esas2r_adapter_interrupt(a);
1619 	}
1620 
1621 	if (esas2r_is_tasklet_pending(a))
1622 		esas2r_do_tasklet_tasks(a);
1623 
1624 	if (esas2r_is_tasklet_pending(a)
1625 	    || (test_bit(AF2_INT_PENDING, &a->flags2))
1626 	    || (test_bit(AF2_TIMER_TICK, &a->flags2))) {
1627 		clear_bit(AF_TASKLET_SCHEDULED, &a->flags);
1628 		esas2r_schedule_tasklet(a);
1629 	} else {
1630 		clear_bit(AF_TASKLET_SCHEDULED, &a->flags);
1631 	}
1632 }
1633 
1634 static void esas2r_timer_callback(unsigned long context);
1635 
1636 void esas2r_kickoff_timer(struct esas2r_adapter *a)
1637 {
1638 	init_timer(&a->timer);
1639 
1640 	a->timer.function = esas2r_timer_callback;
1641 	a->timer.data = (unsigned long)a;
1642 	a->timer.expires = jiffies +
1643 			   msecs_to_jiffies(100);
1644 
1645 	add_timer(&a->timer);
1646 }
1647 
1648 static void esas2r_timer_callback(unsigned long context)
1649 {
1650 	struct esas2r_adapter *a = (struct esas2r_adapter *)context;
1651 
1652 	set_bit(AF2_TIMER_TICK, &a->flags2);
1653 
1654 	esas2r_schedule_tasklet(a);
1655 
1656 	esas2r_kickoff_timer(a);
1657 }
1658 
1659 /*
1660  * Firmware events need to be handled outside of interrupt context
1661  * so we schedule a delayed_work to handle them.
1662  */
1663 
1664 static void
1665 esas2r_free_fw_event(struct esas2r_fw_event_work *fw_event)
1666 {
1667 	unsigned long flags;
1668 	struct esas2r_adapter *a = fw_event->a;
1669 
1670 	spin_lock_irqsave(&a->fw_event_lock, flags);
1671 	list_del(&fw_event->list);
1672 	kfree(fw_event);
1673 	spin_unlock_irqrestore(&a->fw_event_lock, flags);
1674 }
1675 
1676 void
1677 esas2r_fw_event_off(struct esas2r_adapter *a)
1678 {
1679 	unsigned long flags;
1680 
1681 	spin_lock_irqsave(&a->fw_event_lock, flags);
1682 	a->fw_events_off = 1;
1683 	spin_unlock_irqrestore(&a->fw_event_lock, flags);
1684 }
1685 
1686 void
1687 esas2r_fw_event_on(struct esas2r_adapter *a)
1688 {
1689 	unsigned long flags;
1690 
1691 	spin_lock_irqsave(&a->fw_event_lock, flags);
1692 	a->fw_events_off = 0;
1693 	spin_unlock_irqrestore(&a->fw_event_lock, flags);
1694 }
1695 
1696 static void esas2r_add_device(struct esas2r_adapter *a, u16 target_id)
1697 {
1698 	int ret;
1699 	struct scsi_device *scsi_dev;
1700 
1701 	scsi_dev = scsi_device_lookup(a->host, 0, target_id, 0);
1702 
1703 	if (scsi_dev) {
1704 		esas2r_log_dev(
1705 			ESAS2R_LOG_WARN,
1706 			&(scsi_dev->
1707 			  sdev_gendev),
1708 			"scsi device already exists at id %d", target_id);
1709 
1710 		scsi_device_put(scsi_dev);
1711 	} else {
1712 		esas2r_log_dev(
1713 			ESAS2R_LOG_INFO,
1714 			&(a->host->
1715 			  shost_gendev),
1716 			"scsi_add_device() called for 0:%d:0",
1717 			target_id);
1718 
1719 		ret = scsi_add_device(a->host, 0, target_id, 0);
1720 		if (ret) {
1721 			esas2r_log_dev(
1722 				ESAS2R_LOG_CRIT,
1723 				&(a->host->
1724 				  shost_gendev),
1725 				"scsi_add_device failed with %d for id %d",
1726 				ret, target_id);
1727 		}
1728 	}
1729 }
1730 
1731 static void esas2r_remove_device(struct esas2r_adapter *a, u16 target_id)
1732 {
1733 	struct scsi_device *scsi_dev;
1734 
1735 	scsi_dev = scsi_device_lookup(a->host, 0, target_id, 0);
1736 
1737 	if (scsi_dev) {
1738 		scsi_device_set_state(scsi_dev, SDEV_OFFLINE);
1739 
1740 		esas2r_log_dev(
1741 			ESAS2R_LOG_INFO,
1742 			&(scsi_dev->
1743 			  sdev_gendev),
1744 			"scsi_remove_device() called for 0:%d:0",
1745 			target_id);
1746 
1747 		scsi_remove_device(scsi_dev);
1748 
1749 		esas2r_log_dev(
1750 			ESAS2R_LOG_INFO,
1751 			&(scsi_dev->
1752 			  sdev_gendev),
1753 			"scsi_device_put() called");
1754 
1755 		scsi_device_put(scsi_dev);
1756 	} else {
1757 		esas2r_log_dev(
1758 			ESAS2R_LOG_WARN,
1759 			&(a->host->shost_gendev),
1760 			"no target found at id %d",
1761 			target_id);
1762 	}
1763 }
1764 
1765 /*
1766  * Sends a firmware asynchronous event to anyone who happens to be
1767  * listening on the defined ATTO VDA event ports.
1768  */
1769 static void esas2r_send_ae_event(struct esas2r_fw_event_work *fw_event)
1770 {
1771 	struct esas2r_vda_ae *ae = (struct esas2r_vda_ae *)fw_event->data;
1772 	char *type;
1773 
1774 	switch (ae->vda_ae.hdr.bytype) {
1775 	case VDAAE_HDR_TYPE_RAID:
1776 		type = "RAID group state change";
1777 		break;
1778 
1779 	case VDAAE_HDR_TYPE_LU:
1780 		type = "Mapped destination LU change";
1781 		break;
1782 
1783 	case VDAAE_HDR_TYPE_DISK:
1784 		type = "Physical disk inventory change";
1785 		break;
1786 
1787 	case VDAAE_HDR_TYPE_RESET:
1788 		type = "Firmware reset";
1789 		break;
1790 
1791 	case VDAAE_HDR_TYPE_LOG_INFO:
1792 		type = "Event Log message (INFO level)";
1793 		break;
1794 
1795 	case VDAAE_HDR_TYPE_LOG_WARN:
1796 		type = "Event Log message (WARN level)";
1797 		break;
1798 
1799 	case VDAAE_HDR_TYPE_LOG_CRIT:
1800 		type = "Event Log message (CRIT level)";
1801 		break;
1802 
1803 	case VDAAE_HDR_TYPE_LOG_FAIL:
1804 		type = "Event Log message (FAIL level)";
1805 		break;
1806 
1807 	case VDAAE_HDR_TYPE_NVC:
1808 		type = "NVCache change";
1809 		break;
1810 
1811 	case VDAAE_HDR_TYPE_TLG_INFO:
1812 		type = "Time stamped log message (INFO level)";
1813 		break;
1814 
1815 	case VDAAE_HDR_TYPE_TLG_WARN:
1816 		type = "Time stamped log message (WARN level)";
1817 		break;
1818 
1819 	case VDAAE_HDR_TYPE_TLG_CRIT:
1820 		type = "Time stamped log message (CRIT level)";
1821 		break;
1822 
1823 	case VDAAE_HDR_TYPE_PWRMGT:
1824 		type = "Power management";
1825 		break;
1826 
1827 	case VDAAE_HDR_TYPE_MUTE:
1828 		type = "Mute button pressed";
1829 		break;
1830 
1831 	case VDAAE_HDR_TYPE_DEV:
1832 		type = "Device attribute change";
1833 		break;
1834 
1835 	default:
1836 		type = "Unknown";
1837 		break;
1838 	}
1839 
1840 	esas2r_log(ESAS2R_LOG_WARN,
1841 		   "An async event of type \"%s\" was received from the firmware.  The event contents are:",
1842 		   type);
1843 	esas2r_log_hexdump(ESAS2R_LOG_WARN, &ae->vda_ae,
1844 			   ae->vda_ae.hdr.bylength);
1845 
1846 }
1847 
1848 static void
1849 esas2r_firmware_event_work(struct work_struct *work)
1850 {
1851 	struct esas2r_fw_event_work *fw_event =
1852 		container_of(work, struct esas2r_fw_event_work, work.work);
1853 
1854 	struct esas2r_adapter *a = fw_event->a;
1855 
1856 	u16 target_id = *(u16 *)&fw_event->data[0];
1857 
1858 	if (a->fw_events_off)
1859 		goto done;
1860 
1861 	switch (fw_event->type) {
1862 	case fw_event_null:
1863 		break; /* do nothing */
1864 
1865 	case fw_event_lun_change:
1866 		esas2r_remove_device(a, target_id);
1867 		esas2r_add_device(a, target_id);
1868 		break;
1869 
1870 	case fw_event_present:
1871 		esas2r_add_device(a, target_id);
1872 		break;
1873 
1874 	case fw_event_not_present:
1875 		esas2r_remove_device(a, target_id);
1876 		break;
1877 
1878 	case fw_event_vda_ae:
1879 		esas2r_send_ae_event(fw_event);
1880 		break;
1881 	}
1882 
1883 done:
1884 	esas2r_free_fw_event(fw_event);
1885 }
1886 
1887 void esas2r_queue_fw_event(struct esas2r_adapter *a,
1888 			   enum fw_event_type type,
1889 			   void *data,
1890 			   int data_sz)
1891 {
1892 	struct esas2r_fw_event_work *fw_event;
1893 	unsigned long flags;
1894 
1895 	fw_event = kzalloc(sizeof(struct esas2r_fw_event_work), GFP_ATOMIC);
1896 	if (!fw_event) {
1897 		esas2r_log(ESAS2R_LOG_WARN,
1898 			   "esas2r_queue_fw_event failed to alloc");
1899 		return;
1900 	}
1901 
1902 	if (type == fw_event_vda_ae) {
1903 		struct esas2r_vda_ae *ae =
1904 			(struct esas2r_vda_ae *)fw_event->data;
1905 
1906 		ae->signature = ESAS2R_VDA_EVENT_SIG;
1907 		ae->bus_number = a->pcid->bus->number;
1908 		ae->devfn = a->pcid->devfn;
1909 		memcpy(&ae->vda_ae, data, sizeof(ae->vda_ae));
1910 	} else {
1911 		memcpy(fw_event->data, data, data_sz);
1912 	}
1913 
1914 	fw_event->type = type;
1915 	fw_event->a = a;
1916 
1917 	spin_lock_irqsave(&a->fw_event_lock, flags);
1918 	list_add_tail(&fw_event->list, &a->fw_event_list);
1919 	INIT_DELAYED_WORK(&fw_event->work, esas2r_firmware_event_work);
1920 	queue_delayed_work_on(
1921 		smp_processor_id(), a->fw_event_q, &fw_event->work,
1922 		msecs_to_jiffies(1));
1923 	spin_unlock_irqrestore(&a->fw_event_lock, flags);
1924 }
1925 
1926 void esas2r_target_state_changed(struct esas2r_adapter *a, u16 targ_id,
1927 				 u8 state)
1928 {
1929 	if (state == TS_LUN_CHANGE)
1930 		esas2r_queue_fw_event(a, fw_event_lun_change, &targ_id,
1931 				      sizeof(targ_id));
1932 	else if (state == TS_PRESENT)
1933 		esas2r_queue_fw_event(a, fw_event_present, &targ_id,
1934 				      sizeof(targ_id));
1935 	else if (state == TS_NOT_PRESENT)
1936 		esas2r_queue_fw_event(a, fw_event_not_present, &targ_id,
1937 				      sizeof(targ_id));
1938 }
1939 
1940 /* Translate status to a Linux SCSI mid-layer error code */
1941 int esas2r_req_status_to_error(u8 req_stat)
1942 {
1943 	switch (req_stat) {
1944 	case RS_OVERRUN:
1945 	case RS_UNDERRUN:
1946 	case RS_SUCCESS:
1947 	/*
1948 	 * NOTE: SCSI mid-layer wants a good status for a SCSI error, because
1949 	 *       it will check the scsi_stat value in the completion anyway.
1950 	 */
1951 	case RS_SCSI_ERROR:
1952 		return DID_OK;
1953 
1954 	case RS_SEL:
1955 	case RS_SEL2:
1956 		return DID_NO_CONNECT;
1957 
1958 	case RS_RESET:
1959 		return DID_RESET;
1960 
1961 	case RS_ABORTED:
1962 		return DID_ABORT;
1963 
1964 	case RS_BUSY:
1965 		return DID_BUS_BUSY;
1966 	}
1967 
1968 	/* everything else is just an error. */
1969 
1970 	return DID_ERROR;
1971 }
1972 
1973 module_init(esas2r_init);
1974 module_exit(esas2r_exit);
1975