2 * linux/drivers/scsi/esas2r/esas2r_main.c
3 * For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
5 * Copyright (c) 2001-2013 ATTO Technology, Inc.
6 * (mailto:linuxdrivers@attotech.com)
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.
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.
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.
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
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,
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);
51 /* global definitions */
53 static int found_adapters;
54 struct esas2r_adapter *esas2r_adapters[MAX_ADAPTERS];
56 #define ESAS2R_VDA_EVENT_PORT1 54414
57 #define ESAS2R_VDA_EVENT_PORT2 54415
58 #define ESAS2R_VDA_EVENT_SOCK_COUNT 2
60 static struct esas2r_adapter *esas2r_adapter_from_kobj(struct kobject *kobj)
62 struct device *dev = container_of(kobj, struct device, kobj);
63 struct Scsi_Host *host = class_to_shost(dev);
65 return (struct esas2r_adapter *)host->hostdata;
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)
72 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
74 return esas2r_read_fw(a, buf, off, count);
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)
81 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
83 return esas2r_write_fw(a, buf, off, count);
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)
90 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
92 return esas2r_read_fs(a, buf, off, count);
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)
99 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
100 int length = min(sizeof(struct esas2r_ioctl_fs), count);
103 result = esas2r_write_fs(a, buf, off, count);
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)
115 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
117 return esas2r_read_vda(a, buf, off, count);
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)
124 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
126 return esas2r_write_vda(a, buf, off, count);
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)
133 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
134 int length = min_t(size_t, sizeof(struct esas2r_sas_nvram), PAGE_SIZE);
136 memcpy(buf, a->nvram, length);
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)
144 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
145 struct esas2r_request *rq;
146 int result = -EFAULT;
148 rq = esas2r_alloc_request(a);
152 if (esas2r_write_params(a, rq, (struct esas2r_sas_nvram *)buf))
155 esas2r_free_request(a, rq);
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)
164 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
166 esas2r_nvram_get_defaults(a, (struct esas2r_sas_nvram *)buf);
168 return sizeof(struct esas2r_sas_nvram);
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)
175 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
176 int length = min_t(size_t, sizeof(struct atto_ioctl), PAGE_SIZE);
178 if (!a->local_atto_ioctl)
181 if (handle_hba_ioctl(a, a->local_atto_ioctl) != IOCTL_SUCCESS)
184 memcpy(buf, a->local_atto_ioctl, length);
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)
193 struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
194 int length = min(sizeof(struct atto_ioctl), count);
196 if (!a->local_atto_ioctl) {
197 a->local_atto_ioctl = kzalloc(sizeof(struct atto_ioctl),
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));
207 memset(a->local_atto_ioctl, 0, sizeof(struct atto_ioctl));
208 memcpy(a->local_atto_ioctl, buf, length);
213 #define ESAS2R_RW_BIN_ATTR(_name) \
214 struct bin_attribute bin_attr_ ## _name = { \
216 { .name = __stringify(_name), .mode = S_IRUSR | S_IWUSR }, \
218 .read = read_ ## _name, \
219 .write = write_ ## _name }
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);
227 struct bin_attribute bin_attr_default_nvram = {
228 .attr = { .name = "default_nvram", .mode = S_IRUGO },
230 .read = read_default_nvram,
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,
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,
249 .sg_tablesize = SCSI_MAX_SG_SEGMENTS,
251 ESAS2R_DEFAULT_CMD_PER_LUN,
253 .unchecked_isa_dma = 0,
254 .use_clustering = ENABLE_CLUSTERING,
256 .proc_name = ESAS2R_DRVR_NAME,
257 .slave_configure = esas2r_slave_configure,
258 .slave_alloc = esas2r_slave_alloc,
259 .slave_destroy = esas2r_slave_destroy,
260 .change_queue_depth = esas2r_change_queue_depth,
261 .change_queue_type = scsi_change_queue_type,
262 .max_sectors = 0xFFFF,
266 int sgl_page_size = 512;
267 module_param(sgl_page_size, int, 0);
268 MODULE_PARM_DESC(sgl_page_size,
269 "Scatter/gather list (SGL) page size in number of S/G "
270 "entries. If your application is doing a lot of very large "
271 "transfers, you may want to increase the SGL page size. "
274 int num_sg_lists = 1024;
275 module_param(num_sg_lists, int, 0);
276 MODULE_PARM_DESC(num_sg_lists,
277 "Number of scatter/gather lists. Default 1024.");
279 int sg_tablesize = SCSI_MAX_SG_SEGMENTS;
280 module_param(sg_tablesize, int, 0);
281 MODULE_PARM_DESC(sg_tablesize,
282 "Maximum number of entries in a scatter/gather table.");
284 int num_requests = 256;
285 module_param(num_requests, int, 0);
286 MODULE_PARM_DESC(num_requests,
287 "Number of requests. Default 256.");
289 int num_ae_requests = 4;
290 module_param(num_ae_requests, int, 0);
291 MODULE_PARM_DESC(num_ae_requests,
292 "Number of VDA asynchromous event requests. Default 4.");
294 int cmd_per_lun = ESAS2R_DEFAULT_CMD_PER_LUN;
295 module_param(cmd_per_lun, int, 0);
296 MODULE_PARM_DESC(cmd_per_lun,
297 "Maximum number of commands per LUN. Default "
298 DEFINED_NUM_TO_STR(ESAS2R_DEFAULT_CMD_PER_LUN) ".");
301 module_param(can_queue, int, 0);
302 MODULE_PARM_DESC(can_queue,
303 "Maximum number of commands per adapter. Default 128.");
305 int esas2r_max_sectors = 0xFFFF;
306 module_param(esas2r_max_sectors, int, 0);
307 MODULE_PARM_DESC(esas2r_max_sectors,
308 "Maximum number of disk sectors in a single data transfer. "
309 "Default 65535 (largest possible setting).");
311 int interrupt_mode = 1;
312 module_param(interrupt_mode, int, 0);
313 MODULE_PARM_DESC(interrupt_mode,
314 "Defines the interrupt mode to use. 0 for legacy"
315 ", 1 for MSI. Default is MSI (1).");
317 static struct pci_device_id
318 esas2r_pci_table[] = {
319 { ATTO_VENDOR_ID, 0x0049, ATTO_VENDOR_ID, 0x0049,
322 { ATTO_VENDOR_ID, 0x0049, ATTO_VENDOR_ID, 0x004A,
325 { ATTO_VENDOR_ID, 0x0049, ATTO_VENDOR_ID, 0x004B,
328 { ATTO_VENDOR_ID, 0x0049, ATTO_VENDOR_ID, 0x004C,
331 { ATTO_VENDOR_ID, 0x0049, ATTO_VENDOR_ID, 0x004D,
334 { ATTO_VENDOR_ID, 0x0049, ATTO_VENDOR_ID, 0x004E,
342 MODULE_DEVICE_TABLE(pci, esas2r_pci_table);
345 esas2r_probe(struct pci_dev *pcid, const struct pci_device_id *id);
348 esas2r_remove(struct pci_dev *pcid);
350 static struct pci_driver
351 esas2r_pci_driver = {
352 .name = ESAS2R_DRVR_NAME,
353 .id_table = esas2r_pci_table,
354 .probe = esas2r_probe,
355 .remove = esas2r_remove,
356 .suspend = esas2r_suspend,
357 .resume = esas2r_resume,
360 static int esas2r_probe(struct pci_dev *pcid,
361 const struct pci_device_id *id)
363 struct Scsi_Host *host = NULL;
364 struct esas2r_adapter *a;
367 size_t host_alloc_size = sizeof(struct esas2r_adapter)
369 1) * sizeof(struct esas2r_request);
371 esas2r_log_dev(ESAS2R_LOG_DEBG, &(pcid->dev),
372 "esas2r_probe() 0x%02x 0x%02x 0x%02x 0x%02x",
375 pcid->subsystem_vendor,
376 pcid->subsystem_device);
378 esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
379 "before pci_enable_device() "
381 pcid->enable_cnt.counter);
383 err = pci_enable_device(pcid);
385 esas2r_log_dev(ESAS2R_LOG_CRIT, &(pcid->dev),
386 "pci_enable_device() FAIL (%d)",
391 esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
392 "pci_enable_device() OK");
393 esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
394 "after pci_enable_device() enable_cnt: %d",
395 pcid->enable_cnt.counter);
397 host = scsi_host_alloc(&driver_template, host_alloc_size);
399 esas2r_log(ESAS2R_LOG_CRIT, "scsi_host_alloc() FAIL");
403 memset(host->hostdata, 0, host_alloc_size);
405 a = (struct esas2r_adapter *)host->hostdata;
407 esas2r_log(ESAS2R_LOG_INFO, "scsi_host_alloc() OK host: %p", host);
409 /* override max LUN and max target id */
411 host->max_id = ESAS2R_MAX_ID + 1;
414 /* we can handle 16-byte CDbs */
416 host->max_cmd_len = 16;
418 host->can_queue = can_queue;
419 host->cmd_per_lun = cmd_per_lun;
420 host->this_id = host->max_id + 1;
421 host->max_channel = 0;
422 host->unique_id = found_adapters;
423 host->sg_tablesize = sg_tablesize;
424 host->max_sectors = esas2r_max_sectors;
426 /* set to bus master for BIOses that don't do it for us */
428 esas2r_log(ESAS2R_LOG_INFO, "pci_set_master() called");
430 pci_set_master(pcid);
432 if (!esas2r_init_adapter(host, pcid, found_adapters)) {
433 esas2r_log(ESAS2R_LOG_CRIT,
434 "unable to initialize device at PCI bus %x:%x",
438 esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
439 "scsi_host_put() called");
447 esas2r_log(ESAS2R_LOG_INFO, "pci_set_drvdata(%p, %p) called", pcid,
450 pci_set_drvdata(pcid, host);
452 esas2r_log(ESAS2R_LOG_INFO, "scsi_add_host() called");
454 err = scsi_add_host(host, &pcid->dev);
457 esas2r_log(ESAS2R_LOG_CRIT, "scsi_add_host returned %d", err);
458 esas2r_log_dev(ESAS2R_LOG_CRIT, &(host->shost_gendev),
459 "scsi_add_host() FAIL");
461 esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
462 "scsi_host_put() called");
466 esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
467 "pci_set_drvdata(%p, NULL) called",
470 pci_set_drvdata(pcid, NULL);
476 esas2r_fw_event_on(a);
478 esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
479 "scsi_scan_host() called");
481 scsi_scan_host(host);
483 /* Add sysfs binary files */
484 if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fw))
485 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
486 "Failed to create sysfs binary file: fw");
488 a->sysfs_fw_created = 1;
490 if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fs))
491 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
492 "Failed to create sysfs binary file: fs");
494 a->sysfs_fs_created = 1;
496 if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_vda))
497 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
498 "Failed to create sysfs binary file: vda");
500 a->sysfs_vda_created = 1;
502 if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_hw))
503 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
504 "Failed to create sysfs binary file: hw");
506 a->sysfs_hw_created = 1;
508 if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_live_nvram))
509 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
510 "Failed to create sysfs binary file: live_nvram");
512 a->sysfs_live_nvram_created = 1;
514 if (sysfs_create_bin_file(&host->shost_dev.kobj,
515 &bin_attr_default_nvram))
516 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
517 "Failed to create sysfs binary file: default_nvram");
519 a->sysfs_default_nvram_created = 1;
526 static void esas2r_remove(struct pci_dev *pdev)
528 struct Scsi_Host *host;
532 esas2r_log(ESAS2R_LOG_WARN, "esas2r_remove pdev==NULL");
536 host = pci_get_drvdata(pdev);
540 * this can happen if pci_set_drvdata was already called
541 * to clear the host pointer. if this is the case, we
542 * are okay; this channel has already been cleaned up.
548 esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
549 "esas2r_remove(%p) called; "
553 index = esas2r_cleanup(host);
556 esas2r_log_dev(ESAS2R_LOG_WARN, &(pdev->dev),
557 "unknown host in %s",
562 /* if this was the last adapter, clean up the rest of the driver */
564 if (found_adapters == 0)
565 esas2r_cleanup(NULL);
568 static int __init esas2r_init(void)
572 esas2r_log(ESAS2R_LOG_INFO, "%s called", __func__);
574 /* verify valid parameters */
577 esas2r_log(ESAS2R_LOG_WARN,
578 "warning: can_queue must be at least 1, value "
581 } else if (can_queue > 2048) {
582 esas2r_log(ESAS2R_LOG_WARN,
583 "warning: can_queue must be no larger than 2048, "
588 if (cmd_per_lun < 1) {
589 esas2r_log(ESAS2R_LOG_WARN,
590 "warning: cmd_per_lun must be at least 1, value "
593 } else if (cmd_per_lun > 2048) {
594 esas2r_log(ESAS2R_LOG_WARN,
595 "warning: cmd_per_lun must be no larger than "
596 "2048, value forced.");
600 if (sg_tablesize < 32) {
601 esas2r_log(ESAS2R_LOG_WARN,
602 "warning: sg_tablesize must be at least 32, "
607 if (esas2r_max_sectors < 1) {
608 esas2r_log(ESAS2R_LOG_WARN,
609 "warning: esas2r_max_sectors must be at least "
611 esas2r_max_sectors = 1;
612 } else if (esas2r_max_sectors > 0xffff) {
613 esas2r_log(ESAS2R_LOG_WARN,
614 "warning: esas2r_max_sectors must be no larger "
615 "than 0xffff, value forced.");
616 esas2r_max_sectors = 0xffff;
619 sgl_page_size &= ~(ESAS2R_SGL_ALIGN - 1);
621 if (sgl_page_size < SGL_PG_SZ_MIN)
622 sgl_page_size = SGL_PG_SZ_MIN;
623 else if (sgl_page_size > SGL_PG_SZ_MAX)
624 sgl_page_size = SGL_PG_SZ_MAX;
626 if (num_sg_lists < NUM_SGL_MIN)
627 num_sg_lists = NUM_SGL_MIN;
628 else if (num_sg_lists > NUM_SGL_MAX)
629 num_sg_lists = NUM_SGL_MAX;
631 if (num_requests < NUM_REQ_MIN)
632 num_requests = NUM_REQ_MIN;
633 else if (num_requests > NUM_REQ_MAX)
634 num_requests = NUM_REQ_MAX;
636 if (num_ae_requests < NUM_AE_MIN)
637 num_ae_requests = NUM_AE_MIN;
638 else if (num_ae_requests > NUM_AE_MAX)
639 num_ae_requests = NUM_AE_MAX;
641 /* set up other globals */
643 for (i = 0; i < MAX_ADAPTERS; i++)
644 esas2r_adapters[i] = NULL;
648 driver_template.module = THIS_MODULE;
650 if (pci_register_driver(&esas2r_pci_driver) != 0)
651 esas2r_log(ESAS2R_LOG_CRIT, "pci_register_driver FAILED");
653 esas2r_log(ESAS2R_LOG_INFO, "pci_register_driver() OK");
655 if (!found_adapters) {
656 pci_unregister_driver(&esas2r_pci_driver);
657 esas2r_cleanup(NULL);
659 esas2r_log(ESAS2R_LOG_CRIT,
660 "driver will not be loaded because no ATTO "
661 "%s devices were found",
665 esas2r_log(ESAS2R_LOG_INFO, "found %d adapters",
672 /* Handle ioctl calls to "/proc/scsi/esas2r/ATTOnode" */
673 static const struct file_operations esas2r_proc_fops = {
674 .compat_ioctl = esas2r_proc_ioctl,
675 .unlocked_ioctl = esas2r_proc_ioctl,
678 static struct Scsi_Host *esas2r_proc_host;
679 static int esas2r_proc_major;
681 long esas2r_proc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
683 return esas2r_ioctl_handler(esas2r_proc_host->hostdata,
684 (int)cmd, (void __user *)arg);
687 static void __exit esas2r_exit(void)
689 esas2r_log(ESAS2R_LOG_INFO, "%s called", __func__);
691 if (esas2r_proc_major > 0) {
692 esas2r_log(ESAS2R_LOG_INFO, "unregister proc");
694 remove_proc_entry(ATTONODE_NAME,
695 esas2r_proc_host->hostt->proc_dir);
696 unregister_chrdev(esas2r_proc_major, ESAS2R_DRVR_NAME);
698 esas2r_proc_major = 0;
701 esas2r_log(ESAS2R_LOG_INFO, "pci_unregister_driver() called");
703 pci_unregister_driver(&esas2r_pci_driver);
706 int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh)
708 struct esas2r_adapter *a = (struct esas2r_adapter *)sh->hostdata;
710 struct esas2r_target *t;
713 esas2r_log(ESAS2R_LOG_DEBG, "esas2r_show_info (%p,%d)", m, sh->host_no);
715 seq_printf(m, ESAS2R_LONGNAME "\n"
716 "Driver version: "ESAS2R_VERSION_STR "\n"
717 "Flash version: %s\n"
718 "Firmware version: %s\n"
719 "Copyright "ESAS2R_COPYRIGHT_YEARS "\n"
720 "http://www.attotech.com\n"
723 a->fw_rev[0] ? a->fw_rev : "(none)");
726 seq_printf(m, "Adapter information:\n"
727 "--------------------\n"
729 "SAS address: %02X%02X%02X%02X:%02X%02X%02X%02X\n",
730 esas2r_get_model_name(a),
731 a->nvram->sas_addr[0],
732 a->nvram->sas_addr[1],
733 a->nvram->sas_addr[2],
734 a->nvram->sas_addr[3],
735 a->nvram->sas_addr[4],
736 a->nvram->sas_addr[5],
737 a->nvram->sas_addr[6],
738 a->nvram->sas_addr[7]);
741 "Discovered devices:\n"
744 "---------------\n");
746 for (t = a->targetdb; t < a->targetdb_end; t++)
747 if (t->buffered_target_state == TS_PRESENT) {
748 seq_printf(m, " %3d %3d\n",
750 (u16)(uintptr_t)(t - a->targetdb));
754 seq_puts(m, "none\n");
761 int esas2r_release(struct Scsi_Host *sh)
763 esas2r_log_dev(ESAS2R_LOG_INFO, &(sh->shost_gendev),
764 "esas2r_release() called");
768 free_irq(sh->irq, NULL);
773 const char *esas2r_info(struct Scsi_Host *sh)
775 struct esas2r_adapter *a = (struct esas2r_adapter *)sh->hostdata;
776 static char esas2r_info_str[512];
778 esas2r_log_dev(ESAS2R_LOG_INFO, &(sh->shost_gendev),
779 "esas2r_info() called");
782 * if we haven't done so already, register as a char driver
783 * and stick a node under "/proc/scsi/esas2r/ATTOnode"
786 if (esas2r_proc_major <= 0) {
787 esas2r_proc_host = sh;
789 esas2r_proc_major = register_chrdev(0, ESAS2R_DRVR_NAME,
792 esas2r_log_dev(ESAS2R_LOG_DEBG, &(sh->shost_gendev),
793 "register_chrdev (major %d)",
796 if (esas2r_proc_major > 0) {
797 struct proc_dir_entry *pde;
799 pde = proc_create(ATTONODE_NAME, 0,
804 esas2r_log_dev(ESAS2R_LOG_WARN,
806 "failed to create_proc_entry");
807 esas2r_proc_major = -1;
812 sprintf(esas2r_info_str,
813 ESAS2R_LONGNAME " (bus 0x%02X, device 0x%02X, IRQ 0x%02X)"
814 " driver version: "ESAS2R_VERSION_STR " firmware version: "
816 a->pcid->bus->number, a->pcid->devfn, a->pcid->irq,
817 a->fw_rev[0] ? a->fw_rev : "(none)");
819 return esas2r_info_str;
822 /* Callback for building a request scatter/gather list */
823 static u32 get_physaddr_from_sgc(struct esas2r_sg_context *sgc, u64 *addr)
827 if (likely(sgc->cur_offset == sgc->exp_offset)) {
829 * the normal case: caller used all bytes from previous call, so
830 * expected offset is the same as the current offset.
833 if (sgc->sgel_count < sgc->num_sgel) {
834 /* retrieve next segment, except for first time */
835 if (sgc->exp_offset > (u8 *)0) {
836 /* advance current segment */
837 sgc->cur_sgel = sg_next(sgc->cur_sgel);
842 len = sg_dma_len(sgc->cur_sgel);
843 (*addr) = sg_dma_address(sgc->cur_sgel);
845 /* save the total # bytes returned to caller so far */
846 sgc->exp_offset += len;
851 } else if (sgc->cur_offset < sgc->exp_offset) {
853 * caller did not use all bytes from previous call. need to
854 * compute the address based on current segment.
857 len = sg_dma_len(sgc->cur_sgel);
858 (*addr) = sg_dma_address(sgc->cur_sgel);
860 sgc->exp_offset -= len;
862 /* calculate PA based on prev segment address and offsets */
864 (sgc->cur_offset - sgc->exp_offset);
866 sgc->exp_offset += len;
868 /* re-calculate length based on offset */
870 sgc->exp_offset - sgc->cur_offset);
871 } else { /* if ( sgc->cur_offset > sgc->exp_offset ) */
873 * we don't expect the caller to skip ahead.
874 * cur_offset will never exceed the len we return
882 int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
884 struct esas2r_adapter *a =
885 (struct esas2r_adapter *)cmd->device->host->hostdata;
886 struct esas2r_request *rq;
887 struct esas2r_sg_context sgc;
890 /* Assume success, if it fails we will fix the result later. */
891 cmd->result = DID_OK << 16;
893 if (unlikely(test_bit(AF_DEGRADED_MODE, &a->flags))) {
894 cmd->result = DID_NO_CONNECT << 16;
899 rq = esas2r_alloc_request(a);
900 if (unlikely(rq == NULL)) {
901 esas2r_debug("esas2r_alloc_request failed");
902 return SCSI_MLQUEUE_HOST_BUSY;
906 bufflen = scsi_bufflen(cmd);
908 if (likely(bufflen != 0)) {
909 if (cmd->sc_data_direction == DMA_TO_DEVICE)
910 rq->vrq->scsi.flags |= cpu_to_le32(FCP_CMND_WRD);
911 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
912 rq->vrq->scsi.flags |= cpu_to_le32(FCP_CMND_RDD);
915 memcpy(rq->vrq->scsi.cdb, cmd->cmnd, cmd->cmd_len);
916 rq->vrq->scsi.length = cpu_to_le32(bufflen);
917 rq->target_id = cmd->device->id;
918 rq->vrq->scsi.flags |= cpu_to_le32(cmd->device->lun);
919 rq->sense_buf = cmd->sense_buffer;
920 rq->sense_len = SCSI_SENSE_BUFFERSIZE;
922 esas2r_sgc_init(&sgc, a, rq, NULL);
924 sgc.length = bufflen;
925 sgc.cur_offset = NULL;
927 sgc.cur_sgel = scsi_sglist(cmd);
928 sgc.exp_offset = NULL;
929 sgc.num_sgel = scsi_dma_map(cmd);
932 if (unlikely(sgc.num_sgel < 0)) {
933 esas2r_free_request(a, rq);
934 return SCSI_MLQUEUE_HOST_BUSY;
937 sgc.get_phys_addr = (PGETPHYSADDR)get_physaddr_from_sgc;
939 if (unlikely(!esas2r_build_sg_list(a, rq, &sgc))) {
941 esas2r_free_request(a, rq);
942 return SCSI_MLQUEUE_HOST_BUSY;
945 esas2r_debug("start request %p to %d:%d\n", rq, (int)cmd->device->id,
946 (int)cmd->device->lun);
948 esas2r_start_request(a, rq);
953 static void complete_task_management_request(struct esas2r_adapter *a,
954 struct esas2r_request *rq)
956 (*rq->task_management_status_ptr) = rq->req_stat;
957 esas2r_free_request(a, rq);
961 * Searches the specified queue for the specified queue for the command
965 * @param [in] abort_request
968 * @return 0 on failure, 1 if command was not found, 2 if command was found
970 static int esas2r_check_active_queue(struct esas2r_adapter *a,
971 struct esas2r_request **abort_request,
972 struct scsi_cmnd *cmd,
973 struct list_head *queue)
976 struct esas2r_request *ar = *abort_request;
977 struct esas2r_request *rq;
978 struct list_head *element, *next;
980 list_for_each_safe(element, next, queue) {
982 rq = list_entry(element, struct esas2r_request, req_list);
984 if (rq->cmd == cmd) {
986 /* Found the request. See what to do with it. */
987 if (queue == &a->active_list) {
989 * We are searching the active queue, which
990 * means that we need to send an abort request
993 ar = esas2r_alloc_request(a);
995 esas2r_log_dev(ESAS2R_LOG_WARN,
996 &(a->host->shost_gendev),
997 "unable to allocate an abort request for cmd %p",
999 return 0; /* Failure */
1003 * Task management request must be formatted
1007 ar->vrq->scsi.length = 0;
1008 ar->target_id = rq->target_id;
1009 ar->vrq->scsi.flags |= cpu_to_le32(
1010 (u8)le32_to_cpu(rq->vrq->scsi.flags));
1012 memset(ar->vrq->scsi.cdb, 0,
1013 sizeof(ar->vrq->scsi.cdb));
1015 ar->vrq->scsi.flags |= cpu_to_le32(
1017 ar->vrq->scsi.u.abort_handle =
1018 rq->vrq->scsi.handle;
1021 * The request is pending but not active on
1022 * the firmware. Just free it now and we'll
1023 * report the successful abort below.
1025 list_del_init(&rq->req_list);
1026 esas2r_free_request(a, rq);
1036 return 1; /* Not found */
1038 return 2; /* found */
1043 int esas2r_eh_abort(struct scsi_cmnd *cmd)
1045 struct esas2r_adapter *a =
1046 (struct esas2r_adapter *)cmd->device->host->hostdata;
1047 struct esas2r_request *abort_request = NULL;
1048 unsigned long flags;
1049 struct list_head *queue;
1052 esas2r_log(ESAS2R_LOG_INFO, "eh_abort (%p)", cmd);
1054 if (test_bit(AF_DEGRADED_MODE, &a->flags)) {
1055 cmd->result = DID_ABORT << 16;
1057 scsi_set_resid(cmd, 0);
1059 cmd->scsi_done(cmd);
1064 spin_lock_irqsave(&a->queue_lock, flags);
1067 * Run through the defer and active queues looking for the request
1071 queue = &a->defer_list;
1075 result = esas2r_check_active_queue(a, &abort_request, cmd, queue);
1078 spin_unlock_irqrestore(&a->queue_lock, flags);
1080 } else if (result == 2 && (queue == &a->defer_list)) {
1081 queue = &a->active_list;
1082 goto check_active_queue;
1085 spin_unlock_irqrestore(&a->queue_lock, flags);
1087 if (abort_request) {
1088 u8 task_management_status = RS_PENDING;
1091 * the request is already active, so we need to tell
1092 * the firmware to abort it and wait for the response.
1095 abort_request->comp_cb = complete_task_management_request;
1096 abort_request->task_management_status_ptr =
1097 &task_management_status;
1099 esas2r_start_request(a, abort_request);
1101 if (atomic_read(&a->disable_cnt) == 0)
1102 esas2r_do_deferred_processes(a);
1104 while (task_management_status == RS_PENDING)
1108 * Once we get here, the original request will have been
1109 * completed by the firmware and the abort request will have
1110 * been cleaned up. we're done!
1117 * If we get here, either we found the inactive request and
1118 * freed it, or we didn't find it at all. Either way, success!
1121 cmd->result = DID_ABORT << 16;
1123 scsi_set_resid(cmd, 0);
1125 cmd->scsi_done(cmd);
1130 static int esas2r_host_bus_reset(struct scsi_cmnd *cmd, bool host_reset)
1132 struct esas2r_adapter *a =
1133 (struct esas2r_adapter *)cmd->device->host->hostdata;
1135 if (test_bit(AF_DEGRADED_MODE, &a->flags))
1139 esas2r_reset_adapter(a);
1141 esas2r_reset_bus(a);
1143 /* above call sets the AF_OS_RESET flag. wait for it to clear. */
1145 while (test_bit(AF_OS_RESET, &a->flags)) {
1148 if (test_bit(AF_DEGRADED_MODE, &a->flags))
1152 if (test_bit(AF_DEGRADED_MODE, &a->flags))
1158 int esas2r_host_reset(struct scsi_cmnd *cmd)
1160 esas2r_log(ESAS2R_LOG_INFO, "host_reset (%p)", cmd);
1162 return esas2r_host_bus_reset(cmd, true);
1165 int esas2r_bus_reset(struct scsi_cmnd *cmd)
1167 esas2r_log(ESAS2R_LOG_INFO, "bus_reset (%p)", cmd);
1169 return esas2r_host_bus_reset(cmd, false);
1172 static int esas2r_dev_targ_reset(struct scsi_cmnd *cmd, bool target_reset)
1174 struct esas2r_adapter *a =
1175 (struct esas2r_adapter *)cmd->device->host->hostdata;
1176 struct esas2r_request *rq;
1177 u8 task_management_status = RS_PENDING;
1180 if (test_bit(AF_DEGRADED_MODE, &a->flags))
1184 rq = esas2r_alloc_request(a);
1187 esas2r_log(ESAS2R_LOG_CRIT,
1188 "unable to allocate a request for a "
1189 "target reset (%d)!",
1192 esas2r_log(ESAS2R_LOG_CRIT,
1193 "unable to allocate a request for a "
1194 "device reset (%d:%d)!",
1203 rq->target_id = cmd->device->id;
1204 rq->vrq->scsi.flags |= cpu_to_le32(cmd->device->lun);
1205 rq->req_stat = RS_PENDING;
1207 rq->comp_cb = complete_task_management_request;
1208 rq->task_management_status_ptr = &task_management_status;
1211 esas2r_debug("issuing target reset (%p) to id %d", rq,
1213 completed = esas2r_send_task_mgmt(a, rq, 0x20);
1215 esas2r_debug("issuing device reset (%p) to id %d lun %d", rq,
1216 cmd->device->id, cmd->device->lun);
1217 completed = esas2r_send_task_mgmt(a, rq, 0x10);
1221 /* Task management cmd completed right away, need to free it. */
1223 esas2r_free_request(a, rq);
1226 * Wait for firmware to complete the request. Completion
1227 * callback will free it.
1229 while (task_management_status == RS_PENDING)
1233 if (test_bit(AF_DEGRADED_MODE, &a->flags))
1236 if (task_management_status == RS_BUSY) {
1238 * Busy, probably because we are flashing. Wait a bit and
1248 int esas2r_device_reset(struct scsi_cmnd *cmd)
1250 esas2r_log(ESAS2R_LOG_INFO, "device_reset (%p)", cmd);
1252 return esas2r_dev_targ_reset(cmd, false);
1256 int esas2r_target_reset(struct scsi_cmnd *cmd)
1258 esas2r_log(ESAS2R_LOG_INFO, "target_reset (%p)", cmd);
1260 return esas2r_dev_targ_reset(cmd, true);
1263 int esas2r_change_queue_depth(struct scsi_device *dev, int depth, int reason)
1265 esas2r_log(ESAS2R_LOG_INFO, "change_queue_depth %p, %d", dev, depth);
1267 scsi_adjust_queue_depth(dev, scsi_get_tag_type(dev), depth);
1269 return dev->queue_depth;
1272 int esas2r_slave_alloc(struct scsi_device *dev)
1277 int esas2r_slave_configure(struct scsi_device *dev)
1279 esas2r_log_dev(ESAS2R_LOG_INFO, &(dev->sdev_gendev),
1280 "esas2r_slave_configure()");
1282 if (dev->tagged_supported)
1283 scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, cmd_per_lun);
1285 scsi_adjust_queue_depth(dev, 0, cmd_per_lun);
1290 void esas2r_slave_destroy(struct scsi_device *dev)
1292 esas2r_log_dev(ESAS2R_LOG_INFO, &(dev->sdev_gendev),
1293 "esas2r_slave_destroy()");
1296 void esas2r_log_request_failure(struct esas2r_adapter *a,
1297 struct esas2r_request *rq)
1299 u8 reqstatus = rq->req_stat;
1301 if (reqstatus == RS_SUCCESS)
1304 if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
1305 if (reqstatus == RS_SCSI_ERROR) {
1306 if (rq->func_rsp.scsi_rsp.sense_len >= 13) {
1307 esas2r_log(ESAS2R_LOG_WARN,
1308 "request failure - SCSI error %x ASC:%x ASCQ:%x CDB:%x",
1309 rq->sense_buf[2], rq->sense_buf[12],
1311 rq->vrq->scsi.cdb[0]);
1313 esas2r_log(ESAS2R_LOG_WARN,
1314 "request failure - SCSI error CDB:%x\n",
1315 rq->vrq->scsi.cdb[0]);
1317 } else if ((rq->vrq->scsi.cdb[0] != INQUIRY
1318 && rq->vrq->scsi.cdb[0] != REPORT_LUNS)
1319 || (reqstatus != RS_SEL
1320 && reqstatus != RS_SEL2)) {
1321 if ((reqstatus == RS_UNDERRUN) &&
1322 (rq->vrq->scsi.cdb[0] == INQUIRY)) {
1323 /* Don't log inquiry underruns */
1325 esas2r_log(ESAS2R_LOG_WARN,
1326 "request failure - cdb:%x reqstatus:%d target:%d",
1327 rq->vrq->scsi.cdb[0], reqstatus,
1334 void esas2r_wait_request(struct esas2r_adapter *a, struct esas2r_request *rq)
1339 starttime = jiffies_to_msecs(jiffies);
1340 timeout = rq->timeout ? rq->timeout : 5000;
1343 esas2r_polled_interrupt(a);
1345 if (rq->req_stat != RS_STARTED)
1348 schedule_timeout_interruptible(msecs_to_jiffies(100));
1350 if ((jiffies_to_msecs(jiffies) - starttime) > timeout) {
1351 esas2r_hdebug("request TMO");
1354 rq->req_stat = RS_TIMEOUT;
1356 esas2r_local_reset_adapter(a);
1362 u32 esas2r_map_data_window(struct esas2r_adapter *a, u32 addr_lo)
1364 u32 offset = addr_lo & (MW_DATA_WINDOW_SIZE - 1);
1365 u32 base = addr_lo & -(signed int)MW_DATA_WINDOW_SIZE;
1367 if (a->window_base != base) {
1368 esas2r_write_register_dword(a, MVR_PCI_WIN1_REMAP,
1369 base | MVRPW1R_ENABLE);
1370 esas2r_flush_register_dword(a, MVR_PCI_WIN1_REMAP);
1371 a->window_base = base;
1377 /* Read a block of data from chip memory */
1378 bool esas2r_read_mem_block(struct esas2r_adapter *a,
1390 iatvr = (from & -(signed int)MW_DATA_WINDOW_SIZE);
1392 esas2r_map_data_window(a, iatvr);
1394 offset = from & (MW_DATA_WINDOW_SIZE - 1);
1397 if (len > MW_DATA_WINDOW_SIZE - offset)
1398 len = MW_DATA_WINDOW_SIZE - offset;
1404 *end++ = esas2r_read_data_byte(a, offset);
1412 void esas2r_nuxi_mgt_data(u8 function, void *data)
1414 struct atto_vda_grp_info *g;
1415 struct atto_vda_devinfo *d;
1416 struct atto_vdapart_info *p;
1417 struct atto_vda_dh_info *h;
1418 struct atto_vda_metrics_info *m;
1419 struct atto_vda_schedule_info *s;
1420 struct atto_vda_buzzer_info *b;
1424 case VDAMGT_BUZZER_INFO:
1425 case VDAMGT_BUZZER_SET:
1427 b = (struct atto_vda_buzzer_info *)data;
1429 b->duration = le32_to_cpu(b->duration);
1432 case VDAMGT_SCHEDULE_INFO:
1433 case VDAMGT_SCHEDULE_EVENT:
1435 s = (struct atto_vda_schedule_info *)data;
1437 s->id = le32_to_cpu(s->id);
1441 case VDAMGT_DEV_INFO:
1442 case VDAMGT_DEV_CLEAN:
1443 case VDAMGT_DEV_PT_INFO:
1444 case VDAMGT_DEV_FEATURES:
1445 case VDAMGT_DEV_PT_FEATURES:
1446 case VDAMGT_DEV_OPERATION:
1448 d = (struct atto_vda_devinfo *)data;
1450 d->capacity = le64_to_cpu(d->capacity);
1451 d->block_size = le32_to_cpu(d->block_size);
1452 d->ses_dev_index = le16_to_cpu(d->ses_dev_index);
1453 d->target_id = le16_to_cpu(d->target_id);
1454 d->lun = le16_to_cpu(d->lun);
1455 d->features = le16_to_cpu(d->features);
1458 case VDAMGT_GRP_INFO:
1459 case VDAMGT_GRP_CREATE:
1460 case VDAMGT_GRP_DELETE:
1461 case VDAMGT_ADD_STORAGE:
1462 case VDAMGT_MEMBER_ADD:
1463 case VDAMGT_GRP_COMMIT:
1464 case VDAMGT_GRP_REBUILD:
1465 case VDAMGT_GRP_COMMIT_INIT:
1466 case VDAMGT_QUICK_RAID:
1467 case VDAMGT_GRP_FEATURES:
1468 case VDAMGT_GRP_COMMIT_INIT_AUTOMAP:
1469 case VDAMGT_QUICK_RAID_INIT_AUTOMAP:
1470 case VDAMGT_SPARE_LIST:
1471 case VDAMGT_SPARE_ADD:
1472 case VDAMGT_SPARE_REMOVE:
1473 case VDAMGT_LOCAL_SPARE_ADD:
1474 case VDAMGT_GRP_OPERATION:
1476 g = (struct atto_vda_grp_info *)data;
1478 g->capacity = le64_to_cpu(g->capacity);
1479 g->block_size = le32_to_cpu(g->block_size);
1480 g->interleave = le32_to_cpu(g->interleave);
1481 g->features = le16_to_cpu(g->features);
1483 for (i = 0; i < 32; i++)
1484 g->members[i] = le16_to_cpu(g->members[i]);
1488 case VDAMGT_PART_INFO:
1489 case VDAMGT_PART_MAP:
1490 case VDAMGT_PART_UNMAP:
1491 case VDAMGT_PART_AUTOMAP:
1492 case VDAMGT_PART_SPLIT:
1493 case VDAMGT_PART_MERGE:
1495 p = (struct atto_vdapart_info *)data;
1497 p->part_size = le64_to_cpu(p->part_size);
1498 p->start_lba = le32_to_cpu(p->start_lba);
1499 p->block_size = le32_to_cpu(p->block_size);
1500 p->target_id = le16_to_cpu(p->target_id);
1503 case VDAMGT_DEV_HEALTH_REQ:
1505 h = (struct atto_vda_dh_info *)data;
1507 h->med_defect_cnt = le32_to_cpu(h->med_defect_cnt);
1508 h->info_exc_cnt = le32_to_cpu(h->info_exc_cnt);
1511 case VDAMGT_DEV_METRICS:
1513 m = (struct atto_vda_metrics_info *)data;
1515 for (i = 0; i < 32; i++)
1516 m->dev_indexes[i] = le16_to_cpu(m->dev_indexes[i]);
1525 void esas2r_nuxi_cfg_data(u8 function, void *data)
1527 struct atto_vda_cfg_init *ci;
1531 case VDA_CFG_GET_INIT:
1532 case VDA_CFG_GET_INIT2:
1534 ci = (struct atto_vda_cfg_init *)data;
1536 ci->date_time.year = le16_to_cpu(ci->date_time.year);
1537 ci->sgl_page_size = le32_to_cpu(ci->sgl_page_size);
1538 ci->vda_version = le32_to_cpu(ci->vda_version);
1539 ci->epoch_time = le32_to_cpu(ci->epoch_time);
1540 ci->ioctl_tunnel = le32_to_cpu(ci->ioctl_tunnel);
1541 ci->num_targets_backend = le32_to_cpu(ci->num_targets_backend);
1549 void esas2r_nuxi_ae_data(union atto_vda_ae *ae)
1551 struct atto_vda_ae_raid *r = &ae->raid;
1552 struct atto_vda_ae_lu *l = &ae->lu;
1554 switch (ae->hdr.bytype) {
1555 case VDAAE_HDR_TYPE_RAID:
1557 r->dwflags = le32_to_cpu(r->dwflags);
1560 case VDAAE_HDR_TYPE_LU:
1562 l->dwevent = le32_to_cpu(l->dwevent);
1563 l->wphys_target_id = le16_to_cpu(l->wphys_target_id);
1564 l->id.tgtlun.wtarget_id = le16_to_cpu(l->id.tgtlun.wtarget_id);
1566 if (l->hdr.bylength >= offsetof(struct atto_vda_ae_lu, id)
1567 + sizeof(struct atto_vda_ae_lu_tgt_lun_raid)) {
1568 l->id.tgtlun_raid.dwinterleave
1569 = le32_to_cpu(l->id.tgtlun_raid.dwinterleave);
1570 l->id.tgtlun_raid.dwblock_size
1571 = le32_to_cpu(l->id.tgtlun_raid.dwblock_size);
1576 case VDAAE_HDR_TYPE_DISK:
1582 void esas2r_free_request(struct esas2r_adapter *a, struct esas2r_request *rq)
1584 unsigned long flags;
1586 esas2r_rq_destroy_request(rq, a);
1587 spin_lock_irqsave(&a->request_lock, flags);
1588 list_add(&rq->comp_list, &a->avail_request);
1589 spin_unlock_irqrestore(&a->request_lock, flags);
1592 struct esas2r_request *esas2r_alloc_request(struct esas2r_adapter *a)
1594 struct esas2r_request *rq;
1595 unsigned long flags;
1597 spin_lock_irqsave(&a->request_lock, flags);
1599 if (unlikely(list_empty(&a->avail_request))) {
1600 spin_unlock_irqrestore(&a->request_lock, flags);
1604 rq = list_first_entry(&a->avail_request, struct esas2r_request,
1606 list_del(&rq->comp_list);
1607 spin_unlock_irqrestore(&a->request_lock, flags);
1608 esas2r_rq_init_request(rq, a);
1614 void esas2r_complete_request_cb(struct esas2r_adapter *a,
1615 struct esas2r_request *rq)
1617 esas2r_debug("completing request %p\n", rq);
1619 scsi_dma_unmap(rq->cmd);
1621 if (unlikely(rq->req_stat != RS_SUCCESS)) {
1622 esas2r_debug("[%x STATUS %x:%x (%x)]", rq->target_id,
1624 rq->func_rsp.scsi_rsp.scsi_stat,
1628 ((esas2r_req_status_to_error(rq->req_stat) << 16)
1629 | (rq->func_rsp.scsi_rsp.scsi_stat & STATUS_MASK));
1631 if (rq->req_stat == RS_UNDERRUN)
1632 scsi_set_resid(rq->cmd,
1633 le32_to_cpu(rq->func_rsp.scsi_rsp.
1636 scsi_set_resid(rq->cmd, 0);
1639 rq->cmd->scsi_done(rq->cmd);
1641 esas2r_free_request(a, rq);
1644 /* Run tasklet to handle stuff outside of interrupt context. */
1645 void esas2r_adapter_tasklet(unsigned long context)
1647 struct esas2r_adapter *a = (struct esas2r_adapter *)context;
1649 if (unlikely(test_bit(AF2_TIMER_TICK, &a->flags2))) {
1650 clear_bit(AF2_TIMER_TICK, &a->flags2);
1651 esas2r_timer_tick(a);
1654 if (likely(test_bit(AF2_INT_PENDING, &a->flags2))) {
1655 clear_bit(AF2_INT_PENDING, &a->flags2);
1656 esas2r_adapter_interrupt(a);
1659 if (esas2r_is_tasklet_pending(a))
1660 esas2r_do_tasklet_tasks(a);
1662 if (esas2r_is_tasklet_pending(a)
1663 || (test_bit(AF2_INT_PENDING, &a->flags2))
1664 || (test_bit(AF2_TIMER_TICK, &a->flags2))) {
1665 clear_bit(AF_TASKLET_SCHEDULED, &a->flags);
1666 esas2r_schedule_tasklet(a);
1668 clear_bit(AF_TASKLET_SCHEDULED, &a->flags);
1672 static void esas2r_timer_callback(unsigned long context);
1674 void esas2r_kickoff_timer(struct esas2r_adapter *a)
1676 init_timer(&a->timer);
1678 a->timer.function = esas2r_timer_callback;
1679 a->timer.data = (unsigned long)a;
1680 a->timer.expires = jiffies +
1681 msecs_to_jiffies(100);
1683 add_timer(&a->timer);
1686 static void esas2r_timer_callback(unsigned long context)
1688 struct esas2r_adapter *a = (struct esas2r_adapter *)context;
1690 set_bit(AF2_TIMER_TICK, &a->flags2);
1692 esas2r_schedule_tasklet(a);
1694 esas2r_kickoff_timer(a);
1698 * Firmware events need to be handled outside of interrupt context
1699 * so we schedule a delayed_work to handle them.
1703 esas2r_free_fw_event(struct esas2r_fw_event_work *fw_event)
1705 unsigned long flags;
1706 struct esas2r_adapter *a = fw_event->a;
1708 spin_lock_irqsave(&a->fw_event_lock, flags);
1709 list_del(&fw_event->list);
1711 spin_unlock_irqrestore(&a->fw_event_lock, flags);
1715 esas2r_fw_event_off(struct esas2r_adapter *a)
1717 unsigned long flags;
1719 spin_lock_irqsave(&a->fw_event_lock, flags);
1720 a->fw_events_off = 1;
1721 spin_unlock_irqrestore(&a->fw_event_lock, flags);
1725 esas2r_fw_event_on(struct esas2r_adapter *a)
1727 unsigned long flags;
1729 spin_lock_irqsave(&a->fw_event_lock, flags);
1730 a->fw_events_off = 0;
1731 spin_unlock_irqrestore(&a->fw_event_lock, flags);
1734 static void esas2r_add_device(struct esas2r_adapter *a, u16 target_id)
1737 struct scsi_device *scsi_dev;
1739 scsi_dev = scsi_device_lookup(a->host, 0, target_id, 0);
1746 "scsi device already exists at id %d", target_id);
1748 scsi_device_put(scsi_dev);
1754 "scsi_add_device() called for 0:%d:0",
1757 ret = scsi_add_device(a->host, 0, target_id, 0);
1763 "scsi_add_device failed with %d for id %d",
1769 static void esas2r_remove_device(struct esas2r_adapter *a, u16 target_id)
1771 struct scsi_device *scsi_dev;
1773 scsi_dev = scsi_device_lookup(a->host, 0, target_id, 0);
1776 scsi_device_set_state(scsi_dev, SDEV_OFFLINE);
1782 "scsi_remove_device() called for 0:%d:0",
1785 scsi_remove_device(scsi_dev);
1791 "scsi_device_put() called");
1793 scsi_device_put(scsi_dev);
1797 &(a->host->shost_gendev),
1798 "no target found at id %d",
1804 * Sends a firmware asynchronous event to anyone who happens to be
1805 * listening on the defined ATTO VDA event ports.
1807 static void esas2r_send_ae_event(struct esas2r_fw_event_work *fw_event)
1809 struct esas2r_vda_ae *ae = (struct esas2r_vda_ae *)fw_event->data;
1812 switch (ae->vda_ae.hdr.bytype) {
1813 case VDAAE_HDR_TYPE_RAID:
1814 type = "RAID group state change";
1817 case VDAAE_HDR_TYPE_LU:
1818 type = "Mapped destination LU change";
1821 case VDAAE_HDR_TYPE_DISK:
1822 type = "Physical disk inventory change";
1825 case VDAAE_HDR_TYPE_RESET:
1826 type = "Firmware reset";
1829 case VDAAE_HDR_TYPE_LOG_INFO:
1830 type = "Event Log message (INFO level)";
1833 case VDAAE_HDR_TYPE_LOG_WARN:
1834 type = "Event Log message (WARN level)";
1837 case VDAAE_HDR_TYPE_LOG_CRIT:
1838 type = "Event Log message (CRIT level)";
1841 case VDAAE_HDR_TYPE_LOG_FAIL:
1842 type = "Event Log message (FAIL level)";
1845 case VDAAE_HDR_TYPE_NVC:
1846 type = "NVCache change";
1849 case VDAAE_HDR_TYPE_TLG_INFO:
1850 type = "Time stamped log message (INFO level)";
1853 case VDAAE_HDR_TYPE_TLG_WARN:
1854 type = "Time stamped log message (WARN level)";
1857 case VDAAE_HDR_TYPE_TLG_CRIT:
1858 type = "Time stamped log message (CRIT level)";
1861 case VDAAE_HDR_TYPE_PWRMGT:
1862 type = "Power management";
1865 case VDAAE_HDR_TYPE_MUTE:
1866 type = "Mute button pressed";
1869 case VDAAE_HDR_TYPE_DEV:
1870 type = "Device attribute change";
1878 esas2r_log(ESAS2R_LOG_WARN,
1879 "An async event of type \"%s\" was received from the firmware. The event contents are:",
1881 esas2r_log_hexdump(ESAS2R_LOG_WARN, &ae->vda_ae,
1882 ae->vda_ae.hdr.bylength);
1887 esas2r_firmware_event_work(struct work_struct *work)
1889 struct esas2r_fw_event_work *fw_event =
1890 container_of(work, struct esas2r_fw_event_work, work.work);
1892 struct esas2r_adapter *a = fw_event->a;
1894 u16 target_id = *(u16 *)&fw_event->data[0];
1896 if (a->fw_events_off)
1899 switch (fw_event->type) {
1901 break; /* do nothing */
1903 case fw_event_lun_change:
1904 esas2r_remove_device(a, target_id);
1905 esas2r_add_device(a, target_id);
1908 case fw_event_present:
1909 esas2r_add_device(a, target_id);
1912 case fw_event_not_present:
1913 esas2r_remove_device(a, target_id);
1916 case fw_event_vda_ae:
1917 esas2r_send_ae_event(fw_event);
1922 esas2r_free_fw_event(fw_event);
1925 void esas2r_queue_fw_event(struct esas2r_adapter *a,
1926 enum fw_event_type type,
1930 struct esas2r_fw_event_work *fw_event;
1931 unsigned long flags;
1933 fw_event = kzalloc(sizeof(struct esas2r_fw_event_work), GFP_ATOMIC);
1935 esas2r_log(ESAS2R_LOG_WARN,
1936 "esas2r_queue_fw_event failed to alloc");
1940 if (type == fw_event_vda_ae) {
1941 struct esas2r_vda_ae *ae =
1942 (struct esas2r_vda_ae *)fw_event->data;
1944 ae->signature = ESAS2R_VDA_EVENT_SIG;
1945 ae->bus_number = a->pcid->bus->number;
1946 ae->devfn = a->pcid->devfn;
1947 memcpy(&ae->vda_ae, data, sizeof(ae->vda_ae));
1949 memcpy(fw_event->data, data, data_sz);
1952 fw_event->type = type;
1955 spin_lock_irqsave(&a->fw_event_lock, flags);
1956 list_add_tail(&fw_event->list, &a->fw_event_list);
1957 INIT_DELAYED_WORK(&fw_event->work, esas2r_firmware_event_work);
1958 queue_delayed_work_on(
1959 smp_processor_id(), a->fw_event_q, &fw_event->work,
1960 msecs_to_jiffies(1));
1961 spin_unlock_irqrestore(&a->fw_event_lock, flags);
1964 void esas2r_target_state_changed(struct esas2r_adapter *a, u16 targ_id,
1967 if (state == TS_LUN_CHANGE)
1968 esas2r_queue_fw_event(a, fw_event_lun_change, &targ_id,
1970 else if (state == TS_PRESENT)
1971 esas2r_queue_fw_event(a, fw_event_present, &targ_id,
1973 else if (state == TS_NOT_PRESENT)
1974 esas2r_queue_fw_event(a, fw_event_not_present, &targ_id,
1978 /* Translate status to a Linux SCSI mid-layer error code */
1979 int esas2r_req_status_to_error(u8 req_stat)
1986 * NOTE: SCSI mid-layer wants a good status for a SCSI error, because
1987 * it will check the scsi_stat value in the completion anyway.
1994 return DID_NO_CONNECT;
2003 return DID_BUS_BUSY;
2006 /* everything else is just an error. */
2011 module_init(esas2r_init);
2012 module_exit(esas2r_exit);