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