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