Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
Pull SCSI fixes from James Bottomley:
"This is a set of nine fixes (and one author update).
The libsas one should fix discovery in eSATA devices, the WRITE_SAME
one is the largest, but it should fix a lot of problems we've been
getting with the emulated RAID devices (they've been effectively lying
about support and then firmware has been choking on the commands).
The rest are various crash, hang or warn driver fixes"
* tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
[SCSI] bfa: Fix crash when symb name set for offline vport
[SCSI] enclosure: fix WARN_ON in dual path device removing
[SCSI] pm80xx: Tasklets synchronization fix.
[SCSI] pm80xx: Resetting the phy state.
[SCSI] pm80xx: Fix for direct attached device.
[SCSI] pm80xx: Module author addition
[SCSI] hpsa: return 0 from driver probe function on success, not 1
[SCSI] hpsa: do not discard scsi status on aborted commands
[SCSI] Disable WRITE SAME for RAID and virtual host adapter drivers
[SCSI] libsas: fix usage of ata_tf_to_fis
+129
-57
+1
drivers/ata/libata-scsi.c
+1
drivers/ata/libata-scsi.c
+1
drivers/firewire/sbp2.c
+1
drivers/firewire/sbp2.c
+7
drivers/misc/enclosure.c
+7
drivers/misc/enclosure.c
···
198
198
{
199
199
char name[ENCLOSURE_NAME_SIZE];
200
200
201
+
/*
202
+
* In odd circumstances, like multipath devices, something else may
203
+
* already have removed the links, so check for this condition first.
204
+
*/
205
+
if (!cdev->dev->kobj.sd)
206
+
return;
207
+
201
208
enclosure_link_name(cdev, name);
202
209
sysfs_remove_link(&cdev->dev->kobj, name);
203
210
sysfs_remove_link(&cdev->cdev.kobj, "device");
+2
-1
drivers/scsi/3w-9xxx.c
+2
-1
drivers/scsi/3w-9xxx.c
+2
-1
drivers/scsi/3w-sas.c
+2
-1
drivers/scsi/3w-sas.c
+2
-1
drivers/scsi/3w-xxxx.c
+2
-1
drivers/scsi/3w-xxxx.c
+1
drivers/scsi/aacraid/linit.c
+1
drivers/scsi/aacraid/linit.c
+1
drivers/scsi/arcmsr/arcmsr_hba.c
+1
drivers/scsi/arcmsr/arcmsr_hba.c
···
137
137
.cmd_per_lun = ARCMSR_MAX_CMD_PERLUN,
138
138
.use_clustering = ENABLE_CLUSTERING,
139
139
.shost_attrs = arcmsr_host_attrs,
140
+
.no_write_same = 1,
140
141
};
141
142
static struct pci_device_id arcmsr_device_id_table[] = {
142
143
{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1110)},
+1
drivers/scsi/bfa/bfa_fcs.h
+1
drivers/scsi/bfa/bfa_fcs.h
···
296
296
struct bfa_fcs_lport_s *bfa_fcs_lookup_port(struct bfa_fcs_s *fcs,
297
297
u16 vf_id, wwn_t lpwwn);
298
298
299
+
void bfa_fcs_lport_set_symname(struct bfa_fcs_lport_s *port, char *symname);
299
300
void bfa_fcs_lport_get_info(struct bfa_fcs_lport_s *port,
300
301
struct bfa_lport_info_s *port_info);
301
302
void bfa_fcs_lport_get_attr(struct bfa_fcs_lport_s *port,
+11
-3
drivers/scsi/bfa/bfa_fcs_lport.c
+11
-3
drivers/scsi/bfa/bfa_fcs_lport.c
···
1097
1097
bfa_sm_send_event(lport, BFA_FCS_PORT_SM_CREATE);
1098
1098
}
1099
1099
1100
+
void
1101
+
bfa_fcs_lport_set_symname(struct bfa_fcs_lport_s *port,
1102
+
char *symname)
1103
+
{
1104
+
strcpy(port->port_cfg.sym_name.symname, symname);
1105
+
1106
+
if (bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online))
1107
+
bfa_fcs_lport_ns_util_send_rspn_id(
1108
+
BFA_FCS_GET_NS_FROM_PORT(port), NULL);
1109
+
}
1110
+
1100
1111
/*
1101
1112
* fcs_lport_api
1102
1113
*/
···
5150
5139
u8 symbl[256];
5151
5140
u8 *psymbl = &symbl[0];
5152
5141
int len;
5153
-
5154
-
if (!bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online))
5155
-
return;
5156
5142
5157
5143
/* Avoid sending RSPN in the following states. */
5158
5144
if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_offline) ||
+2
-5
drivers/scsi/bfa/bfad_attr.c
+2
-5
drivers/scsi/bfa/bfad_attr.c
···
593
593
return;
594
594
595
595
spin_lock_irqsave(&bfad->bfad_lock, flags);
596
-
if (strlen(sym_name) > 0) {
597
-
strcpy(fcs_vport->lport.port_cfg.sym_name.symname, sym_name);
598
-
bfa_fcs_lport_ns_util_send_rspn_id(
599
-
BFA_FCS_GET_NS_FROM_PORT((&fcs_vport->lport)), NULL);
600
-
}
596
+
if (strlen(sym_name) > 0)
597
+
bfa_fcs_lport_set_symname(&fcs_vport->lport, sym_name);
601
598
spin_unlock_irqrestore(&bfad->bfad_lock, flags);
602
599
}
603
600
+1
drivers/scsi/gdth.c
+1
drivers/scsi/gdth.c
+1
drivers/scsi/hosts.c
+1
drivers/scsi/hosts.c
···
395
395
shost->use_clustering = sht->use_clustering;
396
396
shost->ordered_tag = sht->ordered_tag;
397
397
shost->eh_deadline = shost_eh_deadline * HZ;
398
+
shost->no_write_same = sht->no_write_same;
398
399
399
400
if (sht->supported_mode == MODE_UNKNOWN)
400
401
/* means we didn't set it ... default to INITIATOR */
+3
-2
drivers/scsi/hpsa.c
+3
-2
drivers/scsi/hpsa.c
···
561
561
.sdev_attrs = hpsa_sdev_attrs,
562
562
.shost_attrs = hpsa_shost_attrs,
563
563
.max_sectors = 8192,
564
+
.no_write_same = 1,
564
565
};
565
566
566
567
···
1289
1288
"has check condition: aborted command: "
1290
1289
"ASC: 0x%x, ASCQ: 0x%x\n",
1291
1290
cp, asc, ascq);
1292
-
cmd->result = DID_SOFT_ERROR << 16;
1291
+
cmd->result |= DID_SOFT_ERROR << 16;
1293
1292
break;
1294
1293
}
1295
1294
/* Must be some other type of check condition */
···
4926
4925
hpsa_hba_inquiry(h);
4927
4926
hpsa_register_scsi(h); /* hook ourselves into SCSI subsystem */
4928
4927
start_controller_lockup_detector(h);
4929
-
return 1;
4928
+
return 0;
4930
4929
4931
4930
clean4:
4932
4931
hpsa_free_sg_chain_blocks(h);
+2
-1
drivers/scsi/ipr.c
+2
-1
drivers/scsi/ipr.c
+1
drivers/scsi/ips.c
+1
drivers/scsi/ips.c
+1
-1
drivers/scsi/libsas/sas_ata.c
+1
-1
drivers/scsi/libsas/sas_ata.c
···
211
211
qc->tf.nsect = 0;
212
212
}
213
213
214
-
ata_tf_to_fis(&qc->tf, 1, 0, (u8*)&task->ata_task.fis);
214
+
ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, (u8 *)&task->ata_task.fis);
215
215
task->uldd_task = qc;
216
216
if (ata_is_atapi(qc->tf.protocol)) {
217
217
memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len);
+1
drivers/scsi/megaraid.c
+1
drivers/scsi/megaraid.c
+1
drivers/scsi/megaraid/megaraid_mbox.c
+1
drivers/scsi/megaraid/megaraid_mbox.c
+1
drivers/scsi/megaraid/megaraid_sas_base.c
+1
drivers/scsi/megaraid/megaraid_sas_base.c
+2
drivers/scsi/pm8001/pm8001_hwi.c
+2
drivers/scsi/pm8001/pm8001_hwi.c
···
3403
3403
unsigned long flags;
3404
3404
u8 deviceType = pPayload->sas_identify.dev_type;
3405
3405
port->port_state = portstate;
3406
+
phy->phy_state = PHY_STATE_LINK_UP_SPC;
3406
3407
PM8001_MSG_DBG(pm8001_ha,
3407
3408
pm8001_printk("HW_EVENT_SAS_PHY_UP port id = %d, phy id = %d\n",
3408
3409
port_id, phy_id));
···
3484
3483
pm8001_printk("HW_EVENT_SATA_PHY_UP port id = %d,"
3485
3484
" phy id = %d\n", port_id, phy_id));
3486
3485
port->port_state = portstate;
3486
+
phy->phy_state = PHY_STATE_LINK_UP_SPC;
3487
3487
port->port_attached = 1;
3488
3488
pm8001_get_lrate_mode(phy, link_rate);
3489
3489
phy->phy_type |= PORT_TYPE_SATA;
+4
drivers/scsi/pm8001/pm8001_hwi.h
+4
drivers/scsi/pm8001/pm8001_hwi.h
···
131
131
#define LINKRATE_30 (0x02 << 8)
132
132
#define LINKRATE_60 (0x04 << 8)
133
133
134
+
/* for phy state */
135
+
136
+
#define PHY_STATE_LINK_UP_SPC 0x1
137
+
134
138
/* for new SPC controllers MEMBASE III is shared between BIOS and DATA */
135
139
#define GSM_SM_BASE 0x4F0000
136
140
struct mpi_msg_hdr{
+53
-38
drivers/scsi/pm8001/pm8001_init.c
+53
-38
drivers/scsi/pm8001/pm8001_init.c
···
175
175
static void pm8001_tasklet(unsigned long opaque)
176
176
{
177
177
struct pm8001_hba_info *pm8001_ha;
178
-
u32 vec;
179
-
pm8001_ha = (struct pm8001_hba_info *)opaque;
178
+
struct isr_param *irq_vector;
179
+
180
+
irq_vector = (struct isr_param *)opaque;
181
+
pm8001_ha = irq_vector->drv_inst;
180
182
if (unlikely(!pm8001_ha))
181
183
BUG_ON(1);
182
-
vec = pm8001_ha->int_vector;
183
-
PM8001_CHIP_DISP->isr(pm8001_ha, vec);
184
+
PM8001_CHIP_DISP->isr(pm8001_ha, irq_vector->irq_id);
184
185
}
185
186
#endif
186
-
187
-
static struct pm8001_hba_info *outq_to_hba(u8 *outq)
188
-
{
189
-
return container_of((outq - *outq), struct pm8001_hba_info, outq[0]);
190
-
}
191
187
192
188
/**
193
189
* pm8001_interrupt_handler_msix - main MSIX interrupt handler.
···
194
198
*/
195
199
static irqreturn_t pm8001_interrupt_handler_msix(int irq, void *opaque)
196
200
{
197
-
struct pm8001_hba_info *pm8001_ha = outq_to_hba(opaque);
198
-
u8 outq = *(u8 *)opaque;
201
+
struct isr_param *irq_vector;
202
+
struct pm8001_hba_info *pm8001_ha;
199
203
irqreturn_t ret = IRQ_HANDLED;
204
+
irq_vector = (struct isr_param *)opaque;
205
+
pm8001_ha = irq_vector->drv_inst;
206
+
200
207
if (unlikely(!pm8001_ha))
201
208
return IRQ_NONE;
202
209
if (!PM8001_CHIP_DISP->is_our_interupt(pm8001_ha))
203
210
return IRQ_NONE;
204
-
pm8001_ha->int_vector = outq;
205
211
#ifdef PM8001_USE_TASKLET
206
-
tasklet_schedule(&pm8001_ha->tasklet);
212
+
tasklet_schedule(&pm8001_ha->tasklet[irq_vector->irq_id]);
207
213
#else
208
-
ret = PM8001_CHIP_DISP->isr(pm8001_ha, outq);
214
+
ret = PM8001_CHIP_DISP->isr(pm8001_ha, irq_vector->irq_id);
209
215
#endif
210
216
return ret;
211
217
}
···
228
230
if (!PM8001_CHIP_DISP->is_our_interupt(pm8001_ha))
229
231
return IRQ_NONE;
230
232
231
-
pm8001_ha->int_vector = 0;
232
233
#ifdef PM8001_USE_TASKLET
233
-
tasklet_schedule(&pm8001_ha->tasklet);
234
+
tasklet_schedule(&pm8001_ha->tasklet[0]);
234
235
#else
235
236
ret = PM8001_CHIP_DISP->isr(pm8001_ha, 0);
236
237
#endif
···
454
457
{
455
458
struct pm8001_hba_info *pm8001_ha;
456
459
struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
457
-
460
+
int j;
458
461
459
462
pm8001_ha = sha->lldd_ha;
460
463
if (!pm8001_ha)
···
477
480
pm8001_ha->iomb_size = IOMB_SIZE_SPC;
478
481
479
482
#ifdef PM8001_USE_TASKLET
480
-
/**
481
-
* default tasklet for non msi-x interrupt handler/first msi-x
482
-
* interrupt handler
483
-
**/
484
-
tasklet_init(&pm8001_ha->tasklet, pm8001_tasklet,
485
-
(unsigned long)pm8001_ha);
483
+
/* Tasklet for non msi-x interrupt handler */
484
+
if ((!pdev->msix_cap) || (pm8001_ha->chip_id == chip_8001))
485
+
tasklet_init(&pm8001_ha->tasklet[0], pm8001_tasklet,
486
+
(unsigned long)&(pm8001_ha->irq_vector[0]));
487
+
else
488
+
for (j = 0; j < PM8001_MAX_MSIX_VEC; j++)
489
+
tasklet_init(&pm8001_ha->tasklet[j], pm8001_tasklet,
490
+
(unsigned long)&(pm8001_ha->irq_vector[j]));
486
491
#endif
487
492
pm8001_ioremap(pm8001_ha);
488
493
if (!pm8001_alloc(pm8001_ha, ent))
···
732
733
"pci_enable_msix request ret:%d no of intr %d\n",
733
734
rc, pm8001_ha->number_of_intr));
734
735
735
-
for (i = 0; i < number_of_intr; i++)
736
-
pm8001_ha->outq[i] = i;
737
736
738
737
for (i = 0; i < number_of_intr; i++) {
739
738
snprintf(intr_drvname[i], sizeof(intr_drvname[0]),
740
739
DRV_NAME"%d", i);
740
+
pm8001_ha->irq_vector[i].irq_id = i;
741
+
pm8001_ha->irq_vector[i].drv_inst = pm8001_ha;
742
+
741
743
if (request_irq(pm8001_ha->msix_entries[i].vector,
742
744
pm8001_interrupt_handler_msix, flag,
743
-
intr_drvname[i], &pm8001_ha->outq[i])) {
745
+
intr_drvname[i], &(pm8001_ha->irq_vector[i]))) {
744
746
for (j = 0; j < i; j++)
745
747
free_irq(
746
748
pm8001_ha->msix_entries[j].vector,
747
-
&pm8001_ha->outq[j]);
749
+
&(pm8001_ha->irq_vector[i]));
748
750
pci_disable_msix(pm8001_ha->pdev);
749
751
break;
750
752
}
···
907
907
{
908
908
struct sas_ha_struct *sha = pci_get_drvdata(pdev);
909
909
struct pm8001_hba_info *pm8001_ha;
910
-
int i;
910
+
int i, j;
911
911
pm8001_ha = sha->lldd_ha;
912
912
sas_unregister_ha(sha);
913
913
sas_remove_host(pm8001_ha->shost);
···
921
921
synchronize_irq(pm8001_ha->msix_entries[i].vector);
922
922
for (i = 0; i < pm8001_ha->number_of_intr; i++)
923
923
free_irq(pm8001_ha->msix_entries[i].vector,
924
-
&pm8001_ha->outq[i]);
924
+
&(pm8001_ha->irq_vector[i]));
925
925
pci_disable_msix(pdev);
926
926
#else
927
927
free_irq(pm8001_ha->irq, sha);
928
928
#endif
929
929
#ifdef PM8001_USE_TASKLET
930
-
tasklet_kill(&pm8001_ha->tasklet);
930
+
/* For non-msix and msix interrupts */
931
+
if ((!pdev->msix_cap) || (pm8001_ha->chip_id == chip_8001))
932
+
tasklet_kill(&pm8001_ha->tasklet[0]);
933
+
else
934
+
for (j = 0; j < PM8001_MAX_MSIX_VEC; j++)
935
+
tasklet_kill(&pm8001_ha->tasklet[j]);
931
936
#endif
932
937
pm8001_free(pm8001_ha);
933
938
kfree(sha->sas_phy);
···
953
948
{
954
949
struct sas_ha_struct *sha = pci_get_drvdata(pdev);
955
950
struct pm8001_hba_info *pm8001_ha;
956
-
int i;
951
+
int i, j;
957
952
u32 device_state;
958
953
pm8001_ha = sha->lldd_ha;
959
954
flush_workqueue(pm8001_wq);
···
969
964
synchronize_irq(pm8001_ha->msix_entries[i].vector);
970
965
for (i = 0; i < pm8001_ha->number_of_intr; i++)
971
966
free_irq(pm8001_ha->msix_entries[i].vector,
972
-
&pm8001_ha->outq[i]);
967
+
&(pm8001_ha->irq_vector[i]));
973
968
pci_disable_msix(pdev);
974
969
#else
975
970
free_irq(pm8001_ha->irq, sha);
976
971
#endif
977
972
#ifdef PM8001_USE_TASKLET
978
-
tasklet_kill(&pm8001_ha->tasklet);
973
+
/* For non-msix and msix interrupts */
974
+
if ((!pdev->msix_cap) || (pm8001_ha->chip_id == chip_8001))
975
+
tasklet_kill(&pm8001_ha->tasklet[0]);
976
+
else
977
+
for (j = 0; j < PM8001_MAX_MSIX_VEC; j++)
978
+
tasklet_kill(&pm8001_ha->tasklet[j]);
979
979
#endif
980
980
device_state = pci_choose_state(pdev, state);
981
981
pm8001_printk("pdev=0x%p, slot=%s, entering "
···
1003
993
struct sas_ha_struct *sha = pci_get_drvdata(pdev);
1004
994
struct pm8001_hba_info *pm8001_ha;
1005
995
int rc;
1006
-
u8 i = 0;
996
+
u8 i = 0, j;
1007
997
u32 device_state;
1008
998
pm8001_ha = sha->lldd_ha;
1009
999
device_state = pdev->current_state;
···
1043
1033
if (rc)
1044
1034
goto err_out_disable;
1045
1035
#ifdef PM8001_USE_TASKLET
1046
-
/* default tasklet for non msi-x interrupt handler/first msi-x
1047
-
* interrupt handler */
1048
-
tasklet_init(&pm8001_ha->tasklet, pm8001_tasklet,
1049
-
(unsigned long)pm8001_ha);
1036
+
/* Tasklet for non msi-x interrupt handler */
1037
+
if ((!pdev->msix_cap) || (pm8001_ha->chip_id == chip_8001))
1038
+
tasklet_init(&pm8001_ha->tasklet[0], pm8001_tasklet,
1039
+
(unsigned long)&(pm8001_ha->irq_vector[0]));
1040
+
else
1041
+
for (j = 0; j < PM8001_MAX_MSIX_VEC; j++)
1042
+
tasklet_init(&pm8001_ha->tasklet[j], pm8001_tasklet,
1043
+
(unsigned long)&(pm8001_ha->irq_vector[j]));
1050
1044
#endif
1051
1045
PM8001_CHIP_DISP->interrupt_enable(pm8001_ha, 0);
1052
1046
if (pm8001_ha->chip_id != chip_8001) {
···
1183
1169
MODULE_AUTHOR("Jack Wang <jack_wang@usish.com>");
1184
1170
MODULE_AUTHOR("Anand Kumar Santhanam <AnandKumar.Santhanam@pmcs.com>");
1185
1171
MODULE_AUTHOR("Sangeetha Gnanasekaran <Sangeetha.Gnanasekaran@pmcs.com>");
1172
+
MODULE_AUTHOR("Nikith Ganigarakoppal <Nikith.Ganigarakoppal@pmcs.com>");
1186
1173
MODULE_DESCRIPTION(
1187
1174
"PMC-Sierra PM8001/8081/8088/8089/8074/8076/8077 "
1188
1175
"SAS/SATA controller driver");
+3
-1
drivers/scsi/pm8001/pm8001_sas.c
+3
-1
drivers/scsi/pm8001/pm8001_sas.c
···
1098
1098
struct pm8001_tmf_task tmf_task;
1099
1099
struct pm8001_device *pm8001_dev = dev->lldd_dev;
1100
1100
struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
1101
+
DECLARE_COMPLETION_ONSTACK(completion_setstate);
1101
1102
if (dev_is_sata(dev)) {
1102
1103
struct sas_phy *phy = sas_get_local_phy(dev);
1103
1104
rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
1104
1105
dev, 1, 0);
1105
1106
rc = sas_phy_reset(phy, 1);
1106
1107
sas_put_local_phy(phy);
1108
+
pm8001_dev->setds_completion = &completion_setstate;
1107
1109
rc = PM8001_CHIP_DISP->set_dev_state_req(pm8001_ha,
1108
1110
pm8001_dev, 0x01);
1109
-
msleep(2000);
1111
+
wait_for_completion(&completion_setstate);
1110
1112
} else {
1111
1113
tmf_task.tmf = TMF_LU_RESET;
1112
1114
rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+6
-3
drivers/scsi/pm8001/pm8001_sas.h
+6
-3
drivers/scsi/pm8001/pm8001_sas.h
···
466
466
u64 membase;
467
467
u32 memsize;
468
468
};
469
+
struct isr_param {
470
+
struct pm8001_hba_info *drv_inst;
471
+
u32 irq_id;
472
+
};
469
473
struct pm8001_hba_info {
470
474
char name[PM8001_NAME_LENGTH];
471
475
struct list_head list;
···
523
519
int number_of_intr;/*will be used in remove()*/
524
520
#endif
525
521
#ifdef PM8001_USE_TASKLET
526
-
struct tasklet_struct tasklet;
522
+
struct tasklet_struct tasklet[PM8001_MAX_MSIX_VEC];
527
523
#endif
528
524
u32 logging_level;
529
525
u32 fw_status;
530
526
u32 smp_exp_mode;
531
-
u32 int_vector;
532
527
const struct firmware *fw_image;
533
-
u8 outq[PM8001_MAX_MSIX_VEC];
528
+
struct isr_param irq_vector[PM8001_MAX_MSIX_VEC];
534
529
};
535
530
536
531
struct pm8001_work {
+2
drivers/scsi/pm8001/pm80xx_hwi.c
+2
drivers/scsi/pm8001/pm80xx_hwi.c
···
2894
2894
unsigned long flags;
2895
2895
u8 deviceType = pPayload->sas_identify.dev_type;
2896
2896
port->port_state = portstate;
2897
+
phy->phy_state = PHY_STATE_LINK_UP_SPCV;
2897
2898
PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
2898
2899
"portid:%d; phyid:%d; linkrate:%d; "
2899
2900
"portstate:%x; devicetype:%x\n",
···
2979
2978
port_id, phy_id, link_rate, portstate));
2980
2979
2981
2980
port->port_state = portstate;
2981
+
phy->phy_state = PHY_STATE_LINK_UP_SPCV;
2982
2982
port->port_attached = 1;
2983
2983
pm8001_get_lrate_mode(phy, link_rate);
2984
2984
phy->phy_type |= PORT_TYPE_SATA;
+2
drivers/scsi/pm8001/pm80xx_hwi.h
+2
drivers/scsi/pm8001/pm80xx_hwi.h
···
215
215
#define SAS_DOPNRJT_RTRY_TMO 128
216
216
#define SAS_COPNRJT_RTRY_TMO 128
217
217
218
+
/* for phy state */
219
+
#define PHY_STATE_LINK_UP_SPCV 0x2
218
220
/*
219
221
Making ORR bigger than IT NEXUS LOSS which is 2000000us = 2 second.
220
222
Assuming a bigger value 3 second, 3000000/128 = 23437.5 where 128
+1
drivers/scsi/pmcraid.c
+1
drivers/scsi/pmcraid.c
+6
drivers/scsi/sd.c
+6
drivers/scsi/sd.c
···
2659
2659
{
2660
2660
struct scsi_device *sdev = sdkp->device;
2661
2661
2662
+
if (sdev->host->no_write_same) {
2663
+
sdev->no_write_same = 1;
2664
+
2665
+
return;
2666
+
}
2667
+
2662
2668
if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, INQUIRY) < 0) {
2663
2669
/* too large values might cause issues with arcmsr */
2664
2670
int vpd_buf_len = 64;
+1
drivers/scsi/storvsc_drv.c
+1
drivers/scsi/storvsc_drv.c
+6
include/scsi/scsi_host.h
+6
include/scsi/scsi_host.h
···
475
475
*/
476
476
unsigned ordered_tag:1;
477
477
478
+
/* True if the controller does not support WRITE SAME */
479
+
unsigned no_write_same:1;
480
+
478
481
/*
479
482
* Countdown for host blocking with no commands outstanding.
480
483
*/
···
679
676
680
677
/* Don't resume host in EH */
681
678
unsigned eh_noresume:1;
679
+
680
+
/* The controller does not support WRITE SAME */
681
+
unsigned no_write_same:1;
682
682
683
683
/*
684
684
* Optional work queue to be utilized by the transport