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
45
46
47
48
49
50
51
52
53
54
55
56#include <linux/kernel.h>
57#include <linux/init.h>
58#include <linux/module.h>
59#include <linux/firmware.h>
60#include <linux/efi.h>
61#include <asm/string.h>
62#include <scsi/scsi_host.h>
63#include "host.h"
64#include "isci.h"
65#include "task.h"
66#include "probe_roms.h"
67
68#define MAJ 1
69#define MIN 1
70#define BUILD 0
71#define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \
72 __stringify(BUILD)
73
74MODULE_VERSION(DRV_VERSION);
75
76static struct scsi_transport_template *isci_transport_template;
77
78static DEFINE_PCI_DEVICE_TABLE(isci_id_table) = {
79 { PCI_VDEVICE(INTEL, 0x1D61),},
80 { PCI_VDEVICE(INTEL, 0x1D63),},
81 { PCI_VDEVICE(INTEL, 0x1D65),},
82 { PCI_VDEVICE(INTEL, 0x1D67),},
83 { PCI_VDEVICE(INTEL, 0x1D69),},
84 { PCI_VDEVICE(INTEL, 0x1D6B),},
85 { PCI_VDEVICE(INTEL, 0x1D60),},
86 { PCI_VDEVICE(INTEL, 0x1D62),},
87 { PCI_VDEVICE(INTEL, 0x1D64),},
88 { PCI_VDEVICE(INTEL, 0x1D66),},
89 { PCI_VDEVICE(INTEL, 0x1D68),},
90 { PCI_VDEVICE(INTEL, 0x1D6A),},
91 {}
92};
93
94MODULE_DEVICE_TABLE(pci, isci_id_table);
95
96
97
98unsigned char no_outbound_task_to = 2;
99module_param(no_outbound_task_to, byte, 0);
100MODULE_PARM_DESC(no_outbound_task_to, "No Outbound Task Timeout (1us incr)");
101
102u16 ssp_max_occ_to = 20;
103module_param(ssp_max_occ_to, ushort, 0);
104MODULE_PARM_DESC(ssp_max_occ_to, "SSP Max occupancy timeout (100us incr)");
105
106u16 stp_max_occ_to = 5;
107module_param(stp_max_occ_to, ushort, 0);
108MODULE_PARM_DESC(stp_max_occ_to, "STP Max occupancy timeout (100us incr)");
109
110u16 ssp_inactive_to = 5;
111module_param(ssp_inactive_to, ushort, 0);
112MODULE_PARM_DESC(ssp_inactive_to, "SSP inactivity timeout (100us incr)");
113
114u16 stp_inactive_to = 5;
115module_param(stp_inactive_to, ushort, 0);
116MODULE_PARM_DESC(stp_inactive_to, "STP inactivity timeout (100us incr)");
117
118unsigned char phy_gen = SCIC_SDS_PARM_GEN2_SPEED;
119module_param(phy_gen, byte, 0);
120MODULE_PARM_DESC(phy_gen, "PHY generation (1: 1.5Gbps 2: 3.0Gbps 3: 6.0Gbps)");
121
122unsigned char max_concurr_spinup;
123module_param(max_concurr_spinup, byte, 0);
124MODULE_PARM_DESC(max_concurr_spinup, "Max concurrent device spinup");
125
126uint cable_selection_override = CABLE_OVERRIDE_DISABLED;
127module_param(cable_selection_override, uint, 0);
128
129MODULE_PARM_DESC(cable_selection_override,
130 "This field indicates length of the SAS/SATA cable between "
131 "host and device. If any bits > 15 are set (default) "
132 "indicates \"use platform defaults\"");
133
134static ssize_t isci_show_id(struct device *dev, struct device_attribute *attr, char *buf)
135{
136 struct Scsi_Host *shost = container_of(dev, typeof(*shost), shost_dev);
137 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
138 struct isci_host *ihost = container_of(sas_ha, typeof(*ihost), sas_ha);
139
140 return snprintf(buf, PAGE_SIZE, "%d\n", ihost->id);
141}
142
143static DEVICE_ATTR(isci_id, S_IRUGO, isci_show_id, NULL);
144
145struct device_attribute *isci_host_attrs[] = {
146 &dev_attr_isci_id,
147 NULL
148};
149
150static struct scsi_host_template isci_sht = {
151
152 .module = THIS_MODULE,
153 .name = DRV_NAME,
154 .proc_name = DRV_NAME,
155 .queuecommand = sas_queuecommand,
156 .target_alloc = sas_target_alloc,
157 .slave_configure = sas_slave_configure,
158 .scan_finished = isci_host_scan_finished,
159 .scan_start = isci_host_scan_start,
160 .change_queue_depth = sas_change_queue_depth,
161 .change_queue_type = sas_change_queue_type,
162 .bios_param = sas_bios_param,
163 .can_queue = ISCI_CAN_QUEUE_VAL,
164 .cmd_per_lun = 1,
165 .this_id = -1,
166 .sg_tablesize = SG_ALL,
167 .max_sectors = SCSI_DEFAULT_MAX_SECTORS,
168 .use_clustering = ENABLE_CLUSTERING,
169 .target_destroy = sas_target_destroy,
170 .ioctl = sas_ioctl,
171 .shost_attrs = isci_host_attrs,
172};
173
174static struct sas_domain_function_template isci_transport_ops = {
175
176
177 .lldd_port_formed = isci_port_formed,
178 .lldd_port_deformed = isci_port_deformed,
179
180
181 .lldd_dev_found = isci_remote_device_found,
182 .lldd_dev_gone = isci_remote_device_gone,
183
184 .lldd_execute_task = isci_task_execute_task,
185
186 .lldd_abort_task = isci_task_abort_task,
187 .lldd_abort_task_set = isci_task_abort_task_set,
188 .lldd_clear_aca = isci_task_clear_aca,
189 .lldd_clear_task_set = isci_task_clear_task_set,
190 .lldd_I_T_nexus_reset = isci_task_I_T_nexus_reset,
191 .lldd_lu_reset = isci_task_lu_reset,
192 .lldd_query_task = isci_task_query_task,
193
194
195 .lldd_ata_check_ready = isci_ata_check_ready,
196
197
198 .lldd_clear_nexus_port = isci_task_clear_nexus_port,
199 .lldd_clear_nexus_ha = isci_task_clear_nexus_ha,
200
201
202 .lldd_control_phy = isci_phy_control,
203
204
205 .lldd_write_gpio = isci_gpio_write,
206};
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226static int isci_register_sas_ha(struct isci_host *isci_host)
227{
228 int i;
229 struct sas_ha_struct *sas_ha = &(isci_host->sas_ha);
230 struct asd_sas_phy **sas_phys;
231 struct asd_sas_port **sas_ports;
232
233 sas_phys = devm_kzalloc(&isci_host->pdev->dev,
234 SCI_MAX_PHYS * sizeof(void *),
235 GFP_KERNEL);
236 if (!sas_phys)
237 return -ENOMEM;
238
239 sas_ports = devm_kzalloc(&isci_host->pdev->dev,
240 SCI_MAX_PORTS * sizeof(void *),
241 GFP_KERNEL);
242 if (!sas_ports)
243 return -ENOMEM;
244
245 sas_ha->sas_ha_name = DRV_NAME;
246 sas_ha->lldd_module = THIS_MODULE;
247 sas_ha->sas_addr = &isci_host->phys[0].sas_addr[0];
248
249 for (i = 0; i < SCI_MAX_PHYS; i++) {
250 sas_phys[i] = &isci_host->phys[i].sas_phy;
251 sas_ports[i] = &isci_host->sas_ports[i];
252 }
253
254 sas_ha->sas_phy = sas_phys;
255 sas_ha->sas_port = sas_ports;
256 sas_ha->num_phys = SCI_MAX_PHYS;
257
258 sas_ha->lldd_queue_size = ISCI_CAN_QUEUE_VAL;
259 sas_ha->lldd_max_execute_num = 1;
260 sas_ha->strict_wide_ports = 1;
261
262 sas_register_ha(sas_ha);
263
264 return 0;
265}
266
267static void isci_unregister(struct isci_host *isci_host)
268{
269 struct Scsi_Host *shost;
270
271 if (!isci_host)
272 return;
273
274 shost = isci_host->shost;
275
276 sas_unregister_ha(&isci_host->sas_ha);
277
278 sas_remove_host(isci_host->shost);
279 scsi_remove_host(isci_host->shost);
280 scsi_host_put(isci_host->shost);
281}
282
283static int __devinit isci_pci_init(struct pci_dev *pdev)
284{
285 int err, bar_num, bar_mask = 0;
286 void __iomem * const *iomap;
287
288 err = pcim_enable_device(pdev);
289 if (err) {
290 dev_err(&pdev->dev,
291 "failed enable PCI device %s!\n",
292 pci_name(pdev));
293 return err;
294 }
295
296 for (bar_num = 0; bar_num < SCI_PCI_BAR_COUNT; bar_num++)
297 bar_mask |= 1 << (bar_num * 2);
298
299 err = pcim_iomap_regions(pdev, bar_mask, DRV_NAME);
300 if (err)
301 return err;
302
303 iomap = pcim_iomap_table(pdev);
304 if (!iomap)
305 return -ENOMEM;
306
307 pci_set_master(pdev);
308
309 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
310 if (err) {
311 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
312 if (err)
313 return err;
314 }
315
316 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
317 if (err) {
318 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
319 if (err)
320 return err;
321 }
322
323 return 0;
324}
325
326static int num_controllers(struct pci_dev *pdev)
327{
328
329
330
331
332 resource_size_t scu_bar_size = pci_resource_len(pdev, SCI_SCU_BAR*2);
333 resource_size_t smu_bar_size = pci_resource_len(pdev, SCI_SMU_BAR*2);
334
335 if (scu_bar_size >= SCI_SCU_BAR_SIZE*SCI_MAX_CONTROLLERS &&
336 smu_bar_size >= SCI_SMU_BAR_SIZE*SCI_MAX_CONTROLLERS)
337 return SCI_MAX_CONTROLLERS;
338 else
339 return 1;
340}
341
342static int isci_setup_interrupts(struct pci_dev *pdev)
343{
344 int err, i, num_msix;
345 struct isci_host *ihost;
346 struct isci_pci_info *pci_info = to_pci_info(pdev);
347
348
349
350
351
352 num_msix = num_controllers(pdev) * SCI_NUM_MSI_X_INT;
353
354 for (i = 0; i < num_msix; i++)
355 pci_info->msix_entries[i].entry = i;
356
357 err = pci_enable_msix(pdev, pci_info->msix_entries, num_msix);
358 if (err)
359 goto intx;
360
361 for (i = 0; i < num_msix; i++) {
362 int id = i / SCI_NUM_MSI_X_INT;
363 struct msix_entry *msix = &pci_info->msix_entries[i];
364 irq_handler_t isr;
365
366 ihost = pci_info->hosts[id];
367
368 if (i & 1)
369 isr = isci_error_isr;
370 else
371 isr = isci_msix_isr;
372
373 err = devm_request_irq(&pdev->dev, msix->vector, isr, 0,
374 DRV_NAME"-msix", ihost);
375 if (!err)
376 continue;
377
378 dev_info(&pdev->dev, "msix setup failed falling back to intx\n");
379 while (i--) {
380 id = i / SCI_NUM_MSI_X_INT;
381 ihost = pci_info->hosts[id];
382 msix = &pci_info->msix_entries[i];
383 devm_free_irq(&pdev->dev, msix->vector, ihost);
384 }
385 pci_disable_msix(pdev);
386 goto intx;
387 }
388 return 0;
389
390 intx:
391 for_each_isci_host(i, ihost, pdev) {
392 err = devm_request_irq(&pdev->dev, pdev->irq, isci_intx_isr,
393 IRQF_SHARED, DRV_NAME"-intx", ihost);
394 if (err)
395 break;
396 }
397 return err;
398}
399
400static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
401{
402 struct isci_host *isci_host;
403 struct Scsi_Host *shost;
404 int err;
405
406 isci_host = devm_kzalloc(&pdev->dev, sizeof(*isci_host), GFP_KERNEL);
407 if (!isci_host)
408 return NULL;
409
410 isci_host->pdev = pdev;
411 isci_host->id = id;
412
413 shost = scsi_host_alloc(&isci_sht, sizeof(void *));
414 if (!shost)
415 return NULL;
416 isci_host->shost = shost;
417
418 dev_info(&pdev->dev, "%sSCU controller %d: phy 3-0 cables: "
419 "{%s, %s, %s, %s}\n",
420 (is_cable_select_overridden() ? "* " : ""), isci_host->id,
421 lookup_cable_names(decode_cable_selection(isci_host, 3)),
422 lookup_cable_names(decode_cable_selection(isci_host, 2)),
423 lookup_cable_names(decode_cable_selection(isci_host, 1)),
424 lookup_cable_names(decode_cable_selection(isci_host, 0)));
425
426 err = isci_host_init(isci_host);
427 if (err)
428 goto err_shost;
429
430 SHOST_TO_SAS_HA(shost) = &isci_host->sas_ha;
431 isci_host->sas_ha.core.shost = shost;
432 shost->transportt = isci_transport_template;
433
434 shost->max_id = ~0;
435 shost->max_lun = ~0;
436 shost->max_cmd_len = MAX_COMMAND_SIZE;
437
438 err = scsi_add_host(shost, &pdev->dev);
439 if (err)
440 goto err_shost;
441
442 err = isci_register_sas_ha(isci_host);
443 if (err)
444 goto err_shost_remove;
445
446 return isci_host;
447
448 err_shost_remove:
449 scsi_remove_host(shost);
450 err_shost:
451 scsi_host_put(shost);
452
453 return NULL;
454}
455
456static int __devinit isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
457{
458 struct isci_pci_info *pci_info;
459 int err, i;
460 struct isci_host *isci_host;
461 const struct firmware *fw = NULL;
462 struct isci_orom *orom = NULL;
463 char *source = "(platform)";
464
465 dev_info(&pdev->dev, "driver configured for rev: %d silicon\n",
466 pdev->revision);
467
468 pci_info = devm_kzalloc(&pdev->dev, sizeof(*pci_info), GFP_KERNEL);
469 if (!pci_info)
470 return -ENOMEM;
471 pci_set_drvdata(pdev, pci_info);
472
473 if (efi_enabled)
474 orom = isci_get_efi_var(pdev);
475
476 if (!orom)
477 orom = isci_request_oprom(pdev);
478
479 for (i = 0; orom && i < ARRAY_SIZE(orom->ctrl); i++) {
480 if (sci_oem_parameters_validate(&orom->ctrl[i],
481 orom->hdr.version)) {
482 dev_warn(&pdev->dev,
483 "[%d]: invalid oem parameters detected, falling back to firmware\n", i);
484 devm_kfree(&pdev->dev, orom);
485 orom = NULL;
486 break;
487 }
488 }
489
490 if (!orom) {
491 source = "(firmware)";
492 orom = isci_request_firmware(pdev, fw);
493 if (!orom) {
494
495
496
497 dev_warn(&pdev->dev,
498 "Loading user firmware failed, using default "
499 "values\n");
500 dev_warn(&pdev->dev,
501 "Default OEM configuration being used: 4 "
502 "narrow ports, and default SAS Addresses\n");
503 }
504 }
505
506 if (orom)
507 dev_info(&pdev->dev,
508 "OEM SAS parameters (version: %u.%u) loaded %s\n",
509 (orom->hdr.version & 0xf0) >> 4,
510 (orom->hdr.version & 0xf), source);
511
512 pci_info->orom = orom;
513
514 err = isci_pci_init(pdev);
515 if (err)
516 return err;
517
518 for (i = 0; i < num_controllers(pdev); i++) {
519 struct isci_host *h = isci_host_alloc(pdev, i);
520
521 if (!h) {
522 err = -ENOMEM;
523 goto err_host_alloc;
524 }
525 pci_info->hosts[i] = h;
526
527
528 scsi_host_set_prot(h->shost,
529 SHOST_DIF_TYPE1_PROTECTION |
530 SHOST_DIF_TYPE2_PROTECTION |
531 SHOST_DIF_TYPE3_PROTECTION);
532 scsi_host_set_guard(h->shost, SHOST_DIX_GUARD_CRC);
533 }
534
535 err = isci_setup_interrupts(pdev);
536 if (err)
537 goto err_host_alloc;
538
539 for_each_isci_host(i, isci_host, pdev)
540 scsi_scan_host(isci_host->shost);
541
542 return 0;
543
544 err_host_alloc:
545 for_each_isci_host(i, isci_host, pdev)
546 isci_unregister(isci_host);
547 return err;
548}
549
550static void __devexit isci_pci_remove(struct pci_dev *pdev)
551{
552 struct isci_host *ihost;
553 int i;
554
555 for_each_isci_host(i, ihost, pdev) {
556 wait_for_start(ihost);
557 isci_unregister(ihost);
558 isci_host_deinit(ihost);
559 }
560}
561
562static struct pci_driver isci_pci_driver = {
563 .name = DRV_NAME,
564 .id_table = isci_id_table,
565 .probe = isci_pci_probe,
566 .remove = __devexit_p(isci_pci_remove),
567};
568
569static __init int isci_init(void)
570{
571 int err;
572
573 pr_info("%s: Intel(R) C600 SAS Controller Driver - version %s\n",
574 DRV_NAME, DRV_VERSION);
575
576 isci_transport_template = sas_domain_attach_transport(&isci_transport_ops);
577 if (!isci_transport_template)
578 return -ENOMEM;
579
580 err = pci_register_driver(&isci_pci_driver);
581 if (err)
582 sas_release_transport(isci_transport_template);
583
584 return err;
585}
586
587static __exit void isci_exit(void)
588{
589 pci_unregister_driver(&isci_pci_driver);
590 sas_release_transport(isci_transport_template);
591}
592
593MODULE_LICENSE("Dual BSD/GPL");
594MODULE_FIRMWARE(ISCI_FW_NAME);
595module_init(isci_init);
596module_exit(isci_exit);
597
