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