Mercurial > illumos > illumos-gate
annotate usr/src/uts/common/io/sata/impl/sata.c @ 4837:fe2f53c9eb50
6556577 Need to support Advanced Acoustic Management Feature (AAM (fix lint)
| author | ls24207 |
|---|---|
| date | Thu, 09 Aug 2007 09:49:50 -0700 |
| parents | 7e0fe47fd304 |
| children | 35f6b7bbbbff |
| rev | line source |
|---|---|
| 1258 | 1 /* |
| 2 * CDDL HEADER START | |
| 3 * | |
| 4 * The contents of this file are subject to the terms of the | |
| 5 * Common Development and Distribution License (the "License"). | |
| 6 * You may not use this file except in compliance with the License. | |
| 7 * | |
| 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE | |
| 9 * or http://www.opensolaris.org/os/licensing. | |
| 10 * See the License for the specific language governing permissions | |
| 11 * and limitations under the License. | |
| 12 * | |
| 13 * When distributing Covered Code, include this CDDL HEADER in each | |
| 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
| 15 * If applicable, add the following below this CDDL HEADER, with the | |
| 16 * fields enclosed by brackets "[]" replaced with your own identifying | |
| 17 * information: Portions Copyright [yyyy] [name of copyright owner] | |
| 18 * | |
| 19 * CDDL HEADER END | |
| 20 */ | |
| 21 | |
| 22 /* | |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. |
| 1258 | 24 * Use is subject to license terms. |
| 25 */ | |
| 26 | |
| 27 #pragma ident "%Z%%M% %I% %E% SMI" | |
| 28 | |
| 29 /* | |
| 30 * SATA Framework | |
| 31 * Generic SATA Host Adapter Implementation | |
| 32 * | |
| 33 * NOTE: THIS VERSION DOES NOT SUPPORT ATAPI DEVICES, | |
| 34 * although there is some code related to these devices. | |
| 35 * | |
| 36 */ | |
| 37 #include <sys/conf.h> | |
| 38 #include <sys/file.h> | |
| 39 #include <sys/ddi.h> | |
| 40 #include <sys/sunddi.h> | |
| 41 #include <sys/modctl.h> | |
| 42 #include <sys/cmn_err.h> | |
| 43 #include <sys/errno.h> | |
| 44 #include <sys/thread.h> | |
| 45 #include <sys/kstat.h> | |
| 46 #include <sys/note.h> | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
47 #include <sys/sysevent.h> |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
48 #include <sys/sysevent/eventdefs.h> |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
49 #include <sys/sysevent/dr.h> |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
50 #include <sys/taskq.h> |
| 1258 | 51 |
| 52 #include <sys/sata/impl/sata.h> | |
| 53 #include <sys/sata/sata_hba.h> | |
| 54 #include <sys/sata/sata_defs.h> | |
| 55 #include <sys/sata/sata_cfgadm.h> | |
| 56 | |
| 57 | |
| 58 /* Debug flags - defined in sata.h */ | |
| 59 int sata_debug_flags = 0; | |
| 60 /* | |
| 61 * Flags enabling selected SATA HBA framework functionality | |
| 62 */ | |
| 63 #define SATA_ENABLE_QUEUING 1 | |
| 64 #define SATA_ENABLE_NCQ 2 | |
| 65 #define SATA_ENABLE_PROCESS_EVENTS 4 | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
66 int sata_func_enable = |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
67 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; |
| 1258 | 68 |
| 69 #ifdef SATA_DEBUG | |
| 70 #define SATA_LOG_D(args) sata_log args | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
71 uint64_t mbuf_count = 0; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
72 uint64_t mbuffail_count = 0; |
| 1258 | 73 #else |
| 74 #define SATA_LOG_D(arg) | |
| 75 #endif | |
| 76 | |
| 77 | |
| 78 /* | |
| 79 * SATA cb_ops functions | |
| 80 */ | |
| 81 static int sata_hba_open(dev_t *, int, int, cred_t *); | |
| 82 static int sata_hba_close(dev_t, int, int, cred_t *); | |
| 83 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); | |
| 84 | |
| 85 /* | |
| 86 * SCSA required entry points | |
| 87 */ | |
| 88 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, | |
| 89 scsi_hba_tran_t *, struct scsi_device *); | |
| 90 static int sata_scsi_tgt_probe(struct scsi_device *, | |
| 91 int (*callback)(void)); | |
| 92 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, | |
| 93 scsi_hba_tran_t *, struct scsi_device *); | |
| 94 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); | |
| 95 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); | |
| 96 static int sata_scsi_reset(struct scsi_address *, int); | |
| 97 static int sata_scsi_getcap(struct scsi_address *, char *, int); | |
| 98 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); | |
| 99 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, | |
| 100 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), | |
| 101 caddr_t); | |
| 102 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); | |
| 103 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); | |
| 104 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); | |
| 105 | |
| 106 | |
| 107 /* | |
| 108 * Local functions | |
| 109 */ | |
| 110 static void sata_remove_hba_instance(dev_info_t *); | |
| 111 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); | |
| 112 static void sata_probe_ports(sata_hba_inst_t *); | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
113 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
114 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, int cport, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
115 int pmport); |
| 1258 | 116 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, |
| 117 sata_address_t *); | |
| 118 static int sata_validate_scsi_address(sata_hba_inst_t *, | |
| 119 struct scsi_address *, sata_device_t *); | |
| 120 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); | |
| 121 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); | |
| 122 static void sata_pkt_free(sata_pkt_txlate_t *); | |
| 123 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), | |
| 124 caddr_t, ddi_dma_attr_t *); | |
| 125 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); | |
| 126 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, | |
| 127 sata_device_t *); | |
| 128 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); | |
| 129 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); | |
| 130 static void sata_free_local_buffer(sata_pkt_txlate_t *); | |
| 131 static uint64_t sata_check_capacity(sata_drive_info_t *); | |
| 132 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, | |
| 133 ddi_dma_attr_t *); | |
| 134 static int sata_fetch_device_identify_data(sata_hba_inst_t *, | |
| 135 sata_drive_info_t *); | |
| 136 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); | |
| 137 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); | |
| 138 static int sata_set_udma_mode(sata_hba_inst_t *, sata_drive_info_t *); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
139 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
140 static int sata_set_drive_features(sata_hba_inst_t *, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
141 sata_drive_info_t *, int flag); |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
142 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
143 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); |
| 1258 | 144 |
| 145 /* Event processing functions */ | |
| 146 static void sata_event_daemon(void *); | |
| 147 static void sata_event_thread_control(int); | |
| 148 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); | |
| 149 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); | |
| 150 static void sata_process_port_failed_event(sata_hba_inst_t *, | |
| 151 sata_address_t *); | |
| 152 static void sata_process_port_link_events(sata_hba_inst_t *, | |
| 153 sata_address_t *); | |
| 154 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); | |
| 155 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); | |
| 156 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); | |
| 157 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
158 static void sata_process_target_node_cleanup(sata_hba_inst_t *, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
159 sata_address_t *); |
| 1258 | 160 |
| 161 /* Local functions for ioctl */ | |
| 162 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); | |
| 163 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, | |
| 164 devctl_ap_state_t *); | |
| 165 static dev_info_t *sata_get_target_dip(dev_info_t *, int32_t); | |
| 166 static dev_info_t *sata_devt_to_devinfo(dev_t); | |
| 167 | |
| 168 /* Local translation functions */ | |
| 169 static int sata_txlt_inquiry(sata_pkt_txlate_t *); | |
| 170 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); | |
| 171 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); | |
| 172 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); | |
| 173 static int sata_txlt_request_sense(sata_pkt_txlate_t *); | |
| 174 static int sata_txlt_read(sata_pkt_txlate_t *); | |
| 175 static int sata_txlt_write(sata_pkt_txlate_t *); | |
| 176 static int sata_txlt_atapi(sata_pkt_txlate_t *); | |
| 177 static int sata_txlt_log_sense(sata_pkt_txlate_t *); | |
| 178 static int sata_txlt_log_select(sata_pkt_txlate_t *); | |
| 179 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); | |
| 180 static int sata_txlt_mode_select(sata_pkt_txlate_t *); | |
| 181 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
182 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); |
| 1258 | 183 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); |
| 184 | |
| 185 static int sata_hba_start(sata_pkt_txlate_t *, int *); | |
| 186 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); | |
| 187 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); | |
| 188 static void sata_txlt_rw_completion(sata_pkt_t *); | |
| 189 static void sata_txlt_atapi_completion(sata_pkt_t *); | |
| 190 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
191 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
192 static int sata_emul_rw_completion(sata_pkt_txlate_t *); |
| 1258 | 193 |
| 194 static struct scsi_extended_sense *sata_immediate_error_response( | |
| 195 sata_pkt_txlate_t *, int); | |
| 196 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); | |
| 197 | |
| 198 /* Local functions */ | |
| 199 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, | |
| 200 uint8_t *); | |
| 201 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); | |
| 202 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); | |
| 203 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); | |
| 204 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); | |
| 205 static int sata_mode_select_page_8(sata_pkt_txlate_t *, | |
| 206 struct mode_cache_scsi3 *, int, int *, int *, int *); | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
207 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
208 struct mode_info_excpt_page *, int, int *, int *, int *); |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
209 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
210 static int sata_mode_select_page_30(sata_pkt_txlate_t *, |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
211 struct mode_acoustic_management *, int, int *, int *, int *); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
212 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
213 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
214 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
215 sata_hba_inst_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
216 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
217 sata_hba_inst_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
218 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
219 sata_hba_inst_t *); |
| 1258 | 220 static void sata_save_drive_settings(sata_drive_info_t *); |
| 221 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); | |
| 222 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
223 static int sata_fetch_smart_return_status(sata_hba_inst_t *, |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
224 sata_drive_info_t *); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
225 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
226 struct smart_data *); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
227 static int sata_smart_selftest_log(sata_hba_inst_t *, |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
228 sata_drive_info_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
229 struct smart_selftest_log *); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
230 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
231 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
232 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
233 uint8_t *, uint8_t, uint8_t); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
234 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
235 struct read_log_ext_directory *); |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
236 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
237 static void sata_xlate_errors(sata_pkt_txlate_t *); |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
238 static void sata_decode_device_error(sata_pkt_txlate_t *, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
239 struct scsi_extended_sense *); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
240 static void sata_set_device_removed(dev_info_t *); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
241 static boolean_t sata_check_device_removed(dev_info_t *); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
242 static void sata_set_target_node_cleanup(sata_hba_inst_t *, int cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
243 |
| 1258 | 244 |
| 245 /* | |
| 246 * SATA Framework will ignore SATA HBA driver cb_ops structure and | |
| 247 * register following one with SCSA framework. | |
| 248 * Open & close are provided, so scsi framework will not use its own | |
| 249 */ | |
| 250 static struct cb_ops sata_cb_ops = { | |
| 251 sata_hba_open, /* open */ | |
| 252 sata_hba_close, /* close */ | |
| 253 nodev, /* strategy */ | |
| 254 nodev, /* print */ | |
| 255 nodev, /* dump */ | |
| 256 nodev, /* read */ | |
| 257 nodev, /* write */ | |
| 258 sata_hba_ioctl, /* ioctl */ | |
| 259 nodev, /* devmap */ | |
| 260 nodev, /* mmap */ | |
| 261 nodev, /* segmap */ | |
| 262 nochpoll, /* chpoll */ | |
| 263 ddi_prop_op, /* cb_prop_op */ | |
| 264 0, /* streamtab */ | |
| 265 D_NEW | D_MP, /* cb_flag */ | |
| 266 CB_REV, /* rev */ | |
| 267 nodev, /* aread */ | |
| 268 nodev /* awrite */ | |
| 269 }; | |
| 270 | |
| 271 | |
| 272 extern struct mod_ops mod_miscops; | |
| 273 extern uchar_t scsi_cdb_size[]; | |
| 274 | |
| 275 static struct modlmisc modlmisc = { | |
| 276 &mod_miscops, /* Type of module */ | |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
277 "SATA Module v1.23" /* module name */ |
| 1258 | 278 }; |
| 279 | |
| 280 | |
| 281 static struct modlinkage modlinkage = { | |
| 282 MODREV_1, | |
| 283 (void *)&modlmisc, | |
| 284 NULL | |
| 285 }; | |
| 286 | |
| 287 /* | |
| 288 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, | |
| 289 * i.e. when scsi_pkt has not timeout specified. | |
| 290 */ | |
| 291 static int sata_default_pkt_time = 60; /* 60 seconds */ | |
| 292 | |
| 293 /* | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
294 * Intermediate buffer device access attributes - they are required, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
295 * but not necessarily used. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
296 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
297 static ddi_device_acc_attr_t sata_acc_attr = { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
298 DDI_DEVICE_ATTR_V0, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
299 DDI_STRUCTURE_LE_ACC, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
300 DDI_STRICTORDER_ACC |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
301 }; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
302 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
303 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
304 /* |
| 1258 | 305 * Mutexes protecting structures in multithreaded operations. |
| 306 * Because events are relatively rare, a single global mutex protecting | |
| 307 * data structures should be sufficient. To increase performance, add | |
| 308 * separate mutex per each sata port and use global mutex only to protect | |
| 309 * common data structures. | |
| 310 */ | |
| 311 static kmutex_t sata_mutex; /* protects sata_hba_list */ | |
| 312 static kmutex_t sata_log_mutex; /* protects log */ | |
| 313 | |
| 314 static char sata_log_buf[256]; | |
| 315 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
316 /* Default write cache setting */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
317 int sata_write_cache = 1; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
318 |
| 1258 | 319 /* |
| 320 * Linked list of HBA instances | |
| 321 */ | |
| 322 static sata_hba_inst_t *sata_hba_list = NULL; | |
| 323 static sata_hba_inst_t *sata_hba_list_tail = NULL; | |
| 324 /* | |
| 325 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran | |
| 326 * structure and in sata soft state. | |
| 327 */ | |
| 328 | |
| 329 /* | |
| 330 * Event daemon related variables | |
| 331 */ | |
| 332 static kmutex_t sata_event_mutex; | |
| 333 static kcondvar_t sata_event_cv; | |
| 334 static kthread_t *sata_event_thread = NULL; | |
| 335 static int sata_event_thread_terminate = 0; | |
| 336 static int sata_event_pending = 0; | |
| 337 static int sata_event_thread_active = 0; | |
| 338 extern pri_t minclsyspri; | |
| 339 | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
340 /* |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
341 * NCQ specific data |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
342 */ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
343 static const sata_cmd_t sata_rle_cmd = { |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
344 SATA_CMD_REV, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
345 NULL, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
346 { |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
347 SATA_DIR_READ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
348 }, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
349 ATA_ADDR_LBA48, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
350 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
351 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
352 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
353 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
354 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
355 1, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
356 READ_LOG_EXT_NCQ_ERROR_RECOVERY, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
357 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
358 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
359 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
360 SATAC_READ_LOG_EXT, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
361 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
362 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
363 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
364 }; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
365 |
| 1258 | 366 /* Warlock directives */ |
| 367 | |
| 368 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) | |
| 369 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) | |
| 370 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) | |
| 371 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) | |
| 372 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) | |
| 373 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) | |
| 374 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) | |
| 375 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) | |
| 376 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) | |
| 377 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) | |
| 378 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) | |
| 379 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) | |
| 380 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ | |
| 381 sata_hba_inst::satahba_scsi_tran)) | |
| 382 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) | |
| 383 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) | |
| 384 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) | |
| 385 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) | |
| 386 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, | |
| 387 sata_hba_inst::satahba_event_flags)) | |
| 388 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 389 sata_cport_info::cport_devp)) | |
| 390 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) | |
| 391 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) | |
| 392 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 393 sata_cport_info::cport_dev_type)) | |
| 394 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) | |
| 395 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 396 sata_cport_info::cport_state)) | |
| 397 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) | |
| 398 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) | |
| 399 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) | |
| 400 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) | |
| 401 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
402 #ifdef SATA_DEBUG |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
403 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
404 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
405 #endif |
| 1258 | 406 |
| 407 /* End of warlock directives */ | |
| 408 | |
| 409 /* ************** loadable module configuration functions ************** */ | |
| 410 | |
| 411 int | |
| 412 _init() | |
| 413 { | |
| 414 int rval; | |
| 415 | |
| 416 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 417 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 418 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 419 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); | |
| 420 if ((rval = mod_install(&modlinkage)) != 0) { | |
| 421 #ifdef SATA_DEBUG | |
| 422 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); | |
| 423 #endif | |
| 424 mutex_destroy(&sata_log_mutex); | |
| 425 cv_destroy(&sata_event_cv); | |
| 426 mutex_destroy(&sata_event_mutex); | |
| 427 mutex_destroy(&sata_mutex); | |
| 428 } | |
| 429 return (rval); | |
| 430 } | |
| 431 | |
| 432 int | |
| 433 _fini() | |
| 434 { | |
| 435 int rval; | |
| 436 | |
| 437 if ((rval = mod_remove(&modlinkage)) != 0) | |
| 438 return (rval); | |
| 439 | |
| 440 mutex_destroy(&sata_log_mutex); | |
| 441 cv_destroy(&sata_event_cv); | |
| 442 mutex_destroy(&sata_event_mutex); | |
| 443 mutex_destroy(&sata_mutex); | |
| 444 return (rval); | |
| 445 } | |
| 446 | |
| 447 int | |
| 448 _info(struct modinfo *modinfop) | |
| 449 { | |
| 450 return (mod_info(&modlinkage, modinfop)); | |
| 451 } | |
| 452 | |
| 453 | |
| 454 | |
| 455 /* ********************* SATA HBA entry points ********************* */ | |
| 456 | |
| 457 | |
| 458 /* | |
| 459 * Called by SATA HBA from _init(). | |
| 460 * Registers HBA driver instance/sata framework pair with scsi framework, by | |
| 461 * calling scsi_hba_init(). | |
| 462 * | |
| 463 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used | |
| 464 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver | |
| 465 * cb_ops pointer in SATA HBA driver dev_ops structure. | |
| 466 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. | |
| 467 * | |
| 468 * Return status of the scsi_hba_init() is returned to a calling SATA HBA | |
| 469 * driver. | |
| 470 */ | |
| 471 int | |
| 472 sata_hba_init(struct modlinkage *modlp) | |
| 473 { | |
| 474 int rval; | |
| 475 struct dev_ops *hba_ops; | |
| 476 | |
| 477 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 478 "sata_hba_init: name %s \n", | |
| 479 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); | |
| 480 /* | |
| 481 * Fill-up cb_ops and dev_ops when necessary | |
| 482 */ | |
| 483 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; | |
| 484 /* | |
| 485 * Provide pointer to SATA dev_ops | |
| 486 */ | |
| 487 hba_ops->devo_cb_ops = &sata_cb_ops; | |
| 488 | |
| 489 /* | |
| 490 * Register SATA HBA with SCSI framework | |
| 491 */ | |
| 492 if ((rval = scsi_hba_init(modlp)) != 0) { | |
| 493 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 494 "sata_hba_init: scsi hba init failed\n", NULL); | |
| 495 return (rval); | |
| 496 } | |
| 497 | |
| 498 return (0); | |
| 499 } | |
| 500 | |
| 501 | |
| 502 /* HBA attach stages */ | |
| 503 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 | |
| 504 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 | |
| 505 #define HBA_ATTACH_STAGE_SETUP 4 | |
| 506 #define HBA_ATTACH_STAGE_LINKED 8 | |
| 507 | |
| 508 | |
| 509 /* | |
| 510 * | |
| 511 * Called from SATA HBA driver's attach routine to attach an instance of | |
| 512 * the HBA. | |
| 513 * | |
| 514 * For DDI_ATTACH command: | |
| 515 * sata_hba_inst structure is allocated here and initialized with pointers to | |
| 516 * SATA framework implementation of required scsi tran functions. | |
| 517 * The scsi_tran's tran_hba_private field is used by SATA Framework to point | |
| 518 * to the soft structure (sata_hba_inst) allocated by SATA framework for | |
| 519 * SATA HBA instance related data. | |
| 520 * The scsi_tran's tran_hba_private field is used by SATA framework to | |
| 521 * store a pointer to per-HBA-instance of sata_hba_inst structure. | |
| 522 * The sata_hba_inst structure is cross-linked to scsi tran structure. | |
| 523 * Among other info, a pointer to sata_hba_tran structure is stored in | |
| 524 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are | |
| 525 * linked together into the list, pointed to by sata_hba_list. | |
| 526 * On the first HBA instance attach the sata event thread is initialized. | |
| 527 * Attachment points are created for all SATA ports of the HBA being attached. | |
| 528 * All HBA instance's SATA ports are probed and type of plugged devices is | |
| 529 * determined. For each device of a supported type, a target node is created. | |
| 530 * | |
| 531 * DDI_SUCCESS is returned when attachment process is successful, | |
| 532 * DDI_FAILURE is returned otherwise. | |
| 533 * | |
| 534 * For DDI_RESUME command: | |
| 535 * Not implemented at this time (postponed until phase 2 of the development). | |
| 536 */ | |
| 537 int | |
| 538 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, | |
| 539 ddi_attach_cmd_t cmd) | |
| 540 { | |
| 541 sata_hba_inst_t *sata_hba_inst; | |
| 542 scsi_hba_tran_t *scsi_tran = NULL; | |
| 543 int hba_attach_state = 0; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
544 char taskq_name[MAXPATHLEN]; |
| 1258 | 545 |
| 546 SATADBG3(SATA_DBG_HBA_IF, NULL, | |
| 547 "sata_hba_attach: node %s (%s%d)\n", | |
| 548 ddi_node_name(dip), ddi_driver_name(dip), | |
| 549 ddi_get_instance(dip)); | |
| 550 | |
| 551 if (cmd == DDI_RESUME) { | |
| 552 /* | |
| 553 * Postponed until phase 2 of the development | |
| 554 */ | |
| 555 return (DDI_FAILURE); | |
| 556 } | |
| 557 | |
| 558 if (cmd != DDI_ATTACH) { | |
| 559 return (DDI_FAILURE); | |
| 560 } | |
| 561 | |
| 562 /* cmd == DDI_ATTACH */ | |
| 563 | |
| 564 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { | |
| 565 SATA_LOG_D((NULL, CE_WARN, | |
| 566 "sata_hba_attach: invalid sata_hba_tran")); | |
| 567 return (DDI_FAILURE); | |
| 568 } | |
| 569 /* | |
| 570 * Allocate and initialize SCSI tran structure. | |
| 571 * SATA copy of tran_bus_config is provided to create port nodes. | |
| 572 */ | |
| 573 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); | |
| 574 if (scsi_tran == NULL) | |
| 575 return (DDI_FAILURE); | |
| 576 /* | |
| 577 * Allocate soft structure for SATA HBA instance. | |
| 578 * There is a separate softstate for each HBA instance. | |
| 579 */ | |
| 580 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); | |
| 581 ASSERT(sata_hba_inst != NULL); /* this should not fail */ | |
| 582 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 583 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; | |
| 584 | |
| 585 /* | |
| 586 * scsi_trans's tran_hba_private is used by SATA Framework to point to | |
| 587 * soft structure allocated by SATA framework for | |
| 588 * SATA HBA instance related data. | |
| 589 */ | |
| 590 scsi_tran->tran_hba_private = sata_hba_inst; | |
| 591 scsi_tran->tran_tgt_private = NULL; | |
| 592 | |
| 593 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; | |
| 594 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; | |
| 595 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; | |
| 596 | |
| 597 scsi_tran->tran_start = sata_scsi_start; | |
| 598 scsi_tran->tran_reset = sata_scsi_reset; | |
| 599 scsi_tran->tran_abort = sata_scsi_abort; | |
| 600 scsi_tran->tran_getcap = sata_scsi_getcap; | |
| 601 scsi_tran->tran_setcap = sata_scsi_setcap; | |
| 602 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; | |
| 603 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; | |
| 604 | |
| 605 scsi_tran->tran_dmafree = sata_scsi_dmafree; | |
| 606 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; | |
| 607 | |
| 608 scsi_tran->tran_reset_notify = NULL; | |
| 609 scsi_tran->tran_get_bus_addr = NULL; | |
| 610 scsi_tran->tran_quiesce = NULL; | |
| 611 scsi_tran->tran_unquiesce = NULL; | |
| 612 scsi_tran->tran_bus_reset = NULL; | |
| 613 | |
| 614 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, | |
| 615 scsi_tran, 0) != DDI_SUCCESS) { | |
| 616 #ifdef SATA_DEBUG | |
| 617 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", | |
| 618 ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 619 #endif | |
| 620 goto fail; | |
| 621 } | |
| 622 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; | |
| 623 | |
| 624 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { | |
| 625 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, | |
| 626 "sata", 1) != DDI_PROP_SUCCESS) { | |
| 627 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " | |
| 628 "failed to create hba sata prop")); | |
| 629 goto fail; | |
| 630 } | |
| 631 } | |
| 632 | |
| 633 /* | |
| 634 * Save pointers in hba instance soft state. | |
| 635 */ | |
| 636 sata_hba_inst->satahba_scsi_tran = scsi_tran; | |
| 637 sata_hba_inst->satahba_tran = sata_tran; | |
| 638 sata_hba_inst->satahba_dip = dip; | |
| 639 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
640 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
641 * Create a task queue to handle emulated commands completion |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
642 * Use node name, dash, instance number as the queue name. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
643 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
644 taskq_name[0] = '\0'; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
645 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
646 sizeof (taskq_name)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
647 (void) snprintf(taskq_name + strlen(taskq_name), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
648 sizeof (taskq_name) - strlen(taskq_name), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
649 "-%d", DEVI(dip)->devi_instance); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
650 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
651 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
652 TASKQ_DYNAMIC); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
653 |
| 1258 | 654 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; |
| 655 | |
| 656 /* | |
| 657 * Create events thread if not created yet. | |
| 658 */ | |
| 659 sata_event_thread_control(1); | |
| 660 | |
| 661 /* | |
| 662 * Link this hba instance into the list. | |
| 663 */ | |
| 664 mutex_enter(&sata_mutex); | |
| 665 | |
| 666 | |
| 667 sata_hba_inst->satahba_next = NULL; | |
| 668 sata_hba_inst->satahba_prev = sata_hba_list_tail; | |
| 669 if (sata_hba_list == NULL) { | |
| 670 sata_hba_list = sata_hba_inst; | |
| 671 } | |
| 672 if (sata_hba_list_tail != NULL) { | |
| 673 sata_hba_list_tail->satahba_next = sata_hba_inst; | |
| 674 } | |
| 675 sata_hba_list_tail = sata_hba_inst; | |
| 676 mutex_exit(&sata_mutex); | |
| 677 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; | |
| 678 | |
| 679 /* | |
| 680 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl | |
| 681 * SATA HBA driver should not use its own open/close entry points. | |
| 682 * | |
| 683 * Make sure that instance number doesn't overflow | |
| 684 * when forming minor numbers. | |
| 685 */ | |
| 686 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); | |
| 687 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, | |
| 688 INST2DEVCTL(ddi_get_instance(dip)), | |
| 689 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { | |
| 690 #ifdef SATA_DEBUG | |
| 691 cmn_err(CE_WARN, "sata_hba_attach: " | |
| 692 "cannot create devctl minor node"); | |
| 693 #endif | |
| 694 goto fail; | |
| 695 } | |
| 696 | |
| 697 | |
| 698 /* | |
| 699 * Set-up kstats here, if necessary. | |
| 700 * (postponed until phase 2 of the development). | |
| 701 */ | |
| 702 | |
| 703 | |
| 704 /* | |
| 705 * Probe controller ports. This operation will describe a current | |
| 706 * controller/port/multipliers/device configuration and will create | |
| 707 * attachment points. | |
| 708 * We may end-up with just a controller with no devices attached. | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
709 * For the ports with a supported device attached, device target nodes |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
710 * are created and devices are initialized. |
| 1258 | 711 */ |
| 712 sata_probe_ports(sata_hba_inst); | |
| 713 | |
| 714 sata_hba_inst->satahba_attached = 1; | |
| 715 return (DDI_SUCCESS); | |
| 716 | |
| 717 fail: | |
| 718 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { | |
| 719 (void) sata_remove_hba_instance(dip); | |
| 720 if (sata_hba_list == NULL) | |
| 721 sata_event_thread_control(0); | |
| 722 } | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
723 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
724 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { |
| 1258 | 725 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
726 taskq_destroy(sata_hba_inst->satahba_taskq); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
727 } |
| 1258 | 728 |
| 729 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) | |
| 730 (void) scsi_hba_detach(dip); | |
| 731 | |
| 732 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { | |
| 733 mutex_destroy(&sata_hba_inst->satahba_mutex); | |
| 734 kmem_free((void *)sata_hba_inst, | |
| 735 sizeof (struct sata_hba_inst)); | |
| 736 scsi_hba_tran_free(scsi_tran); | |
| 737 } | |
| 738 | |
| 739 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", | |
| 740 ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 741 | |
| 742 return (DDI_FAILURE); | |
| 743 } | |
| 744 | |
| 745 | |
| 746 /* | |
| 747 * Called by SATA HBA from to detach an instance of the driver. | |
| 748 * | |
| 749 * For DDI_DETACH command: | |
| 750 * Free local structures allocated for SATA HBA instance during | |
| 751 * sata_hba_attach processing. | |
| 752 * | |
| 753 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. | |
| 754 * | |
| 755 * For DDI_SUSPEND command: | |
| 756 * Not implemented at this time (postponed until phase 2 of the development) | |
| 757 * Returnd DDI_SUCCESS. | |
| 758 * | |
| 759 * When the last HBA instance is detached, the event daemon is terminated. | |
| 760 * | |
| 761 * NOTE: cport support only, no port multiplier support. | |
| 762 */ | |
| 763 int | |
| 764 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) | |
| 765 { | |
| 766 dev_info_t *tdip; | |
| 767 sata_hba_inst_t *sata_hba_inst; | |
| 768 scsi_hba_tran_t *scsi_hba_tran; | |
| 769 sata_cport_info_t *cportinfo; | |
| 770 sata_drive_info_t *sdinfo; | |
| 771 int ncport; | |
| 772 | |
| 773 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", | |
| 774 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 775 | |
| 776 switch (cmd) { | |
| 777 case DDI_DETACH: | |
| 778 | |
| 779 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 780 return (DDI_FAILURE); | |
| 781 | |
| 782 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 783 if (sata_hba_inst == NULL) | |
| 784 return (DDI_FAILURE); | |
| 785 | |
| 786 if (scsi_hba_detach(dip) == DDI_FAILURE) { | |
| 787 sata_hba_inst->satahba_attached = 1; | |
| 788 return (DDI_FAILURE); | |
| 789 } | |
| 790 | |
| 791 /* | |
| 792 * Free all target nodes - at this point | |
| 793 * devices should be at least offlined | |
| 794 * otherwise scsi_hba_detach() should not be called. | |
| 795 */ | |
| 796 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 797 ncport++) { | |
| 798 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 799 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 800 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 801 if (sdinfo != NULL) { | |
| 802 tdip = sata_get_target_dip(dip, | |
| 803 ncport); | |
| 804 if (tdip != NULL) { | |
| 805 if (ndi_devi_offline(tdip, | |
| 806 NDI_DEVI_REMOVE) != | |
| 807 NDI_SUCCESS) { | |
| 808 SATA_LOG_D(( | |
| 809 sata_hba_inst, | |
| 810 CE_WARN, | |
| 811 "sata_hba_detach: " | |
| 812 "Target node not " | |
| 813 "removed !")); | |
| 814 return (DDI_FAILURE); | |
| 815 } | |
| 816 } | |
| 817 } | |
| 818 } | |
| 819 } | |
| 820 /* | |
| 821 * Disable sata event daemon processing for this HBA | |
| 822 */ | |
| 823 sata_hba_inst->satahba_attached = 0; | |
| 824 | |
| 825 /* | |
| 826 * Remove event daemon thread, if it is last HBA instance. | |
| 827 */ | |
| 828 | |
| 829 mutex_enter(&sata_mutex); | |
| 830 if (sata_hba_list->satahba_next == NULL) { | |
| 831 mutex_exit(&sata_mutex); | |
| 832 sata_event_thread_control(0); | |
| 833 mutex_enter(&sata_mutex); | |
| 834 } | |
| 835 mutex_exit(&sata_mutex); | |
| 836 | |
| 837 /* Remove this HBA instance from the HBA list */ | |
| 838 sata_remove_hba_instance(dip); | |
| 839 | |
| 840 /* | |
| 841 * At this point there should be no target nodes attached. | |
| 842 * Detach and destroy device and port info structures. | |
| 843 */ | |
| 844 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 845 ncport++) { | |
| 846 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 847 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 848 sdinfo = | |
| 849 cportinfo->cport_devp.cport_sata_drive; | |
| 850 if (sdinfo != NULL) { | |
| 851 /* Release device structure */ | |
| 852 kmem_free(sdinfo, | |
| 853 sizeof (sata_drive_info_t)); | |
| 854 } | |
| 855 /* Release cport info */ | |
| 856 mutex_destroy(&cportinfo->cport_mutex); | |
| 857 kmem_free(cportinfo, | |
| 858 sizeof (sata_cport_info_t)); | |
| 859 } | |
| 860 } | |
| 861 | |
| 862 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); | |
| 863 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
864 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
865 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
866 taskq_destroy(sata_hba_inst->satahba_taskq); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
867 |
| 1258 | 868 mutex_destroy(&sata_hba_inst->satahba_mutex); |
| 869 kmem_free((void *)sata_hba_inst, | |
| 870 sizeof (struct sata_hba_inst)); | |
| 871 | |
| 872 return (DDI_SUCCESS); | |
| 873 | |
| 874 case DDI_SUSPEND: | |
| 875 /* | |
| 876 * Postponed until phase 2 | |
| 877 */ | |
| 878 return (DDI_FAILURE); | |
| 879 | |
| 880 default: | |
| 881 return (DDI_FAILURE); | |
| 882 } | |
| 883 } | |
| 884 | |
| 885 | |
| 886 /* | |
| 887 * Called by an HBA drive from _fini() routine. | |
| 888 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. | |
| 889 */ | |
| 890 void | |
| 891 sata_hba_fini(struct modlinkage *modlp) | |
| 892 { | |
| 893 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 894 "sata_hba_fini: name %s\n", | |
| 895 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); | |
| 896 | |
| 897 scsi_hba_fini(modlp); | |
| 898 } | |
| 899 | |
| 900 | |
| 901 /* | |
| 902 * Default open and close routine for sata_hba framework. | |
| 903 * | |
| 904 */ | |
| 905 /* | |
| 906 * Open devctl node. | |
| 907 * | |
| 908 * Returns: | |
| 909 * 0 if node was open successfully, error code otherwise. | |
| 910 * | |
| 911 * | |
| 912 */ | |
| 913 | |
| 914 static int | |
| 915 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) | |
| 916 { | |
| 917 #ifndef __lock_lint | |
| 918 _NOTE(ARGUNUSED(credp)) | |
| 919 #endif | |
| 920 int rv = 0; | |
| 921 dev_info_t *dip; | |
| 922 scsi_hba_tran_t *scsi_hba_tran; | |
| 923 sata_hba_inst_t *sata_hba_inst; | |
| 924 | |
| 925 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); | |
| 926 | |
| 927 if (otyp != OTYP_CHR) | |
| 928 return (EINVAL); | |
| 929 | |
| 930 dip = sata_devt_to_devinfo(*devp); | |
| 931 if (dip == NULL) | |
| 932 return (ENXIO); | |
| 933 | |
| 934 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 935 return (ENXIO); | |
| 936 | |
| 937 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 938 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) | |
| 939 return (ENXIO); | |
| 940 | |
| 941 mutex_enter(&sata_mutex); | |
| 942 if (flags & FEXCL) { | |
| 943 if (sata_hba_inst->satahba_open_flag != 0) { | |
| 944 rv = EBUSY; | |
| 945 } else { | |
| 946 sata_hba_inst->satahba_open_flag = | |
| 947 SATA_DEVCTL_EXOPENED; | |
| 948 } | |
| 949 } else { | |
| 950 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { | |
| 951 rv = EBUSY; | |
| 952 } else { | |
| 953 sata_hba_inst->satahba_open_flag = | |
| 954 SATA_DEVCTL_SOPENED; | |
| 955 } | |
| 956 } | |
| 957 mutex_exit(&sata_mutex); | |
| 958 | |
| 959 return (rv); | |
| 960 } | |
| 961 | |
| 962 | |
| 963 /* | |
| 964 * Close devctl node. | |
| 965 * Returns: | |
| 966 * 0 if node was closed successfully, error code otherwise. | |
| 967 * | |
| 968 */ | |
| 969 | |
| 970 static int | |
| 971 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) | |
| 972 { | |
| 973 #ifndef __lock_lint | |
| 974 _NOTE(ARGUNUSED(credp)) | |
| 975 _NOTE(ARGUNUSED(flag)) | |
| 976 #endif | |
| 977 dev_info_t *dip; | |
| 978 scsi_hba_tran_t *scsi_hba_tran; | |
| 979 sata_hba_inst_t *sata_hba_inst; | |
| 980 | |
| 981 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); | |
| 982 | |
| 983 if (otyp != OTYP_CHR) | |
| 984 return (EINVAL); | |
| 985 | |
| 986 dip = sata_devt_to_devinfo(dev); | |
| 987 if (dip == NULL) | |
| 988 return (ENXIO); | |
| 989 | |
| 990 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 991 return (ENXIO); | |
| 992 | |
| 993 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 994 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) | |
| 995 return (ENXIO); | |
| 996 | |
| 997 mutex_enter(&sata_mutex); | |
| 998 sata_hba_inst->satahba_open_flag = 0; | |
| 999 mutex_exit(&sata_mutex); | |
| 1000 return (0); | |
| 1001 } | |
| 1002 | |
| 1003 | |
| 1004 | |
| 1005 /* | |
| 1006 * Standard IOCTL commands for SATA hotplugging. | |
| 1007 * Implemented DEVCTL_AP commands: | |
| 1008 * DEVCTL_AP_CONNECT | |
| 1009 * DEVCTL_AP_DISCONNECT | |
| 1010 * DEVCTL_AP_CONFIGURE | |
| 1011 * DEVCTL_UNCONFIGURE | |
| 1012 * DEVCTL_AP_CONTROL | |
| 1013 * | |
| 1014 * Commands passed to default ndi ioctl handler: | |
| 1015 * DEVCTL_DEVICE_GETSTATE | |
| 1016 * DEVCTL_DEVICE_ONLINE | |
| 1017 * DEVCTL_DEVICE_OFFLINE | |
| 1018 * DEVCTL_DEVICE_REMOVE | |
| 1019 * DEVCTL_DEVICE_INSERT | |
| 1020 * DEVCTL_BUS_GETSTATE | |
| 1021 * | |
| 1022 * All other cmds are passed to HBA if it provide ioctl handler, or failed | |
| 1023 * if not. | |
| 1024 * | |
| 1025 * Returns: | |
| 1026 * 0 if successful, | |
| 1027 * error code if operation failed. | |
| 1028 * | |
| 1029 * NOTE: Port Multiplier is not supported. | |
| 1030 * | |
| 1031 */ | |
| 1032 | |
| 1033 static int | |
| 1034 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, | |
| 1035 int *rvalp) | |
| 1036 { | |
| 1037 #ifndef __lock_lint | |
| 1038 _NOTE(ARGUNUSED(credp)) | |
| 1039 _NOTE(ARGUNUSED(rvalp)) | |
| 1040 #endif | |
| 1041 int rv = 0; | |
| 1042 int32_t comp_port = -1; | |
| 1043 dev_info_t *dip, *tdip; | |
| 1044 devctl_ap_state_t ap_state; | |
| 1045 struct devctl_iocdata *dcp = NULL; | |
| 1046 scsi_hba_tran_t *scsi_hba_tran; | |
| 1047 sata_hba_inst_t *sata_hba_inst; | |
| 1048 sata_device_t sata_device; | |
| 1049 sata_drive_info_t *sdinfo; | |
| 1050 sata_cport_info_t *cportinfo; | |
| 1051 int cport, pmport, qual; | |
| 1052 int rval = SATA_SUCCESS; | |
| 1053 | |
| 1054 dip = sata_devt_to_devinfo(dev); | |
| 1055 if (dip == NULL) | |
| 1056 return (ENXIO); | |
| 1057 | |
| 1058 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 1059 return (ENXIO); | |
| 1060 | |
| 1061 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 1062 if (sata_hba_inst == NULL) | |
| 1063 return (ENXIO); | |
| 1064 | |
| 1065 if (sata_hba_inst->satahba_tran == NULL) | |
| 1066 return (ENXIO); | |
| 1067 | |
| 1068 switch (cmd) { | |
| 1069 | |
| 1070 case DEVCTL_DEVICE_GETSTATE: | |
| 1071 case DEVCTL_DEVICE_ONLINE: | |
| 1072 case DEVCTL_DEVICE_OFFLINE: | |
| 1073 case DEVCTL_DEVICE_REMOVE: | |
| 1074 case DEVCTL_BUS_GETSTATE: | |
| 1075 /* | |
| 1076 * There may be more cases that we want to pass to default | |
| 1077 * handler rather then fail them. | |
| 1078 */ | |
| 1079 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); | |
| 1080 } | |
| 1081 | |
| 1082 /* read devctl ioctl data */ | |
| 1083 if (cmd != DEVCTL_AP_CONTROL) { | |
| 1084 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) | |
| 1085 return (EFAULT); | |
| 1086 | |
| 1087 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == | |
| 1088 -1) { | |
| 1089 if (dcp) | |
| 1090 ndi_dc_freehdl(dcp); | |
| 1091 return (EINVAL); | |
| 1092 } | |
| 1093 | |
| 1094 cport = SCSI_TO_SATA_CPORT(comp_port); | |
| 1095 pmport = SCSI_TO_SATA_PMPORT(comp_port); | |
| 1096 /* Only cport is considered now, i.e. SATA_ADDR_CPORT */ | |
| 1097 qual = SATA_ADDR_CPORT; | |
| 1098 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, | |
| 1099 qual) != 0) { | |
| 1100 ndi_dc_freehdl(dcp); | |
| 1101 return (EINVAL); | |
| 1102 } | |
| 1103 | |
| 1104 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 1105 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1106 cport_mutex); | |
| 1107 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { | |
| 1108 /* | |
| 1109 * Cannot process ioctl request now. Come back later. | |
| 1110 */ | |
| 1111 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1112 cport_mutex); | |
| 1113 ndi_dc_freehdl(dcp); | |
| 1114 return (EBUSY); | |
| 1115 } | |
| 1116 /* Block event processing for this port */ | |
| 1117 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; | |
| 1118 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1119 | |
| 1120 sata_device.satadev_addr.cport = cport; | |
| 1121 sata_device.satadev_addr.pmport = pmport; | |
| 1122 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1123 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 1124 } | |
| 1125 | |
| 1126 switch (cmd) { | |
| 1127 | |
| 1128 case DEVCTL_AP_DISCONNECT: | |
| 1129 /* | |
| 1130 * Normally, cfgadm sata plugin will try to offline | |
| 1131 * (unconfigure) device before this request. Nevertheless, | |
| 1132 * if a device is still configured, we need to | |
| 1133 * attempt to offline and unconfigure device first, and we will | |
| 1134 * deactivate the port regardless of the unconfigure | |
| 1135 * operation results. | |
| 1136 * | |
| 1137 * DEVCTL_AP_DISCONNECT invokes | |
| 1138 * sata_hba_inst->satahba_tran-> | |
| 1139 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). | |
| 1140 * If successful, the device structure (if any) attached | |
| 1141 * to a port is removed and state of the port marked | |
| 1142 * appropriately. | |
| 1143 * Failure of the port_deactivate may keep port in | |
| 1144 * the active state, or may fail the port. | |
| 1145 */ | |
| 1146 | |
| 1147 /* Check the current state of the port */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1148 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1149 (dip, &sata_device); |
| 1258 | 1150 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1151 cport_mutex); | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1152 sata_update_port_info(sata_hba_inst, &sata_device); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1153 if (rval != SATA_SUCCESS || |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1154 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1155 cportinfo->cport_state = SATA_PSTATE_FAILED; |
| 1258 | 1156 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1157 cport_mutex); | |
| 1158 rv = EIO; | |
| 1159 break; | |
| 1160 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1161 /* Sanity check */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1162 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
1163 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
1164 cport_mutex); |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1165 /* No physical port deactivation supported. */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1166 break; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1167 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1168 |
| 1258 | 1169 /* |
| 1170 * set port's dev_state to not ready - this will disable | |
| 1171 * an access to an attached device. | |
| 1172 */ | |
| 1173 cportinfo->cport_state &= ~SATA_STATE_READY; | |
| 1174 | |
| 1175 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1176 sdinfo = cportinfo->cport_devp.cport_sata_drive; | |
| 1177 ASSERT(sdinfo != NULL); | |
| 1178 if ((sdinfo->satadrv_type & | |
| 1179 (SATA_VALID_DEV_TYPE))) { | |
| 1180 /* | |
| 1181 * If a target node exists, try to offline | |
| 1182 * a device and remove target node. | |
| 1183 */ | |
| 1184 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1185 cport)->cport_mutex); | |
| 1186 tdip = sata_get_target_dip(dip, comp_port); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1187 if (tdip != NULL && ndi_devi_offline(tdip, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1188 NDI_DEVI_REMOVE) != NDI_SUCCESS) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1189 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1190 * Problem |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1191 * A target node remained |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1192 * attached. This happens when |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1193 * the file was open or a node |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1194 * was waiting for resources. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1195 * Cannot do anything about it. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1196 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1197 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1198 "sata_hba_ioctl: " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1199 "disconnect: could not " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1200 "unconfigure device before " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1201 "disconnecting the SATA " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1202 "port %d", cport)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1203 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1204 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1205 * Set DEVICE REMOVED state |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1206 * in the target node. It |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1207 * will prevent access to |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1208 * the device even when a |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1209 * new device is attached, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1210 * until the old target node |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1211 * is released, removed and |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1212 * recreated for a new |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1213 * device. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1214 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1215 sata_set_device_removed(tdip); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1216 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1217 * Instruct event daemon to |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1218 * try the target node cleanup |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1219 * later. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1220 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1221 sata_set_target_node_cleanup( |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1222 sata_hba_inst, cport); |
| 1258 | 1223 } |
| 1224 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1225 cport)->cport_mutex); | |
| 1226 /* | |
| 1227 * Remove and release sata_drive_info | |
| 1228 * structure. | |
| 1229 */ | |
| 1230 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != | |
| 1231 NULL) { | |
| 1232 SATA_CPORTINFO_DRV_INFO(cportinfo) = | |
| 1233 NULL; | |
| 1234 (void) kmem_free((void *)sdinfo, | |
| 1235 sizeof (sata_drive_info_t)); | |
| 1236 cportinfo->cport_dev_type = | |
| 1237 SATA_DTYPE_NONE; | |
| 1238 } | |
| 1239 } | |
| 1240 /* | |
| 1241 * Note: PMult info requires different handling. | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1242 * Put PMult handling code here, when PMult is |
| 1258 | 1243 * supported. |
| 1244 */ | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1245 |
| 1258 | 1246 } |
| 1247 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1248 /* Just ask HBA driver to deactivate port */ | |
| 1249 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1250 | |
| 1251 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) | |
| 1252 (dip, &sata_device); | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1253 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1254 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1255 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1256 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1257 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1258 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1259 &sata_device.satadev_addr, SE_NO_HINT); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1260 |
| 1258 | 1261 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1262 cport_mutex); | |
| 1263 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1264 | |
| 1265 if (rval != SATA_SUCCESS) { | |
| 1266 /* | |
| 1267 * Port deactivation failure - do not | |
| 1268 * change port state unless the state | |
| 1269 * returned by HBA indicates a port failure. | |
| 1270 */ | |
| 1271 if (sata_device.satadev_state & SATA_PSTATE_FAILED) | |
| 1272 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 1273 rv = EIO; | |
| 1274 } else { | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1275 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1276 * Deactivation succeded. From now on the framework |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1277 * will not know what is happening to the device, until |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1278 * the port is activated again. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1279 */ |
| 1258 | 1280 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; |
| 1281 } | |
| 1282 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1283 break; | |
| 1284 | |
| 1285 case DEVCTL_AP_UNCONFIGURE: | |
| 1286 | |
| 1287 /* | |
| 1288 * The unconfigure operation uses generic nexus operation to | |
| 1289 * offline a device. It leaves a target device node attached. | |
| 1290 * and obviously sata_drive_info attached as well, because | |
| 1291 * from the hardware point of view nothing has changed. | |
| 1292 */ | |
| 1293 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { | |
| 1294 | |
| 1295 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != | |
| 1296 NDI_SUCCESS) { | |
| 1297 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1298 "sata_hba_ioctl: unconfigure: " | |
| 1299 "failed to unconfigure " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1300 "device at SATA port %d", cport)); |
| 1258 | 1301 rv = EIO; |
| 1302 } | |
| 1303 /* | |
| 1304 * The target node devi_state should be marked with | |
| 1305 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). | |
| 1306 * This would be the indication for cfgadm that | |
| 1307 * the AP node occupant state is 'unconfigured'. | |
| 1308 */ | |
| 1309 | |
| 1310 } else { | |
| 1311 /* | |
| 1312 * This would indicate a failure on the part of cfgadm | |
| 1313 * to detect correct state of the node prior to this | |
| 1314 * call - one cannot unconfigure non-existing device. | |
| 1315 */ | |
| 1316 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1317 "sata_hba_ioctl: unconfigure: " | |
| 1318 "attempt to unconfigure non-existing device " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1319 "at SATA port %d", cport)); |
| 1258 | 1320 rv = ENXIO; |
| 1321 } | |
| 1322 | |
| 1323 break; | |
| 1324 | |
| 1325 case DEVCTL_AP_CONNECT: | |
| 1326 { | |
| 1327 /* | |
| 1328 * The sata cfgadm pluging will invoke this operation only if | |
| 1329 * port was found in the disconnect state (failed state | |
| 1330 * is also treated as the disconnected state). | |
| 1331 * DEVCTL_AP_CONNECT would invoke | |
| 1332 * sata_hba_inst->satahba_tran-> | |
| 1333 * sata_tran_hotplug_ops->sata_tran_port_activate(). | |
| 1334 * If successful and a device is found attached to the port, | |
| 1335 * the initialization sequence is executed to attach | |
| 1336 * a device structure to a port structure. The device is not | |
| 1337 * set in configured state (system-wise) by this operation. | |
| 1338 * The state of the port and a device would be set | |
| 1339 * appropriately. | |
| 1340 * | |
| 1341 * Note, that activating the port may generate link events, | |
| 1342 * so is is important that following processing and the | |
| 1343 * event processing does not interfere with each other! | |
| 1344 * | |
| 1345 * This operation may remove port failed state and will | |
| 1346 * try to make port active and in good standing. | |
| 1347 */ | |
| 1348 | |
| 1349 /* We only care about host sata cport for now */ | |
| 1350 | |
| 1351 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { | |
| 1352 /* Just let HBA driver to activate port */ | |
| 1353 | |
| 1354 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 1355 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1356 /* | |
| 1357 * Port activation failure. | |
| 1358 */ | |
| 1359 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1360 cport)->cport_mutex); | |
| 1361 sata_update_port_info(sata_hba_inst, | |
| 1362 &sata_device); | |
| 1363 if (sata_device.satadev_state & | |
| 1364 SATA_PSTATE_FAILED) { | |
| 1365 cportinfo->cport_state = | |
| 1366 SATA_PSTATE_FAILED; | |
| 1367 } | |
| 1368 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1369 cport)->cport_mutex); | |
| 1370 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1371 "sata_hba_ioctl: connect: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1372 "failed to activate SATA port %d", |
| 1258 | 1373 cport)); |
| 1374 rv = EIO; | |
| 1375 break; | |
| 1376 } | |
| 1377 } | |
| 1378 /* Virgin port state - will be updated by the port re-probe. */ | |
| 1379 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1380 cport)->cport_mutex); | |
| 1381 cportinfo->cport_state = 0; | |
| 1382 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1383 cport)->cport_mutex); | |
| 1384 | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1385 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1386 * Probe the port to find its state and attached device. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1387 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1388 if (sata_reprobe_port(sata_hba_inst, &sata_device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1389 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) |
| 1258 | 1390 rv = EIO; |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1391 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1392 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1393 * without the hint |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1394 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1395 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1396 &sata_device.satadev_addr, SE_NO_HINT); |
| 1258 | 1397 /* |
| 1398 * If there is a device attached to the port, emit | |
| 1399 * a message. | |
| 1400 */ | |
| 1401 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1402 sata_log(sata_hba_inst, CE_WARN, | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1403 "SATA device detected at port %d", cport); |
| 1258 | 1404 } |
| 1405 break; | |
| 1406 } | |
| 1407 | |
| 1408 case DEVCTL_AP_CONFIGURE: | |
| 1409 { | |
| 1410 boolean_t target = TRUE; | |
| 1411 | |
| 1412 /* | |
| 1413 * A port may be in an active or shutdown state. | |
| 1414 * If port is in a failed state, operation is aborted - one | |
| 1415 * has to use explicit connect or port activate request | |
| 1416 * to try to get a port into non-failed mode. | |
| 1417 * | |
| 1418 * If a port is in a shutdown state, arbitrarily invoke | |
| 1419 * sata_tran_port_activate() prior to any other operation. | |
| 1420 * | |
| 1421 * Verify that port state is READY and there is a device | |
| 1422 * of a supported type attached to this port. | |
| 1423 * If target node exists, a device was most likely offlined. | |
| 1424 * If target node does not exist, create a target node an | |
| 1425 * attempt to online it. | |
| 1426 * * | |
| 1427 * NO PMult or devices beyond PMult are supported yet. | |
| 1428 */ | |
| 1429 | |
| 1430 /* We only care about host controller's sata cport for now. */ | |
| 1431 if (cportinfo->cport_state & SATA_PSTATE_FAILED) { | |
| 1432 rv = ENXIO; | |
| 1433 break; | |
| 1434 } | |
| 1435 /* Check the current state of the port */ | |
| 1436 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1437 | |
| 1438 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 1439 (dip, &sata_device); | |
| 1440 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1441 cport_mutex); | |
| 1442 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1443 if (rval != SATA_SUCCESS || | |
| 1444 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { | |
| 1445 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 1446 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1447 cport_mutex); | |
| 1448 rv = EIO; | |
| 1449 break; | |
| 1450 } | |
| 1451 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN) { | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1452 target = FALSE; |
| 1258 | 1453 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1454 cport_mutex); | |
| 1455 | |
| 1456 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { | |
| 1457 /* Just let HBA driver to activate port */ | |
| 1458 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 1459 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1460 /* | |
| 1461 * Port activation failure - do not | |
| 1462 * change port state unless the state | |
| 1463 * returned by HBA indicates a port | |
| 1464 * failure. | |
| 1465 */ | |
| 1466 mutex_enter(&SATA_CPORT_INFO( | |
| 1467 sata_hba_inst, cport)->cport_mutex); | |
| 1468 sata_update_port_info(sata_hba_inst, | |
| 1469 &sata_device); | |
| 1470 if (sata_device.satadev_state & | |
| 1471 SATA_PSTATE_FAILED) { | |
| 1472 cportinfo->cport_state = | |
| 1473 SATA_PSTATE_FAILED; | |
| 1474 } | |
| 1475 mutex_exit(&SATA_CPORT_INFO( | |
| 1476 sata_hba_inst, cport)->cport_mutex); | |
| 1477 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1478 "sata_hba_ioctl: configure: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1479 "failed to activate SATA port %d", |
| 1258 | 1480 cport)); |
| 1481 rv = EIO; | |
| 1482 break; | |
| 1483 } | |
| 1484 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1485 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1486 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1487 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1488 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1489 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1490 &sata_device.satadev_addr, SE_NO_HINT); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1491 |
| 1258 | 1492 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1493 cport_mutex); | |
| 1494 /* Virgin port state */ | |
| 1495 cportinfo->cport_state = 0; | |
| 1496 } | |
| 1497 /* | |
| 1498 * Always reprobe port, to get current device info. | |
| 1499 */ | |
| 1500 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1501 if (sata_reprobe_port(sata_hba_inst, &sata_device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1502 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { |
| 1258 | 1503 rv = EIO; |
| 1504 break; | |
| 1505 } | |
| 1506 if (target == FALSE && | |
| 1507 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1508 /* | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1509 * That's the transition from "inactive" port |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1510 * to active one with device attached. |
| 1258 | 1511 */ |
| 1512 sata_log(sata_hba_inst, CE_WARN, | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1513 "SATA device detected at port %d", |
| 1258 | 1514 cport); |
| 1515 } | |
| 1516 | |
| 1517 /* | |
| 1518 * This is where real configure starts. | |
| 1519 * Change following check for PMult support. | |
| 1520 */ | |
| 1521 if (!(sata_device.satadev_type & SATA_VALID_DEV_TYPE)) { | |
| 1522 /* No device to configure */ | |
| 1523 rv = ENXIO; /* No device to configure */ | |
| 1524 break; | |
| 1525 } | |
| 1526 | |
| 1527 /* | |
| 1528 * Here we may have a device in reset condition, | |
| 1529 * but because we are just configuring it, there is | |
| 1530 * no need to process the reset other than just | |
| 1531 * to clear device reset condition in the HBA driver. | |
| 1532 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will | |
| 1533 * cause a first command sent the HBA driver with the request | |
| 1534 * to clear device reset condition. | |
| 1535 */ | |
| 1536 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1537 cport_mutex); | |
| 1538 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 1539 if (sdinfo == NULL) { | |
| 1540 rv = ENXIO; | |
| 1541 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1542 cport_mutex); | |
| 1543 break; | |
| 1544 } | |
| 1545 if (sdinfo->satadrv_event_flags & | |
| 1546 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) | |
| 1547 sdinfo->satadrv_event_flags = 0; | |
| 1548 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 1549 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1550 | |
| 1551 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1552 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1553 * Target node exists. Verify, that it belongs |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1554 * to existing, attached device and not to |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1555 * a removed device. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1556 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1557 if (sata_check_device_removed(tdip) == B_FALSE) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1558 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1559 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1560 "sata_hba_ioctl: configure: " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1561 "onlining device at SATA port %d " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1562 "failed", cport)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1563 rv = EIO; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1564 break; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1565 } else { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1566 mutex_enter(&SATA_CPORT_INFO( |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1567 sata_hba_inst, cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1568 SATA_CPORT_INFO(sata_hba_inst, cport)-> |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1569 cport_tgtnode_clean = B_TRUE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1570 mutex_exit(&SATA_CPORT_INFO( |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1571 sata_hba_inst, cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1572 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1573 } else { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1574 sata_log(sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1575 "SATA device at port %d cannot be " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1576 "configured. " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1577 "Application(s) accessing previously " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1578 "attached device " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1579 "have to release it before newly inserted " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1580 "device can be made accessible.", |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1581 cport); |
| 1258 | 1582 break; |
| 1583 } | |
| 1584 } else { | |
| 1585 /* | |
| 1586 * No target node - need to create a new target node. | |
| 1587 */ | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1588 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1589 cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1590 SATA_CPORT_INFO(sata_hba_inst, cport)-> |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1591 cport_tgtnode_clean = B_TRUE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1592 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1593 cport_mutex); |
| 1258 | 1594 tdip = sata_create_target_node(dip, sata_hba_inst, |
| 1595 &sata_device.satadev_addr); | |
| 1596 if (tdip == NULL) { | |
| 1597 /* configure failed */ | |
| 1598 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1599 "sata_hba_ioctl: configure: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1600 "configuring SATA device at port %d " |
| 1258 | 1601 "failed", cport)); |
| 1602 rv = EIO; | |
| 1603 break; | |
| 1604 } | |
| 1605 } | |
| 1606 | |
| 1607 break; | |
| 1608 } | |
| 1609 | |
| 1610 case DEVCTL_AP_GETSTATE: | |
| 1611 | |
| 1612 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); | |
| 1613 | |
| 1614 ap_state.ap_last_change = (time_t)-1; | |
| 1615 ap_state.ap_error_code = 0; | |
| 1616 ap_state.ap_in_transition = 0; | |
| 1617 | |
| 1618 /* Copy the return AP-state information to the user space */ | |
| 1619 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { | |
| 1620 rv = EFAULT; | |
| 1621 } | |
| 1622 break; | |
| 1623 | |
| 1624 case DEVCTL_AP_CONTROL: | |
| 1625 { | |
| 1626 /* | |
| 1627 * Generic devctl for hardware specific functionality | |
| 1628 */ | |
| 1629 sata_ioctl_data_t ioc; | |
| 1630 | |
| 1631 ASSERT(dcp == NULL); | |
| 1632 | |
| 1633 /* Copy in user ioctl data first */ | |
| 1634 #ifdef _MULTI_DATAMODEL | |
| 1635 if (ddi_model_convert_from(mode & FMODELS) == | |
| 1636 DDI_MODEL_ILP32) { | |
| 1637 | |
| 1638 sata_ioctl_data_32_t ioc32; | |
| 1639 | |
| 1640 if (ddi_copyin((void *)arg, (void *)&ioc32, | |
| 1641 sizeof (ioc32), mode) != 0) { | |
| 1642 rv = EFAULT; | |
| 1643 break; | |
| 1644 } | |
| 1645 ioc.cmd = (uint_t)ioc32.cmd; | |
| 1646 ioc.port = (uint_t)ioc32.port; | |
| 1647 ioc.get_size = (uint_t)ioc32.get_size; | |
| 1648 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; | |
| 1649 ioc.bufsiz = (uint_t)ioc32.bufsiz; | |
| 1650 ioc.misc_arg = (uint_t)ioc32.misc_arg; | |
| 1651 } else | |
| 1652 #endif /* _MULTI_DATAMODEL */ | |
| 1653 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), | |
| 1654 mode) != 0) { | |
| 1655 return (EFAULT); | |
| 1656 } | |
| 1657 | |
| 1658 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 1659 "sata_hba_ioctl: DEVCTL_AP_CONTROL " | |
| 1660 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); | |
| 1661 | |
| 1662 /* | |
| 1663 * To avoid BE/LE and 32/64 issues, a get_size always returns | |
| 1664 * a 32-bit number. | |
| 1665 */ | |
| 1666 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { | |
| 1667 return (EINVAL); | |
| 1668 } | |
| 1669 /* validate address */ | |
| 1670 cport = SCSI_TO_SATA_CPORT(ioc.port); | |
| 1671 pmport = SCSI_TO_SATA_PMPORT(ioc.port); | |
| 1672 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); | |
| 1673 | |
| 1674 /* Override address qualifier - handle cport only for now */ | |
| 1675 qual = SATA_ADDR_CPORT; | |
| 1676 | |
| 1677 if (sata_validate_sata_address(sata_hba_inst, cport, | |
| 1678 pmport, qual) != 0) | |
| 1679 return (EINVAL); | |
| 1680 | |
| 1681 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 1682 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1683 cport_mutex); | |
| 1684 /* Is the port locked by event processing daemon ? */ | |
| 1685 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { | |
| 1686 /* | |
| 1687 * Cannot process ioctl request now. Come back later | |
| 1688 */ | |
| 1689 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1690 cport_mutex); | |
| 1691 return (EBUSY); | |
| 1692 } | |
| 1693 /* Block event processing for this port */ | |
| 1694 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; | |
| 1695 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1696 | |
| 1697 | |
| 1698 sata_device.satadev_addr.cport = cport; | |
| 1699 sata_device.satadev_addr.pmport = pmport; | |
| 1700 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 1701 | |
| 1702 switch (ioc.cmd) { | |
| 1703 | |
| 1704 case SATA_CFGA_RESET_PORT: | |
| 1705 /* | |
| 1706 * There is no protection here for configured | |
| 1707 * device. | |
| 1708 */ | |
| 1709 | |
| 1710 /* Sanity check */ | |
| 1711 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1712 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1713 "sata_hba_ioctl: " | |
| 1714 "sata_hba_tran missing required " | |
| 1715 "function sata_tran_reset_dport")); | |
| 1716 rv = EINVAL; | |
| 1717 break; | |
| 1718 } | |
| 1719 | |
| 1720 /* handle cport only for now */ | |
| 1721 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1722 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1723 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1724 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1725 "sata_hba_ioctl: reset port: " | |
| 1726 "failed cport %d pmport %d", | |
| 1727 cport, pmport)); | |
| 1728 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1729 cport)->cport_mutex); | |
| 1730 sata_update_port_info(sata_hba_inst, | |
| 1731 &sata_device); | |
| 1732 SATA_CPORT_STATE(sata_hba_inst, cport) = | |
| 1733 SATA_PSTATE_FAILED; | |
| 1734 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1735 cport)->cport_mutex); | |
| 1736 rv = EIO; | |
| 1737 } | |
| 1738 /* | |
| 1739 * Since the port was reset, it should be probed and | |
| 1740 * attached device reinitialized. At this point the | |
| 1741 * port state is unknown - it's state is HBA-specific. | |
| 1742 * Re-probe port to get its state. | |
| 1743 */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1744 if (sata_reprobe_port(sata_hba_inst, &sata_device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1745 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { |
| 1258 | 1746 rv = EIO; |
| 1747 break; | |
| 1748 } | |
| 1749 break; | |
| 1750 | |
| 1751 case SATA_CFGA_RESET_DEVICE: | |
| 1752 /* | |
| 1753 * There is no protection here for configured | |
| 1754 * device. | |
| 1755 */ | |
| 1756 | |
| 1757 /* Sanity check */ | |
| 1758 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1759 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1760 "sata_hba_ioctl: " | |
| 1761 "sata_hba_tran missing required " | |
| 1762 "function sata_tran_reset_dport")); | |
| 1763 rv = EINVAL; | |
| 1764 break; | |
| 1765 } | |
| 1766 | |
| 1767 /* handle only device attached to cports, for now */ | |
| 1768 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1769 | |
| 1770 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1771 cport_mutex); | |
| 1772 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 1773 &sata_device); | |
| 1774 if (sdinfo == NULL) { | |
| 1775 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1776 cport)->cport_mutex); | |
| 1777 rv = EINVAL; | |
| 1778 break; | |
| 1779 } | |
| 1780 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1781 cport_mutex); | |
| 1782 | |
| 1783 /* only handle cport for now */ | |
| 1784 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1785 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1786 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1787 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1788 "sata_hba_ioctl: reset device: failed " | |
| 1789 "cport %d pmport %d", cport, pmport)); | |
| 1790 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1791 cport)->cport_mutex); | |
| 1792 sata_update_port_info(sata_hba_inst, | |
| 1793 &sata_device); | |
| 1794 /* | |
| 1795 * Device info structure remains | |
| 1796 * attached. Another device reset or | |
| 1797 * port disconnect/connect and re-probing is | |
| 1798 * needed to change it's state | |
| 1799 */ | |
| 1800 sdinfo->satadrv_state &= ~SATA_STATE_READY; | |
| 1801 sdinfo->satadrv_state |= | |
| 1802 SATA_DSTATE_FAILED; | |
| 1803 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1804 cport)->cport_mutex); | |
| 1805 rv = EIO; | |
| 1806 } | |
| 1807 /* | |
| 1808 * Since the device was reset, we expect reset event | |
| 1809 * to be reported and processed. | |
| 1810 */ | |
| 1811 break; | |
| 1812 | |
| 1813 case SATA_CFGA_RESET_ALL: | |
| 1814 { | |
| 1815 int tcport; | |
| 1816 | |
| 1817 /* | |
| 1818 * There is no protection here for configured | |
| 1819 * devices. | |
| 1820 */ | |
| 1821 /* Sanity check */ | |
| 1822 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1823 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1824 "sata_hba_ioctl: " | |
| 1825 "sata_hba_tran missing required " | |
| 1826 "function sata_tran_reset_dport")); | |
| 1827 rv = EINVAL; | |
| 1828 break; | |
| 1829 } | |
| 1830 | |
| 1831 /* | |
| 1832 * Need to lock all ports, not just one. | |
| 1833 * If any port is locked by event processing, fail | |
| 1834 * the whole operation. | |
| 1835 * One port is already locked, but for simplicity | |
| 1836 * lock it again. | |
| 1837 */ | |
| 1838 for (tcport = 0; | |
| 1839 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1840 tcport++) { | |
| 1841 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1842 tcport)->cport_mutex); | |
| 1843 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> | |
| 1844 cport_event_flags) & | |
| 1845 SATA_EVNT_LOCK_PORT_BUSY) != 0) { | |
| 1846 rv = EBUSY; | |
| 1847 mutex_exit( | |
| 1848 &SATA_CPORT_INFO(sata_hba_inst, | |
| 1849 tcport)->cport_mutex); | |
| 1850 break; | |
| 1851 } else { | |
| 1852 SATA_CPORT_INFO(sata_hba_inst, | |
| 1853 tcport)->cport_event_flags |= | |
| 1854 SATA_APCTL_LOCK_PORT_BUSY; | |
| 1855 } | |
| 1856 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1857 tcport)->cport_mutex); | |
| 1858 } | |
| 1859 | |
| 1860 if (rv == 0) { | |
| 1861 /* | |
| 1862 * All cports successfully locked. | |
| 1863 * Reset main SATA controller only for now - | |
| 1864 * no PMult. | |
| 1865 */ | |
| 1866 sata_device.satadev_addr.qual = | |
| 1867 SATA_ADDR_CNTRL; | |
| 1868 | |
| 1869 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1870 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1871 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1872 "sata_hba_ioctl: reset controller " | |
| 1873 "failed")); | |
| 1874 rv = EIO; | |
| 1875 } | |
| 1876 | |
| 1877 /* | |
| 1878 * Since ports were reset, they should be | |
| 1879 * re-probed and attached devices | |
| 1880 * reinitialized. | |
| 1881 * At this point port states are unknown, | |
| 1882 * Re-probe ports to get their state - | |
| 1883 * cports only for now. | |
| 1884 */ | |
| 1885 for (tcport = 0; | |
| 1886 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1887 tcport++) { | |
| 1888 sata_device.satadev_addr.cport = | |
| 1889 tcport; | |
| 1890 sata_device.satadev_addr.qual = | |
| 1891 SATA_ADDR_CPORT; | |
| 1892 | |
| 1893 if (sata_reprobe_port(sata_hba_inst, | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1894 &sata_device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1895 SATA_DEV_IDENTIFY_RETRY) != |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
1896 SATA_SUCCESS) |
| 1258 | 1897 rv = EIO; |
| 1898 | |
| 1899 } | |
| 1900 } | |
| 1901 /* | |
| 1902 * Unlock all ports | |
| 1903 */ | |
| 1904 for (tcport = 0; | |
| 1905 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1906 tcport++) { | |
| 1907 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1908 tcport)->cport_mutex); | |
| 1909 SATA_CPORT_INFO(sata_hba_inst, tcport)-> | |
| 1910 cport_event_flags &= | |
| 1911 ~SATA_APCTL_LOCK_PORT_BUSY; | |
| 1912 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1913 tcport)->cport_mutex); | |
| 1914 } | |
| 1915 | |
| 1916 /* | |
| 1917 * This operation returns EFAULT if either reset | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1918 * controller failed or a re-probing of any ports |
| 1258 | 1919 * failed. |
| 1920 * We return here, because common return is for | |
| 1921 * a single cport operation. | |
| 1922 */ | |
| 1923 return (rv); | |
| 1924 } | |
| 1925 | |
| 1926 case SATA_CFGA_PORT_DEACTIVATE: | |
| 1927 /* Sanity check */ | |
| 1928 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { | |
| 1929 rv = ENOTSUP; | |
| 1930 break; | |
| 1931 } | |
| 1932 /* | |
| 1933 * Arbitrarily unconfigure attached device, if any. | |
| 1934 * Even if the unconfigure fails, proceed with the | |
| 1935 * port deactivation. | |
| 1936 */ | |
| 1937 | |
| 1938 /* Handle only device attached to cports, for now */ | |
| 1939 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1940 | |
| 1941 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1942 cport_mutex); | |
| 1943 cportinfo->cport_state &= ~SATA_STATE_READY; | |
| 1944 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1945 /* | |
| 1946 * Handle only device attached to cports, | |
| 1947 * for now | |
| 1948 */ | |
| 1949 sata_device.satadev_addr.qual = | |
| 1950 SATA_ADDR_DCPORT; | |
| 1951 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 1952 &sata_device); | |
| 1953 if (sdinfo != NULL && | |
| 1954 (sdinfo->satadrv_type & | |
| 1955 SATA_VALID_DEV_TYPE)) { | |
| 1956 /* | |
| 1957 * If a target node exists, try to | |
| 1958 * offline a device and remove target | |
| 1959 * node. | |
| 1960 */ | |
| 1961 mutex_exit(&SATA_CPORT_INFO( | |
| 1962 sata_hba_inst, cport)->cport_mutex); | |
| 1963 tdip = sata_get_target_dip(dip, cport); | |
| 1964 if (tdip != NULL) { | |
| 1965 /* target node exist */ | |
| 1966 SATADBG1(SATA_DBG_IOCTL_IF, | |
| 1967 sata_hba_inst, | |
| 1968 "sata_hba_ioctl: " | |
| 1969 "port deactivate: " | |
| 1970 "target node exists.", | |
| 1971 NULL); | |
| 1972 | |
| 1973 if (ndi_devi_offline(tdip, | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1974 NDI_DEVI_REMOVE) != |
| 1258 | 1975 NDI_SUCCESS) { |
| 1976 SATA_LOG_D(( | |
| 1977 sata_hba_inst, | |
| 1978 CE_WARN, | |
| 1979 "sata_hba_ioctl:" | |
| 1980 "port deactivate: " | |
| 1981 "failed to " | |
| 1982 "unconfigure " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1983 "device at port " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1984 "%d before " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1985 "deactivating " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
1986 "the port", cport)); |
|
4659
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1987 |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1988 |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1989 /* |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1990 * Set DEVICE REMOVED |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1991 * state in the target |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1992 * node. It will |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1993 * prevent access to |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1994 * the device even when |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1995 * a new device is |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1996 * attached, until the |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1997 * old target node is |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1998 * released, removed and |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
1999 * recreated for a new |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2000 * device. |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2001 */ |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2002 sata_set_device_removed |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2003 (tdip); |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2004 /* |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2005 * Instruct event |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2006 * daemon to try the |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2007 * target node cleanup |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2008 * later. |
|
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2009 */ |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2010 sata_set_target_node_cleanup( |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2011 sata_hba_inst, cport); |
|
4659
c3ede552abd1
6575990 sata module may panic system when sata port is deactivated
pawelw
parents:
4582
diff
changeset
|
2012 } |
| 1258 | 2013 } |
| 2014 mutex_enter(&SATA_CPORT_INFO( | |
| 2015 sata_hba_inst, cport)->cport_mutex); | |
| 2016 /* | |
| 2017 * In any case, | |
| 2018 * remove and release sata_drive_info | |
| 2019 * structure. | |
| 2020 * (cport attached device ony, for now) | |
| 2021 */ | |
| 2022 SATA_CPORTINFO_DRV_INFO(cportinfo) = | |
| 2023 NULL; | |
| 2024 (void) kmem_free((void *)sdinfo, | |
| 2025 sizeof (sata_drive_info_t)); | |
| 2026 cportinfo->cport_dev_type = | |
| 2027 SATA_DTYPE_NONE; | |
| 2028 } | |
| 2029 /* | |
| 2030 * Note: PMult info requires different | |
| 2031 * handling. This comment is a placeholder for | |
| 2032 * a code handling PMult, to be implemented | |
| 2033 * in phase 2. | |
| 2034 */ | |
| 2035 } | |
| 2036 cportinfo->cport_state &= ~(SATA_STATE_PROBED | | |
| 2037 SATA_STATE_PROBING); | |
| 2038 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2039 cport_mutex); | |
| 2040 /* handle cport only for now */ | |
| 2041 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 2042 /* Just let HBA driver to deactivate port */ | |
| 2043 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) | |
| 2044 (dip, &sata_device); | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2045 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2046 * Generate sysevent - |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2047 * EC_DR / ESC_DR_AP_STATE_CHANGE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2048 * without the hint |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2049 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2050 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2051 &sata_device.satadev_addr, SE_NO_HINT); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2052 |
| 1258 | 2053 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 2054 cport_mutex); | |
| 2055 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 2056 if (rval != SATA_SUCCESS) { | |
| 2057 /* | |
| 2058 * Port deactivation failure - do not | |
| 2059 * change port state unless the state | |
| 2060 * returned by HBA indicates a port failure. | |
| 2061 */ | |
| 2062 if (sata_device.satadev_state & | |
| 2063 SATA_PSTATE_FAILED) { | |
| 2064 SATA_CPORT_STATE(sata_hba_inst, | |
| 2065 cport) = SATA_PSTATE_FAILED; | |
| 2066 } | |
| 2067 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2068 "sata_hba_ioctl: port deactivate: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2069 "cannot deactivate SATA port %d", |
| 1258 | 2070 cport)); |
| 2071 rv = EIO; | |
| 2072 } else { | |
| 2073 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; | |
| 2074 } | |
| 2075 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2076 cport_mutex); | |
| 2077 | |
| 2078 break; | |
| 2079 | |
| 2080 case SATA_CFGA_PORT_ACTIVATE: | |
| 2081 { | |
| 2082 boolean_t dev_existed = TRUE; | |
| 2083 | |
| 2084 /* Sanity check */ | |
| 2085 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { | |
| 2086 rv = ENOTSUP; | |
| 2087 break; | |
| 2088 } | |
| 2089 /* handle cport only for now */ | |
| 2090 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || | |
| 2091 cportinfo->cport_dev_type == SATA_DTYPE_NONE) | |
| 2092 dev_existed = FALSE; | |
| 2093 | |
| 2094 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 2095 /* Just let HBA driver to activate port */ | |
| 2096 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 2097 (dip, &sata_device) != SATA_SUCCESS) { | |
| 2098 /* | |
| 2099 * Port activation failure - do not | |
| 2100 * change port state unless the state | |
| 2101 * returned by HBA indicates a port failure. | |
| 2102 */ | |
| 2103 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2104 cport)->cport_mutex); | |
| 2105 sata_update_port_info(sata_hba_inst, | |
| 2106 &sata_device); | |
| 2107 if (sata_device.satadev_state & | |
| 2108 SATA_PSTATE_FAILED) { | |
| 2109 SATA_CPORT_STATE(sata_hba_inst, | |
| 2110 cport) = SATA_PSTATE_FAILED; | |
| 2111 } | |
| 2112 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2113 cport)->cport_mutex); | |
| 2114 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2115 "sata_hba_ioctl: port activate: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2116 "cannot activate SATA port %d", |
| 1258 | 2117 cport)); |
| 2118 rv = EIO; | |
| 2119 break; | |
| 2120 } | |
| 2121 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2122 cport_mutex); | |
| 2123 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; | |
| 2124 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2125 cport_mutex); | |
| 2126 | |
| 2127 /* | |
| 2128 * Re-probe port to find its current state and | |
| 2129 * possibly attached device. | |
| 2130 * Port re-probing may change the cportinfo device | |
| 2131 * type if device is found attached. | |
| 2132 * If port probing failed, the device type would be | |
| 2133 * set to SATA_DTYPE_NONE. | |
| 2134 */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2135 (void) sata_reprobe_port(sata_hba_inst, &sata_device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2136 SATA_DEV_IDENTIFY_RETRY); |
| 1258 | 2137 |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2138 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2139 * Generate sysevent - |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2140 * EC_DR / ESC_DR_AP_STATE_CHANGE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2141 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2142 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2143 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2144 &sata_device.satadev_addr, SE_NO_HINT); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2145 |
| 1258 | 2146 if (dev_existed == FALSE && |
| 2147 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 2148 /* | |
| 2149 * That's the transition from "inactive" port | |
| 2150 * state or active port without a device | |
| 2151 * attached to the active port state with | |
| 2152 * a device attached. | |
| 2153 */ | |
| 2154 sata_log(sata_hba_inst, CE_WARN, | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2155 "SATA device detected at port %d", cport); |
| 1258 | 2156 } |
| 2157 | |
| 2158 break; | |
| 2159 } | |
| 2160 | |
| 2161 case SATA_CFGA_PORT_SELF_TEST: | |
| 2162 | |
| 2163 /* Sanity check */ | |
| 2164 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) { | |
| 2165 rv = ENOTSUP; | |
| 2166 break; | |
| 2167 } | |
| 2168 /* | |
| 2169 * There is no protection here for a configured | |
| 2170 * device attached to this port. | |
| 2171 */ | |
| 2172 | |
| 2173 /* only handle cport for now */ | |
| 2174 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 2175 | |
| 2176 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) | |
| 2177 (dip, &sata_device) != SATA_SUCCESS) { | |
| 2178 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2179 "sata_hba_ioctl: port selftest: " | |
| 2180 "failed cport %d pmport %d", | |
| 2181 cport, pmport)); | |
| 2182 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2183 cport)->cport_mutex); | |
| 2184 sata_update_port_info(sata_hba_inst, | |
| 2185 &sata_device); | |
| 2186 SATA_CPORT_STATE(sata_hba_inst, cport) = | |
| 2187 SATA_PSTATE_FAILED; | |
| 2188 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2189 cport)->cport_mutex); | |
| 2190 rv = EIO; | |
| 2191 break; | |
| 2192 } | |
| 2193 /* | |
| 2194 * Since the port was reset, it should be probed and | |
| 2195 * attached device reinitialized. At this point the | |
| 2196 * port state is unknown - it's state is HBA-specific. | |
| 2197 * Force port re-probing to get it into a known state. | |
| 2198 */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2199 if (sata_reprobe_port(sata_hba_inst, &sata_device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2200 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { |
| 1258 | 2201 rv = EIO; |
| 2202 break; | |
| 2203 } | |
| 2204 break; | |
| 2205 | |
| 2206 case SATA_CFGA_GET_DEVICE_PATH: | |
| 2207 { | |
| 2208 char path[MAXPATHLEN]; | |
| 2209 uint32_t size; | |
| 2210 | |
| 2211 (void) strcpy(path, "/devices"); | |
| 2212 if ((tdip = sata_get_target_dip(dip, ioc.port)) == | |
| 2213 NULL) { | |
| 2214 | |
| 2215 /* | |
| 2216 * No such device. | |
| 2217 * If this is a request for a size, do not | |
| 2218 * return EINVAL for non-exisiting target, | |
| 2219 * because cfgadm will indicate a meaningless | |
| 2220 * ioctl failure. | |
| 2221 * If this is a real request for a path, | |
| 2222 * indicate invalid argument. | |
| 2223 */ | |
| 2224 if (!ioc.get_size) { | |
| 2225 rv = EINVAL; | |
| 2226 break; | |
| 2227 } | |
| 2228 } else { | |
| 2229 (void) ddi_pathname(tdip, path + strlen(path)); | |
| 2230 } | |
| 2231 size = strlen(path) + 1; | |
| 2232 | |
| 2233 if (ioc.get_size) { | |
| 2234 if (ddi_copyout((void *)&size, | |
| 2235 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2236 rv = EFAULT; | |
| 2237 } | |
| 2238 } else { | |
| 2239 if (ioc.bufsiz != size) { | |
| 2240 rv = EINVAL; | |
| 2241 } else if (ddi_copyout((void *)&path, | |
| 2242 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2243 rv = EFAULT; | |
| 2244 } | |
| 2245 } | |
| 2246 break; | |
| 2247 } | |
| 2248 | |
| 2249 case SATA_CFGA_GET_AP_TYPE: | |
| 2250 { | |
| 2251 uint32_t type_len; | |
| 2252 const char *ap_type; | |
| 2253 | |
| 2254 /* cport only, no port multiplier support */ | |
| 2255 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { | |
| 2256 case SATA_DTYPE_NONE: | |
| 2257 ap_type = "port"; | |
| 2258 break; | |
| 2259 | |
| 2260 case SATA_DTYPE_ATADISK: | |
| 2261 ap_type = "disk"; | |
| 2262 break; | |
| 2263 | |
| 2264 case SATA_DTYPE_ATAPICD: | |
| 2265 ap_type = "cd/dvd"; | |
| 2266 break; | |
| 2267 | |
| 2268 case SATA_DTYPE_PMULT: | |
| 2269 ap_type = "pmult"; | |
| 2270 break; | |
| 2271 | |
| 2272 case SATA_DTYPE_UNKNOWN: | |
| 2273 ap_type = "unknown"; | |
| 2274 break; | |
| 2275 | |
| 2276 default: | |
| 2277 ap_type = "unsupported"; | |
| 2278 break; | |
| 2279 | |
| 2280 } /* end of dev_type switch */ | |
| 2281 | |
| 2282 type_len = strlen(ap_type) + 1; | |
| 2283 | |
| 2284 if (ioc.get_size) { | |
| 2285 if (ddi_copyout((void *)&type_len, | |
| 2286 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2287 rv = EFAULT; | |
| 2288 break; | |
| 2289 } | |
| 2290 } else { | |
| 2291 if (ioc.bufsiz != type_len) { | |
| 2292 rv = EINVAL; | |
| 2293 break; | |
| 2294 } | |
| 2295 if (ddi_copyout((void *)ap_type, ioc.buf, | |
| 2296 ioc.bufsiz, mode) != 0) { | |
| 2297 rv = EFAULT; | |
| 2298 break; | |
| 2299 } | |
| 2300 } | |
| 2301 | |
| 2302 break; | |
| 2303 } | |
| 2304 | |
| 2305 case SATA_CFGA_GET_MODEL_INFO: | |
| 2306 { | |
| 2307 uint32_t info_len; | |
| 2308 char ap_info[sizeof (sdinfo->satadrv_id.ai_model) + 1]; | |
| 2309 | |
| 2310 /* | |
| 2311 * This operation should return to cfgadm the | |
| 2312 * device model information string | |
| 2313 */ | |
| 2314 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2315 cport_mutex); | |
| 2316 /* only handle device connected to cport for now */ | |
| 2317 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2318 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2319 &sata_device); | |
| 2320 if (sdinfo == NULL) { | |
| 2321 rv = EINVAL; | |
| 2322 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2323 cport)->cport_mutex); | |
| 2324 break; | |
| 2325 } | |
| 2326 bcopy(sdinfo->satadrv_id.ai_model, ap_info, | |
| 2327 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 2328 swab(ap_info, ap_info, | |
| 2329 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 2330 ap_info[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; | |
| 2331 | |
| 2332 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2333 cport_mutex); | |
| 2334 | |
| 2335 info_len = strlen(ap_info) + 1; | |
| 2336 | |
| 2337 if (ioc.get_size) { | |
| 2338 if (ddi_copyout((void *)&info_len, | |
| 2339 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2340 rv = EFAULT; | |
| 2341 break; | |
| 2342 } | |
| 2343 } else { | |
| 2344 if (ioc.bufsiz < info_len) { | |
| 2345 rv = EINVAL; | |
| 2346 break; | |
| 2347 } | |
| 2348 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2349 ioc.bufsiz, mode) != 0) { | |
| 2350 rv = EFAULT; | |
| 2351 break; | |
| 2352 } | |
| 2353 } | |
| 2354 | |
| 2355 break; | |
| 2356 } | |
| 2357 | |
| 2358 case SATA_CFGA_GET_REVFIRMWARE_INFO: | |
| 2359 { | |
| 2360 uint32_t info_len; | |
| 2361 char ap_info[ | |
| 2362 sizeof (sdinfo->satadrv_id.ai_fw) + 1]; | |
| 2363 | |
| 2364 /* | |
| 2365 * This operation should return to cfgadm the | |
| 2366 * device firmware revision information string | |
| 2367 */ | |
| 2368 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2369 cport_mutex); | |
| 2370 /* only handle device connected to cport for now */ | |
| 2371 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2372 | |
| 2373 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2374 &sata_device); | |
| 2375 if (sdinfo == NULL) { | |
| 2376 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2377 cport)->cport_mutex); | |
| 2378 rv = EINVAL; | |
| 2379 break; | |
| 2380 } | |
| 2381 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, | |
| 2382 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 2383 swab(ap_info, ap_info, | |
| 2384 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 2385 ap_info[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; | |
| 2386 | |
| 2387 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2388 cport_mutex); | |
| 2389 | |
| 2390 info_len = strlen(ap_info) + 1; | |
| 2391 | |
| 2392 if (ioc.get_size) { | |
| 2393 if (ddi_copyout((void *)&info_len, | |
| 2394 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2395 rv = EFAULT; | |
| 2396 break; | |
| 2397 } | |
| 2398 } else { | |
| 2399 if (ioc.bufsiz < info_len) { | |
| 2400 rv = EINVAL; | |
| 2401 break; | |
| 2402 } | |
| 2403 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2404 ioc.bufsiz, mode) != 0) { | |
| 2405 rv = EFAULT; | |
| 2406 break; | |
| 2407 } | |
| 2408 } | |
| 2409 | |
| 2410 break; | |
| 2411 } | |
| 2412 | |
| 2413 case SATA_CFGA_GET_SERIALNUMBER_INFO: | |
| 2414 { | |
| 2415 uint32_t info_len; | |
| 2416 char ap_info[ | |
| 2417 sizeof (sdinfo->satadrv_id.ai_drvser) + 1]; | |
| 2418 | |
| 2419 /* | |
| 2420 * This operation should return to cfgadm the | |
| 2421 * device serial number information string | |
| 2422 */ | |
| 2423 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2424 cport_mutex); | |
| 2425 /* only handle device connected to cport for now */ | |
| 2426 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2427 | |
| 2428 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2429 &sata_device); | |
| 2430 if (sdinfo == NULL) { | |
| 2431 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2432 cport)->cport_mutex); | |
| 2433 rv = EINVAL; | |
| 2434 break; | |
| 2435 } | |
| 2436 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, | |
| 2437 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 2438 swab(ap_info, ap_info, | |
| 2439 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 2440 ap_info[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; | |
| 2441 | |
| 2442 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2443 cport_mutex); | |
| 2444 | |
| 2445 info_len = strlen(ap_info) + 1; | |
| 2446 | |
| 2447 if (ioc.get_size) { | |
| 2448 if (ddi_copyout((void *)&info_len, | |
| 2449 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2450 rv = EFAULT; | |
| 2451 break; | |
| 2452 } | |
| 2453 } else { | |
| 2454 if (ioc.bufsiz < info_len) { | |
| 2455 rv = EINVAL; | |
| 2456 break; | |
| 2457 } | |
| 2458 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2459 ioc.bufsiz, mode) != 0) { | |
| 2460 rv = EFAULT; | |
| 2461 break; | |
| 2462 } | |
| 2463 } | |
| 2464 | |
| 2465 break; | |
| 2466 } | |
| 2467 | |
| 2468 default: | |
| 2469 rv = EINVAL; | |
| 2470 break; | |
| 2471 | |
| 2472 } /* End of DEVCTL_AP_CONTROL cmd switch */ | |
| 2473 | |
| 2474 break; | |
| 2475 } | |
| 2476 | |
| 2477 default: | |
| 2478 { | |
| 2479 /* | |
| 2480 * If we got here, we got an IOCTL that SATA HBA Framework | |
| 2481 * does not recognize. Pass ioctl to HBA driver, in case | |
| 2482 * it could process it. | |
| 2483 */ | |
| 2484 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; | |
| 2485 dev_info_t *mydip = SATA_DIP(sata_hba_inst); | |
| 2486 | |
| 2487 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 2488 "IOCTL 0x%2x not supported in SATA framework, " | |
| 2489 "passthrough to HBA", cmd); | |
| 2490 | |
| 2491 if (sata_tran->sata_tran_ioctl == NULL) { | |
| 2492 rv = EINVAL; | |
| 2493 break; | |
| 2494 } | |
| 2495 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); | |
| 2496 if (rval != 0) { | |
| 2497 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 2498 "IOCTL 0x%2x failed in HBA", cmd); | |
| 2499 rv = rval; | |
| 2500 } | |
| 2501 break; | |
| 2502 } | |
| 2503 | |
| 2504 } /* End of main IOCTL switch */ | |
| 2505 | |
| 2506 if (dcp) { | |
| 2507 ndi_dc_freehdl(dcp); | |
| 2508 } | |
| 2509 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 2510 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; | |
| 2511 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 2512 | |
| 2513 return (rv); | |
| 2514 } | |
| 2515 | |
| 2516 | |
| 2517 | |
| 2518 | |
| 2519 /* ****************** SCSA required entry points *********************** */ | |
| 2520 | |
| 2521 /* | |
| 2522 * Implementation of scsi tran_tgt_init. | |
| 2523 * sata_scsi_tgt_init() initializes scsi_device structure | |
| 2524 * | |
| 2525 * If successful, DDI_SUCCESS is returned. | |
| 2526 * DDI_FAILURE is returned if addressed device does not exist | |
| 2527 */ | |
| 2528 | |
| 2529 static int | |
| 2530 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, | |
| 2531 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) | |
| 2532 { | |
| 2533 #ifndef __lock_lint | |
| 2534 _NOTE(ARGUNUSED(hba_dip)) | |
| 2535 #endif | |
| 2536 sata_device_t sata_device; | |
| 2537 sata_drive_info_t *sdinfo; | |
| 4582 | 2538 struct sata_id *sid; |
| 1258 | 2539 sata_hba_inst_t *sata_hba_inst; |
| 4582 | 2540 char model[SATA_ID_MODEL_LEN + 1]; |
| 2541 char fw[SATA_ID_FW_LEN + 1]; | |
| 2542 char *vid, *pid; | |
| 2543 int i; | |
| 1258 | 2544 |
| 2545 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); | |
| 2546 | |
| 2547 /* Validate scsi device address */ | |
| 2548 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, | |
| 2549 &sata_device) != 0) | |
| 2550 return (DDI_FAILURE); | |
| 2551 | |
| 2552 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2553 sata_device.satadev_addr.cport))); | |
| 2554 | |
| 2555 /* sata_device now contains a valid sata address */ | |
| 2556 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 2557 if (sdinfo == NULL) { | |
| 2558 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2559 sata_device.satadev_addr.cport))); | |
| 2560 return (DDI_FAILURE); | |
| 2561 } | |
| 4582 | 2562 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
| 2563 sata_device.satadev_addr.cport))); | |
| 2564 | |
| 1258 | 2565 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { |
| 2566 if (ndi_prop_update_string(DDI_DEV_T_NONE, tgt_dip, | |
| 2567 "variant", "atapi") != DDI_PROP_SUCCESS) { | |
| 2568 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2569 "sata_scsi_tgt_init: variant atapi " | |
| 2570 "property could not be created")); | |
| 2571 return (DDI_FAILURE); | |
| 2572 } | |
| 4582 | 2573 } |
| 2574 | |
| 2575 /* | |
| 2576 * 'Identify Device Data' does not always fit in standard SCSI | |
| 2577 * INQUIRY data, so establish INQUIRY_* properties with full-form | |
| 2578 * of information. | |
| 2579 */ | |
| 2580 sid = &sdinfo->satadrv_id; | |
| 2581 #ifdef _LITTLE_ENDIAN | |
| 2582 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); | |
| 2583 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); | |
| 2584 #else /* _LITTLE_ENDIAN */ | |
| 2585 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); | |
| 2586 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); | |
| 2587 #endif /* _LITTLE_ENDIAN */ | |
| 2588 model[SATA_ID_MODEL_LEN] = 0; | |
| 2589 fw[SATA_ID_FW_LEN] = 0; | |
| 2590 | |
| 2591 /* split model into into vid/pid */ | |
| 2592 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) | |
| 2593 if ((*pid == ' ') || (*pid == '\t')) | |
| 2594 break; | |
| 2595 if (i < SATA_ID_MODEL_LEN) { | |
| 2596 vid = model; | |
| 2597 *pid++ = 0; /* terminate vid, establish pid */ | |
| 2598 } else { | |
| 2599 vid = NULL; /* vid will stay "ATA " */ | |
| 2600 pid = model; /* model is all pid */ | |
| 2601 } | |
| 2602 | |
| 2603 if (vid) | |
| 2604 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, | |
| 2605 vid, strlen(vid)); | |
| 2606 if (pid) | |
| 2607 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, | |
| 2608 pid, strlen(pid)); | |
| 2609 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_REVISION_ID, | |
| 2610 fw, strlen(fw)); | |
| 2611 | |
| 1258 | 2612 return (DDI_SUCCESS); |
| 2613 } | |
| 2614 | |
| 2615 /* | |
| 2616 * Implementation of scsi tran_tgt_probe. | |
| 2617 * Probe target, by calling default scsi routine scsi_hba_probe() | |
| 2618 */ | |
| 2619 static int | |
| 2620 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) | |
| 2621 { | |
| 2622 sata_hba_inst_t *sata_hba_inst = | |
| 2623 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); | |
| 2624 int rval; | |
| 2625 | |
| 2626 rval = scsi_hba_probe(sd, callback); | |
| 2627 | |
| 2628 if (rval == SCSIPROBE_EXISTS) { | |
| 2629 /* | |
| 2630 * Set property "pm-capable" on the target device node, so that | |
| 2631 * the target driver will not try to fetch scsi cycle counters | |
| 2632 * before enabling device power-management. | |
| 2633 */ | |
| 2634 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, | |
| 2635 "pm-capable", 1)) != DDI_PROP_SUCCESS) { | |
| 2636 sata_log(sata_hba_inst, CE_WARN, | |
| 4582 | 2637 "SATA device at port %d: " |
| 2638 "will not be power-managed ", | |
| 2639 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); | |
| 1258 | 2640 SATA_LOG_D((sata_hba_inst, CE_WARN, |
| 4582 | 2641 "failure updating pm-capable property")); |
| 1258 | 2642 } |
| 2643 } | |
| 2644 return (rval); | |
| 2645 } | |
| 2646 | |
| 2647 /* | |
| 2648 * Implementation of scsi tran_tgt_free. | |
| 2649 * Release all resources allocated for scsi_device | |
| 2650 */ | |
| 2651 static void | |
| 2652 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, | |
| 2653 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) | |
| 2654 { | |
| 2655 #ifndef __lock_lint | |
| 2656 _NOTE(ARGUNUSED(hba_dip)) | |
| 2657 #endif | |
| 2658 sata_device_t sata_device; | |
| 2659 sata_drive_info_t *sdinfo; | |
| 2660 sata_hba_inst_t *sata_hba_inst; | |
| 2661 | |
| 2662 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); | |
| 2663 | |
| 2664 /* Validate scsi device address */ | |
| 2665 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, | |
| 2666 &sata_device) != 0) | |
| 2667 return; | |
| 2668 | |
| 2669 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2670 sata_device.satadev_addr.cport))); | |
| 2671 | |
| 2672 /* sata_device now should contain a valid sata address */ | |
| 2673 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 2674 if (sdinfo == NULL) { | |
| 2675 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2676 sata_device.satadev_addr.cport))); | |
| 2677 return; | |
| 2678 } | |
| 2679 /* | |
| 2680 * We did not allocate any resources in sata_scsi_tgt_init() | |
| 2681 * other than property for ATAPI device, if any | |
| 2682 */ | |
| 2683 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { | |
| 2684 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2685 sata_device.satadev_addr.cport))); | |
| 2686 if (ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "variant") != | |
| 2687 DDI_PROP_SUCCESS) | |
| 2688 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2689 "sata_scsi_tgt_free: variant atapi " | |
| 2690 "property could not be removed")); | |
| 2691 } else { | |
| 2692 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2693 sata_device.satadev_addr.cport))); | |
| 2694 } | |
| 2695 } | |
| 2696 | |
| 2697 /* | |
| 2698 * Implementation of scsi tran_init_pkt | |
| 2699 * Upon successful return, scsi pkt buffer has DMA resources allocated. | |
| 2700 * | |
| 2701 * It seems that we should always allocate pkt, even if the address is | |
| 2702 * for non-existing device - just use some default for dma_attr. | |
| 2703 * The reason is that there is no way to communicate this to a caller here. | |
| 2704 * Subsequent call to sata_scsi_start may fail appropriately. | |
| 2705 * Simply returning NULL does not seem to discourage a target driver... | |
| 2706 * | |
| 2707 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. | |
| 2708 */ | |
| 2709 static struct scsi_pkt * | |
| 2710 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, | |
| 2711 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, | |
| 2712 int (*callback)(caddr_t), caddr_t arg) | |
| 2713 { | |
| 2714 sata_hba_inst_t *sata_hba_inst = | |
| 2715 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2716 dev_info_t *dip = SATA_DIP(sata_hba_inst); | |
| 2717 sata_device_t sata_device; | |
| 2718 sata_drive_info_t *sdinfo; | |
| 2719 sata_pkt_txlate_t *spx; | |
| 2720 ddi_dma_attr_t cur_dma_attr; | |
| 2721 int rval; | |
| 2722 boolean_t new_pkt = TRUE; | |
| 2723 | |
| 2724 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); | |
| 2725 | |
| 2726 /* | |
| 2727 * We need to translate the address, even if it could be | |
| 2728 * a bogus one, for a non-existing device | |
| 2729 */ | |
| 2730 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); | |
| 2731 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 2732 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); | |
| 2733 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 2734 | |
| 2735 if (pkt == NULL) { | |
| 2736 /* | |
| 2737 * Have to allocate a brand new scsi packet. | |
| 2738 * We need to operate with auto request sense enabled. | |
| 2739 */ | |
| 2740 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, | |
| 2741 MAX(statuslen, sizeof (struct scsi_arq_status)), | |
| 2742 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); | |
| 2743 | |
| 2744 if (pkt == NULL) | |
| 2745 return (NULL); | |
| 2746 | |
| 2747 /* Fill scsi packet structure */ | |
| 2748 pkt->pkt_comp = (void (*)())NULL; | |
| 2749 pkt->pkt_time = 0; | |
| 2750 pkt->pkt_resid = 0; | |
| 2751 pkt->pkt_statistics = 0; | |
| 2752 pkt->pkt_reason = 0; | |
| 2753 | |
| 2754 /* | |
| 2755 * pkt_hba_private will point to sata pkt txlate structure | |
| 2756 */ | |
| 2757 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2758 bzero(spx, sizeof (sata_pkt_txlate_t)); | |
| 2759 | |
| 2760 spx->txlt_scsi_pkt = pkt; | |
| 2761 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 2762 | |
| 2763 /* Allocate sata_pkt */ | |
| 2764 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); | |
| 2765 if (spx->txlt_sata_pkt == NULL) { | |
| 2766 /* Could not allocate sata pkt */ | |
| 2767 scsi_hba_pkt_free(ap, pkt); | |
| 2768 return (NULL); | |
| 2769 } | |
| 2770 /* Set sata address */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2771 spx->txlt_sata_pkt->satapkt_device.satadev_addr = |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2772 sata_device.satadev_addr; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2773 spx->txlt_sata_pkt->satapkt_device.satadev_rev = |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
2774 sata_device.satadev_rev; |
| 1258 | 2775 |
| 2776 if ((bp == NULL) || (bp->b_bcount == 0)) | |
| 2777 return (pkt); | |
| 2778 | |
| 2779 spx->txlt_total_residue = bp->b_bcount; | |
| 2780 } else { | |
| 2781 new_pkt = FALSE; | |
| 2782 /* | |
| 2783 * Packet was preallocated/initialized by previous call | |
| 2784 */ | |
| 2785 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2786 | |
| 2787 if ((bp == NULL) || (bp->b_bcount == 0)) { | |
| 2788 return (pkt); | |
| 2789 } | |
| 2790 ASSERT(spx->txlt_buf_dma_handle != NULL); | |
| 2791 | |
| 2792 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ | |
| 2793 } | |
| 2794 | |
| 2795 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; | |
| 2796 | |
| 2797 /* | |
| 2798 * We use an adjusted version of the dma_attr, to account | |
| 2799 * for device addressing limitations. | |
| 2800 * sata_adjust_dma_attr() will handle sdinfo == NULL which may | |
| 2801 * happen when a device is not yet configured. | |
| 2802 */ | |
| 2803 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2804 sata_device.satadev_addr.cport))); | |
| 2805 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 2806 &spx->txlt_sata_pkt->satapkt_device); | |
| 2807 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ | |
| 2808 sata_adjust_dma_attr(sdinfo, | |
| 2809 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); | |
| 2810 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2811 sata_device.satadev_addr.cport))); | |
| 2812 /* | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2813 * Allocate necessary DMA resources for the packet's data buffer |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2814 * NOTE: |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2815 * In case of read/write commands, DMA resource allocation here is |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2816 * based on the premise that the transfer length specified in |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2817 * the read/write scsi cdb will match exactly DMA resources - |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2818 * returning correct packet residue is crucial. |
| 1258 | 2819 */ |
| 2820 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, | |
| 2821 &cur_dma_attr)) != DDI_SUCCESS) { | |
|
2071
01f4efa62f05
6430233 panic assertion failed: spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == 0L
ls24207
parents:
1940
diff
changeset
|
2822 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; |
| 1258 | 2823 sata_pkt_free(spx); |
| 2824 /* | |
| 2825 * If a DMA allocation request fails with | |
| 2826 * DDI_DMA_NOMAPPING, indicate the error by calling | |
| 2827 * bioerror(9F) with bp and an error code of EFAULT. | |
| 2828 * If a DMA allocation request fails with | |
| 2829 * DDI_DMA_TOOBIG, indicate the error by calling | |
| 2830 * bioerror(9F) with bp and an error code of EINVAL. | |
| 2831 */ | |
| 2832 switch (rval) { | |
| 2833 case DDI_DMA_NORESOURCES: | |
| 2834 bioerror(bp, 0); | |
| 2835 break; | |
| 2836 case DDI_DMA_NOMAPPING: | |
| 2837 case DDI_DMA_BADATTR: | |
| 2838 bioerror(bp, EFAULT); | |
| 2839 break; | |
| 2840 case DDI_DMA_TOOBIG: | |
| 2841 default: | |
| 2842 bioerror(bp, EINVAL); | |
| 2843 break; | |
| 2844 } | |
| 2177 | 2845 if (new_pkt == TRUE) |
| 1258 | 2846 scsi_hba_pkt_free(ap, pkt); |
| 2847 return (NULL); | |
| 2848 } | |
| 2849 /* Set number of bytes that are not yet accounted for */ | |
| 2850 pkt->pkt_resid = spx->txlt_total_residue; | |
| 2851 ASSERT(pkt->pkt_resid >= 0); | |
| 2852 | |
| 2853 return (pkt); | |
| 2854 } | |
| 2855 | |
| 2856 /* | |
| 2857 * Implementation of scsi tran_start. | |
| 2858 * Translate scsi cmd into sata operation and return status. | |
| 2859 * Supported scsi commands: | |
| 2860 * SCMD_INQUIRY | |
| 2861 * SCMD_TEST_UNIT_READY | |
| 2862 * SCMD_START_STOP | |
| 2863 * SCMD_READ_CAPACITY | |
| 2864 * SCMD_REQUEST_SENSE | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
2865 * SCMD_LOG_SENSE_G1 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
2866 * SCMD_LOG_SELECT_G1 |
| 1258 | 2867 * SCMD_MODE_SENSE (specific pages) |
| 2868 * SCMD_MODE_SENSE_G1 (specific pages) | |
| 2869 * SCMD_MODE_SELECT (specific pages) | |
| 2870 * SCMD_MODE_SELECT_G1 (specific pages) | |
| 2871 * SCMD_SYNCHRONIZE_CACHE | |
| 2872 * SCMD_SYNCHRONIZE_CACHE_G1 | |
| 2873 * SCMD_READ | |
| 2874 * SCMD_READ_G1 | |
| 2875 * SCMD_READ_G4 | |
| 2876 * SCMD_READ_G5 | |
| 2877 * SCMD_WRITE | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
2878 * SCMD_WRITE_BUFFER |
| 1258 | 2879 * SCMD_WRITE_G1 |
| 2880 * SCMD_WRITE_G4 | |
| 2881 * SCMD_WRITE_G5 | |
| 2882 * SCMD_SEEK (noop) | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
2883 * SCMD_SDIAG |
| 1258 | 2884 * |
| 2885 * All other commands are rejected as unsupported. | |
| 2886 * | |
| 2887 * Returns: | |
| 2888 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver | |
| 2889 * for execution. | |
| 2890 * TRAN_BADPKT if cmd was directed to invalid address. | |
| 2891 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including | |
| 2892 * unexpected removal of a device or some other unspecified error. | |
| 2893 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA | |
| 2894 * framework was busy performing some other operation(s). | |
| 2895 * | |
| 2896 */ | |
| 2897 static int | |
| 2898 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 2899 { | |
| 2900 sata_hba_inst_t *sata_hba_inst = | |
| 2901 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2902 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2903 sata_drive_info_t *sdinfo; | |
| 2904 struct buf *bp; | |
| 2905 int cport; | |
| 2906 int rval; | |
| 2907 | |
| 2908 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2909 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); | |
| 2910 | |
| 2911 ASSERT(spx != NULL && | |
| 2912 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); | |
| 2913 | |
| 2914 cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 2915 | |
| 2916 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2917 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2918 &spx->txlt_sata_pkt->satapkt_device); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2919 if (sdinfo == NULL || |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2920 SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean == |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2921 B_FALSE) { |
| 1258 | 2922 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2923 pkt->pkt_reason = CMD_DEV_GONE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2924 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2925 * The sd target driver is checking CMD_DEV_GONE pkt_reason |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2926 * only in callback function (for normal requests) and |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2927 * in the dump code path. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2928 * So, if the callback is available, we need to do |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2929 * the callback rather than returning TRAN_FATAL_ERROR here. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2930 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2931 if (pkt->pkt_comp != NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2932 /* scsi callback required */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2933 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2934 (task_func_t *)pkt->pkt_comp, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2935 (void *)pkt, TQ_SLEEP) == NULL) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2936 /* Scheduling the callback failed */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2937 return (TRAN_BUSY); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2938 return (TRAN_ACCEPT); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2939 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
2940 /* No callback available */ |
| 1258 | 2941 return (TRAN_FATAL_ERROR); |
| 2942 } | |
| 2943 | |
| 2944 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 2945 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2946 rval = sata_txlt_atapi(spx); | |
| 2947 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2948 "sata_scsi_start atapi: rval %d\n", rval); | |
| 2949 return (rval); | |
| 2950 } | |
| 2951 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2952 | |
| 2953 /* ATA Disk commands processing starts here */ | |
| 2954 | |
| 2955 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 2956 | |
| 2957 switch (pkt->pkt_cdbp[0]) { | |
| 2958 | |
| 2959 case SCMD_INQUIRY: | |
| 2960 /* Mapped to identify device */ | |
| 2961 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2962 bp_mapin(bp); | |
| 2963 rval = sata_txlt_inquiry(spx); | |
| 2964 break; | |
| 2965 | |
| 2966 case SCMD_TEST_UNIT_READY: | |
| 2967 /* | |
| 2968 * SAT "SATA to ATA Translation" doc specifies translation | |
| 2969 * to ATA CHECK POWER MODE. | |
| 2970 */ | |
| 2971 rval = sata_txlt_test_unit_ready(spx); | |
| 2972 break; | |
| 2973 | |
| 2974 case SCMD_START_STOP: | |
| 2975 /* Mapping depends on the command */ | |
| 2976 rval = sata_txlt_start_stop_unit(spx); | |
| 2977 break; | |
| 2978 | |
| 2979 case SCMD_READ_CAPACITY: | |
| 2980 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2981 bp_mapin(bp); | |
| 2982 rval = sata_txlt_read_capacity(spx); | |
| 2983 break; | |
| 2984 | |
| 2985 case SCMD_REQUEST_SENSE: | |
| 2986 /* | |
| 2987 * Always No Sense, since we force ARQ | |
| 2988 */ | |
| 2989 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2990 bp_mapin(bp); | |
| 2991 rval = sata_txlt_request_sense(spx); | |
| 2992 break; | |
| 2993 | |
| 2994 case SCMD_LOG_SENSE_G1: | |
| 2995 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2996 bp_mapin(bp); | |
| 2997 rval = sata_txlt_log_sense(spx); | |
| 2998 break; | |
| 2999 | |
| 3000 case SCMD_LOG_SELECT_G1: | |
| 3001 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 3002 bp_mapin(bp); | |
| 3003 rval = sata_txlt_log_select(spx); | |
| 3004 break; | |
| 3005 | |
| 3006 case SCMD_MODE_SENSE: | |
| 3007 case SCMD_MODE_SENSE_G1: | |
| 3008 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 3009 bp_mapin(bp); | |
| 3010 rval = sata_txlt_mode_sense(spx); | |
| 3011 break; | |
| 3012 | |
| 3013 | |
| 3014 case SCMD_MODE_SELECT: | |
| 3015 case SCMD_MODE_SELECT_G1: | |
| 3016 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 3017 bp_mapin(bp); | |
| 3018 rval = sata_txlt_mode_select(spx); | |
| 3019 break; | |
| 3020 | |
| 3021 case SCMD_SYNCHRONIZE_CACHE: | |
| 3022 case SCMD_SYNCHRONIZE_CACHE_G1: | |
| 3023 rval = sata_txlt_synchronize_cache(spx); | |
| 3024 break; | |
| 3025 | |
| 3026 case SCMD_READ: | |
| 3027 case SCMD_READ_G1: | |
| 3028 case SCMD_READ_G4: | |
| 3029 case SCMD_READ_G5: | |
| 3030 rval = sata_txlt_read(spx); | |
| 3031 break; | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
3032 case SCMD_WRITE_BUFFER: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
3033 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
3034 bp_mapin(bp); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
3035 rval = sata_txlt_write_buffer(spx); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
3036 break; |
| 1258 | 3037 |
| 3038 case SCMD_WRITE: | |
| 3039 case SCMD_WRITE_G1: | |
| 3040 case SCMD_WRITE_G4: | |
| 3041 case SCMD_WRITE_G5: | |
| 3042 rval = sata_txlt_write(spx); | |
| 3043 break; | |
| 3044 | |
| 3045 case SCMD_SEEK: | |
| 3046 rval = sata_txlt_nodata_cmd_immediate(spx); | |
| 3047 break; | |
| 3048 | |
| 3049 /* Other cases will be filed later */ | |
| 3050 /* postponed until phase 2 of the development */ | |
| 3051 default: | |
| 3052 rval = sata_txlt_invalid_command(spx); | |
| 3053 break; | |
| 3054 } | |
| 3055 | |
| 3056 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3057 "sata_scsi_start: rval %d\n", rval); | |
| 3058 | |
| 3059 return (rval); | |
| 3060 } | |
| 3061 | |
| 3062 /* | |
| 3063 * Implementation of scsi tran_abort. | |
| 3064 * Abort specific pkt or all packets. | |
| 3065 * | |
| 3066 * Returns 1 if one or more packets were aborted, returns 0 otherwise | |
| 3067 * | |
| 3068 * May be called from an interrupt level. | |
| 3069 */ | |
| 3070 static int | |
| 3071 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) | |
| 3072 { | |
| 3073 sata_hba_inst_t *sata_hba_inst = | |
| 3074 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3075 sata_device_t sata_device; | |
| 3076 sata_pkt_t *sata_pkt; | |
| 3077 | |
| 3078 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3079 "sata_scsi_abort: %s at target: 0x%x\n", | |
| 3080 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); | |
| 3081 | |
| 3082 /* Validate address */ | |
| 3083 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) | |
| 3084 /* Invalid address */ | |
| 3085 return (0); | |
| 3086 | |
| 3087 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3088 sata_device.satadev_addr.cport))); | |
| 3089 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 3090 /* invalid address */ | |
| 3091 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3092 sata_device.satadev_addr.cport))); | |
| 3093 return (0); | |
| 3094 } | |
| 3095 if (scsi_pkt == NULL) { | |
| 3096 /* | |
| 3097 * Abort all packets. | |
| 3098 * Although we do not have specific packet, we still need | |
| 3099 * dummy packet structure to pass device address to HBA. | |
| 3100 * Allocate one, without sleeping. Fail if pkt cannot be | |
| 3101 * allocated. | |
| 3102 */ | |
| 3103 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); | |
| 3104 if (sata_pkt == NULL) { | |
| 3105 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3106 sata_device.satadev_addr.cport))); | |
| 3107 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " | |
| 3108 "could not allocate sata_pkt")); | |
| 3109 return (0); | |
| 3110 } | |
| 3111 sata_pkt->satapkt_rev = SATA_PKT_REV; | |
| 3112 sata_pkt->satapkt_device = sata_device; | |
| 3113 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; | |
| 3114 } else { | |
| 3115 if (scsi_pkt->pkt_ha_private == NULL) { | |
| 3116 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3117 sata_device.satadev_addr.cport))); | |
| 3118 return (0); /* Bad scsi pkt */ | |
| 3119 } | |
| 3120 /* extract pointer to sata pkt */ | |
| 3121 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> | |
| 3122 txlt_sata_pkt; | |
| 3123 } | |
| 3124 | |
| 3125 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3126 sata_device.satadev_addr.cport))); | |
| 3127 /* Send abort request to HBA */ | |
| 3128 if ((*SATA_ABORT_FUNC(sata_hba_inst)) | |
| 3129 (SATA_DIP(sata_hba_inst), sata_pkt, | |
| 3130 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == | |
| 3131 SATA_SUCCESS) { | |
| 3132 if (scsi_pkt == NULL) | |
| 3133 kmem_free(sata_pkt, sizeof (sata_pkt_t)); | |
| 3134 /* Success */ | |
| 3135 return (1); | |
| 3136 } | |
| 3137 /* Else, something did not go right */ | |
| 3138 if (scsi_pkt == NULL) | |
| 3139 kmem_free(sata_pkt, sizeof (sata_pkt_t)); | |
| 3140 /* Failure */ | |
| 3141 return (0); | |
| 3142 } | |
| 3143 | |
| 3144 | |
| 3145 /* | |
| 3146 * Implementation os scsi tran_reset. | |
| 3147 * RESET_ALL request is translated into port reset. | |
| 3148 * RESET_TARGET requests is translated into a device reset, | |
| 3149 * RESET_LUN request is accepted only for LUN 0 and translated into | |
| 3150 * device reset. | |
| 3151 * The target reset should cause all HBA active and queued packets to | |
| 3152 * be terminated and returned with pkt reason SATA_PKT_RESET prior to | |
| 3153 * the return. HBA should report reset event for the device. | |
| 3154 * | |
| 3155 * Returns 1 upon success, 0 upon failure. | |
| 3156 */ | |
| 3157 static int | |
| 3158 sata_scsi_reset(struct scsi_address *ap, int level) | |
| 3159 { | |
| 3160 sata_hba_inst_t *sata_hba_inst = | |
| 3161 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3162 sata_device_t sata_device; | |
| 3163 int val; | |
| 3164 | |
| 3165 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3166 "sata_scsi_reset: level %d target: 0x%x\n", | |
| 3167 level, ap->a_target); | |
| 3168 | |
| 3169 /* Validate address */ | |
| 3170 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); | |
| 3171 if (val == -1) | |
| 3172 /* Invalid address */ | |
| 3173 return (0); | |
| 3174 | |
| 3175 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3176 sata_device.satadev_addr.cport))); | |
| 3177 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 3178 /* invalid address */ | |
| 3179 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3180 sata_device.satadev_addr.cport))); | |
| 3181 return (0); | |
| 3182 } | |
| 3183 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3184 sata_device.satadev_addr.cport))); | |
| 3185 if (level == RESET_ALL) { | |
| 3186 /* port reset - cport only */ | |
| 3187 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 3188 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 3189 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) | |
| 3190 return (1); | |
| 3191 else | |
| 3192 return (0); | |
| 3193 | |
| 3194 } else if (val == 0 && | |
| 3195 (level == RESET_TARGET || level == RESET_LUN)) { | |
| 3196 /* reset device (device attached) */ | |
| 3197 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 3198 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) | |
| 3199 return (1); | |
| 3200 else | |
| 3201 return (0); | |
| 3202 } | |
| 3203 return (0); | |
| 3204 } | |
| 3205 | |
| 3206 | |
| 3207 /* | |
| 3208 * Implementation of scsi tran_getcap (get transport/device capabilities). | |
| 3209 * Supported capabilities: | |
| 3210 * auto-rqsense (always supported) | |
| 3211 * tagged-qing (supported if HBA supports it) | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3212 * untagged-qing (could be supported if disk supports it, but because |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3213 * caching behavior allowing untagged queuing actually |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3214 * results in reduced performance. sd tries to throttle |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3215 * back to only 3 outstanding commands, which may |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3216 * work for real SCSI disks, but with read ahead |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3217 * caching, having more than 1 outstanding command |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3218 * results in cache thrashing.) |
| 1258 | 3219 * dma_max |
| 3220 * interconnect-type (INTERCONNECT_SATA) | |
| 3221 * | |
| 3222 * Request for other capabilities is rejected as unsupported. | |
| 3223 * | |
| 3224 * Returns supported capability value, or -1 if capability is unsuppported or | |
| 3225 * the address is invalid (no device). | |
| 3226 */ | |
| 3227 | |
| 3228 static int | |
| 3229 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) | |
| 3230 { | |
| 3231 | |
| 3232 sata_hba_inst_t *sata_hba_inst = | |
| 3233 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3234 sata_device_t sata_device; | |
| 3235 sata_drive_info_t *sdinfo; | |
| 3236 ddi_dma_attr_t adj_dma_attr; | |
| 3237 int rval; | |
| 3238 | |
| 3239 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3240 "sata_scsi_getcap: target: 0x%x, cap: %s\n", | |
| 3241 ap->a_target, cap); | |
| 3242 | |
| 3243 /* | |
| 3244 * We want to process the capabilities on per port granularity. | |
| 3245 * So, we are specifically restricting ourselves to whom != 0 | |
| 3246 * to exclude the controller wide handling. | |
| 3247 */ | |
| 3248 if (cap == NULL || whom == 0) | |
| 3249 return (-1); | |
| 3250 | |
| 3251 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { | |
| 3252 /* Invalid address */ | |
| 3253 return (-1); | |
| 3254 } | |
| 3255 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3256 sata_device.satadev_addr.cport))); | |
| 3257 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == | |
| 3258 NULL) { | |
| 3259 /* invalid address */ | |
| 3260 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3261 sata_device.satadev_addr.cport))); | |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3262 return (-1); |
| 1258 | 3263 } |
| 3264 | |
| 3265 switch (scsi_hba_lookup_capstr(cap)) { | |
| 3266 case SCSI_CAP_ARQ: | |
| 3267 rval = 1; /* ARQ supported, turned on */ | |
| 3268 break; | |
| 3269 | |
| 3270 case SCSI_CAP_SECTOR_SIZE: | |
| 3271 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) | |
| 3272 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ | |
| 3273 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) | |
| 3274 rval = SATA_ATAPI_SECTOR_SIZE; | |
| 3275 else rval = -1; | |
| 3276 break; | |
| 3277 | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3278 /* |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3279 * untagged queuing cause a performance inversion because of |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3280 * the way sd operates. Because of this reason we do not |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3281 * use it when available. |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3282 */ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3283 case SCSI_CAP_UNTAGGED_QING: |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3284 if (sdinfo->satadrv_features_enabled & |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3285 SATA_DEV_F_E_UNTAGGED_QING) |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3286 rval = 1; /* Untagged queuing available */ |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3287 else |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3288 rval = -1; /* Untagged queuing not available */ |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3289 break; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3290 |
| 1258 | 3291 case SCSI_CAP_TAGGED_QING: |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3292 if (sdinfo->satadrv_features_enabled & SATA_DEV_F_E_TAGGED_QING) |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3293 rval = 1; /* Tagged queuing available */ |
| 1258 | 3294 else |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3295 rval = -1; /* Tagged queuing not available */ |
| 1258 | 3296 break; |
| 3297 | |
| 3298 case SCSI_CAP_DMA_MAX: | |
| 3299 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), | |
| 3300 &adj_dma_attr); | |
| 3301 rval = (int)adj_dma_attr.dma_attr_maxxfer; | |
| 3302 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ | |
| 3303 break; | |
| 3304 | |
| 3305 case SCSI_CAP_INTERCONNECT_TYPE: | |
| 3306 rval = INTERCONNECT_SATA; /* SATA interconnect type */ | |
| 3307 break; | |
| 3308 | |
| 3309 default: | |
| 3310 rval = -1; | |
| 3311 break; | |
| 3312 } | |
| 3313 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3314 sata_device.satadev_addr.cport))); | |
| 3315 return (rval); | |
| 3316 } | |
| 3317 | |
| 3318 /* | |
| 3319 * Implementation of scsi tran_setcap | |
| 3320 */ | |
| 3321 static int | |
| 3322 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) | |
| 3323 { | |
| 3324 sata_hba_inst_t *sata_hba_inst = | |
| 3325 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3326 sata_device_t sata_device; | |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3327 sata_drive_info_t *sdinfo; |
| 1258 | 3328 int rval; |
| 3329 | |
| 3330 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3331 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); | |
| 3332 | |
| 3333 /* | |
| 3334 * We want to process the capabilities on per port granularity. | |
| 3335 * So, we are specifically restricting ourselves to whom != 0 | |
| 3336 * to exclude the controller wide handling. | |
| 3337 */ | |
| 3338 if (cap == NULL || whom == 0) { | |
| 3339 return (-1); | |
| 3340 } | |
| 3341 | |
| 3342 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { | |
| 3343 /* Invalid address */ | |
| 3344 return (-1); | |
| 3345 } | |
| 3346 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3347 sata_device.satadev_addr.cport))); | |
| 4582 | 3348 if ((sdinfo = sata_get_device_info(sata_hba_inst, |
| 3349 &sata_device)) == NULL) { | |
| 1258 | 3350 /* invalid address */ |
| 3351 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3352 sata_device.satadev_addr.cport))); | |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3353 return (-1); |
| 1258 | 3354 } |
| 3355 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3356 sata_device.satadev_addr.cport))); | |
| 3357 | |
| 3358 switch (scsi_hba_lookup_capstr(cap)) { | |
| 3359 case SCSI_CAP_ARQ: | |
| 3360 case SCSI_CAP_SECTOR_SIZE: | |
| 3361 case SCSI_CAP_DMA_MAX: | |
| 3362 case SCSI_CAP_INTERCONNECT_TYPE: | |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3363 rval = 0; |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3364 break; |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3365 case SCSI_CAP_UNTAGGED_QING: |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3366 if (SATA_QDEPTH(sata_hba_inst) > 1) { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3367 rval = 1; |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3368 if (value == 1) { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3369 sdinfo->satadrv_features_enabled |= |
| 4582 | 3370 SATA_DEV_F_E_UNTAGGED_QING; |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3371 } else if (value == 0) { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3372 sdinfo->satadrv_features_enabled &= |
| 4582 | 3373 ~SATA_DEV_F_E_UNTAGGED_QING; |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3374 } else { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3375 rval = -1; |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3376 } |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3377 } else { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3378 rval = 0; |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3379 } |
| 1258 | 3380 break; |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3381 case SCSI_CAP_TAGGED_QING: |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3382 /* This can TCQ or NCQ */ |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3383 if (sata_func_enable & SATA_ENABLE_QUEUING && |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3384 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3385 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3386 (sata_func_enable & SATA_ENABLE_NCQ && |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3387 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3388 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ))) { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3389 rval = 1; |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3390 if (value == 1) { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3391 sdinfo->satadrv_features_enabled |= |
| 4582 | 3392 SATA_DEV_F_E_TAGGED_QING; |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3393 } else if (value == 0) { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3394 sdinfo->satadrv_features_enabled &= |
| 4582 | 3395 ~SATA_DEV_F_E_TAGGED_QING; |
|
3821
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3396 } else { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3397 rval = -1; |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3398 } |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3399 } else { |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3400 rval = 0; |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3401 } |
|
2c5d11a65307
6498799 marvell88sx driver/hardware wedges when doing multiple concurrent tagged commands
ls24207
parents:
3116
diff
changeset
|
3402 break; |
| 1258 | 3403 default: |
| 3404 rval = -1; | |
| 3405 break; | |
| 3406 } | |
| 3407 return (rval); | |
| 3408 } | |
| 3409 | |
| 3410 /* | |
| 3411 * Implementations of scsi tran_destroy_pkt. | |
| 3412 * Free resources allocated by sata_scsi_init_pkt() | |
| 3413 */ | |
| 3414 static void | |
| 3415 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3416 { | |
| 3417 sata_pkt_txlate_t *spx; | |
| 3418 | |
| 3419 ASSERT(pkt != NULL); | |
| 3420 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 3421 | |
| 3422 if (spx->txlt_buf_dma_handle != NULL) { | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3423 if (spx->txlt_tmp_buf != NULL) { |
| 4582 | 3424 ASSERT(spx->txlt_tmp_buf_handle != 0); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3425 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3426 * Intermediate DMA buffer was allocated. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3427 * Free allocated buffer and associated access handle. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3428 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3429 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3430 spx->txlt_tmp_buf = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3431 } |
| 1258 | 3432 /* |
| 3433 * Free DMA resources - cookies and handles | |
| 3434 */ | |
| 3435 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3436 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3437 (void) kmem_free(spx->txlt_dma_cookie_list, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3438 spx->txlt_dma_cookie_list_len * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3439 sizeof (ddi_dma_cookie_t)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3440 spx->txlt_dma_cookie_list = NULL; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3441 } |
| 1258 | 3442 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); |
| 3443 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 3444 } | |
| 3445 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 3446 sata_pkt_free(spx); | |
| 3447 | |
| 3448 scsi_hba_pkt_free(ap, pkt); | |
| 3449 } | |
| 3450 | |
| 3451 /* | |
| 3452 * Implementation of scsi tran_dmafree. | |
| 3453 * Free DMA resources allocated by sata_scsi_init_pkt() | |
| 3454 */ | |
| 3455 | |
| 3456 static void | |
| 3457 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3458 { | |
| 3459 #ifndef __lock_lint | |
| 3460 _NOTE(ARGUNUSED(ap)) | |
| 3461 #endif | |
| 3462 sata_pkt_txlate_t *spx; | |
| 3463 | |
| 3464 ASSERT(pkt != NULL); | |
| 3465 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 3466 | |
| 3467 if (spx->txlt_buf_dma_handle != NULL) { | |
| 3468 /* | |
| 3469 * Free DMA resources - cookies and handles | |
| 3470 */ | |
| 3471 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3472 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3473 (void) kmem_free(spx->txlt_dma_cookie_list, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3474 spx->txlt_dma_cookie_list_len * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3475 sizeof (ddi_dma_cookie_t)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3476 spx->txlt_dma_cookie_list = NULL; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3477 } |
| 1258 | 3478 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); |
| 3479 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 3480 } | |
| 3481 } | |
| 3482 | |
| 3483 /* | |
| 3484 * Implementation of scsi tran_sync_pkt. | |
| 3485 * | |
| 3486 * The assumption below is that pkt is unique - there is no need to check ap | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3487 * |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3488 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3489 * into/from the real buffer. |
| 1258 | 3490 */ |
| 3491 static void | |
| 3492 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3493 { | |
| 3494 #ifndef __lock_lint | |
| 3495 _NOTE(ARGUNUSED(ap)) | |
| 3496 #endif | |
| 3497 int rval; | |
| 3498 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3499 struct buf *bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3500 int direction; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3501 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3502 ASSERT(spx != NULL); |
| 1258 | 3503 if (spx->txlt_buf_dma_handle != NULL) { |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3504 direction = spx->txlt_sata_pkt-> |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3505 satapkt_cmd.satacmd_flags.sata_data_direction; |
| 1258 | 3506 if (spx->txlt_sata_pkt != NULL && |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3507 direction != SATA_DIR_NODATA_XFER) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3508 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3509 /* Intermediate DMA buffer used */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3510 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3511 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3512 if (direction & SATA_DIR_WRITE) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3513 bcopy(bp->b_un.b_addr, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3514 spx->txlt_tmp_buf, bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3515 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3516 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3517 /* Sync the buffer for device or for CPU */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3518 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3519 (direction & SATA_DIR_WRITE) ? |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3520 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3521 ASSERT(rval == DDI_SUCCESS); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3522 if (spx->txlt_tmp_buf != NULL && |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3523 !(direction & SATA_DIR_WRITE)) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3524 /* Intermediate DMA buffer used for read */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3525 bcopy(spx->txlt_tmp_buf, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3526 bp->b_un.b_addr, bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3527 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3528 |
| 1258 | 3529 } |
| 3530 } | |
| 3531 } | |
| 3532 | |
| 3533 | |
| 3534 | |
| 3535 /* ******************* SATA - SCSI Translation functions **************** */ | |
| 3536 /* | |
| 3537 * SCSI to SATA pkt and command translation and SATA to SCSI status/error | |
| 3538 * translation. | |
| 3539 */ | |
| 3540 | |
| 3541 /* | |
| 3542 * Checks if a device exists and can be access and translates common | |
| 3543 * scsi_pkt data to sata_pkt data. | |
| 3544 * | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3545 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3546 * sata_pkt was set-up. |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3547 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3548 * exist and pkt_comp callback was scheduled. |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3549 * Returns other TRAN_XXXXX values when error occured and command should be |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3550 * rejected with the returned TRAN_XXXXX value. |
| 1258 | 3551 * |
| 3552 * This function should be called with port mutex held. | |
| 3553 */ | |
| 3554 static int | |
| 3555 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx) | |
| 3556 { | |
| 3557 sata_drive_info_t *sdinfo; | |
| 3558 sata_device_t sata_device; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3559 const struct sata_cmd_flags sata_initial_cmd_flags = { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3560 SATA_DIR_NODATA_XFER, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3561 /* all other values to 0/FALSE */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3562 }; |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3563 /* |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3564 * Pkt_reason has to be set if the pkt_comp callback is invoked, |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3565 * and that implies TRAN_ACCEPT return value. Any other returned value |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3566 * indicates that the scsi packet was not accepted (the reason will not |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3567 * be checked by the scsi traget driver). |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3568 * To make debugging easier, we set pkt_reason to know value here. |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3569 * It may be changed later when different completion reason is |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3570 * determined. |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3571 */ |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3572 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; |
| 1258 | 3573 |
| 3574 /* Validate address */ | |
| 3575 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, | |
| 3576 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { | |
| 3577 | |
| 3578 case -1: | |
| 3579 /* Invalid address or invalid device type */ | |
| 3580 return (TRAN_BADPKT); | |
| 3581 case 1: | |
| 3582 /* valid address but no device - it has disappeared ? */ | |
| 3583 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3584 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3585 * The sd target driver is checking CMD_DEV_GONE pkt_reason |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3586 * only in callback function (for normal requests) and |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3587 * in the dump code path. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3588 * So, if the callback is available, we need to do |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3589 * the callback rather than returning TRAN_FATAL_ERROR here. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3590 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3591 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3592 /* scsi callback required */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3593 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3594 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3595 (void *)spx->txlt_scsi_pkt, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3596 TQ_SLEEP) == NULL) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3597 /* Scheduling the callback failed */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3598 return (TRAN_BUSY); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3599 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3600 return (TRAN_ACCEPT); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3601 } |
| 1258 | 3602 return (TRAN_FATAL_ERROR); |
| 3603 default: | |
| 3604 /* all OK */ | |
| 3605 break; | |
| 3606 } | |
| 3607 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 3608 &spx->txlt_sata_pkt->satapkt_device); | |
| 3609 | |
| 3610 /* | |
| 3611 * If device is in reset condition, reject the packet with | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3612 * TRAN_BUSY, unless: |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3613 * 1. system is panicking (dumping) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3614 * In such case only one thread is running and there is no way to |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3615 * process reset. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3616 * 2. cfgadm operation is is progress (internal APCTL lock is set) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3617 * Some cfgadm operations involve drive commands, so reset condition |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3618 * needs to be ignored for IOCTL operations. |
| 1258 | 3619 */ |
|
3116
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
3620 if ((sdinfo->satadrv_event_flags & |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3621 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3622 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3623 if (!ddi_in_panic() && |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3624 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3625 sata_device.satadev_addr.cport) & |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3626 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3627 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3628 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3629 "sata_scsi_start: rejecting command because " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3630 "of device reset state\n", NULL); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3631 return (TRAN_BUSY); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3632 } |
| 1258 | 3633 } |
| 3634 | |
| 3635 /* | |
| 3636 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by | |
| 3637 * sata_scsi_pkt_init() because pkt init had to work also with | |
| 3638 * non-existing devices. | |
| 3639 * Now we know that the packet was set-up for a real device, so its | |
| 3640 * type is known. | |
| 3641 */ | |
| 3642 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; | |
| 3643 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3644 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3645 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3646 sata_device.satadev_addr.cport)->cport_event_flags & |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3647 SATA_APCTL_LOCK_PORT_BUSY) != 0) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3648 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3649 sata_ignore_dev_reset = B_TRUE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3650 } |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3651 /* |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3652 * At this point the generic translation routine determined that the |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3653 * scsi packet should be accepted. Packet completion reason may be |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3654 * changed later when a different completion reason is determined. |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3655 */ |
| 1258 | 3656 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; |
| 3657 | |
| 3658 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { | |
| 3659 /* Synchronous execution */ | |
| 3660 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | | |
| 3661 SATA_OPMODE_POLLING; | |
|
3023
87cffc3df3bf
6485154 crash dumps for drivers using the sata framework fail
ls24207
parents:
2960
diff
changeset
|
3662 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. |
|
87cffc3df3bf
6485154 crash dumps for drivers using the sata framework fail
ls24207
parents:
2960
diff
changeset
|
3663 sata_ignore_dev_reset = ddi_in_panic(); |
| 1258 | 3664 } else { |
| 3665 /* Asynchronous execution */ | |
| 3666 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | | |
| 3667 SATA_OPMODE_INTERRUPTS; | |
| 3668 } | |
| 3669 /* Convert queuing information */ | |
| 3670 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3671 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3672 B_TRUE; |
| 1258 | 3673 else if (spx->txlt_scsi_pkt->pkt_flags & |
| 3674 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3675 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3676 B_TRUE; |
| 1258 | 3677 |
| 3678 /* Always limit pkt time */ | |
| 3679 if (spx->txlt_scsi_pkt->pkt_time == 0) | |
| 3680 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; | |
| 3681 else | |
| 3682 /* Pass on scsi_pkt time */ | |
| 3683 spx->txlt_sata_pkt->satapkt_time = | |
| 3684 spx->txlt_scsi_pkt->pkt_time; | |
| 3685 | |
| 3686 return (TRAN_ACCEPT); | |
| 3687 } | |
| 3688 | |
| 3689 | |
| 3690 /* | |
| 3691 * Translate ATA(ATAPI) Identify (Packet) Device data to SCSI Inquiry data. | |
| 3692 * SATA Identify Device data has to be valid in sata_rive_info. | |
| 3693 * Buffer has to accomodate the inquiry length (36 bytes). | |
| 3694 * | |
| 3695 * This function should be called with a port mutex held. | |
| 3696 */ | |
| 3697 static void | |
| 3698 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, | |
| 3699 sata_drive_info_t *sdinfo, uint8_t *buf) | |
| 3700 { | |
| 3701 | |
| 3702 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; | |
| 3703 struct sata_id *sid = &sdinfo->satadrv_id; | |
| 3704 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3705 /* Start with a nice clean slate */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3706 bzero((void *)inq, sizeof (struct scsi_inquiry)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3707 |
| 1258 | 3708 /* Rely on the dev_type for setting paripheral qualifier */ |
| 3709 /* Does DTYPE_RODIRECT apply to CD/DVD R/W devices ? */ | |
| 3710 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 3711 DTYPE_DIRECT : DTYPE_RODIRECT; | |
| 3712 | |
| 3713 inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0; | |
| 3714 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ | |
| 3715 inq->inq_iso = 0; /* ISO version */ | |
| 3716 inq->inq_ecma = 0; /* ECMA version */ | |
| 3717 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ | |
| 3718 inq->inq_aenc = 0; /* Async event notification cap. */ | |
| 3719 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg ??? */ | |
| 3720 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ | |
| 3721 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ | |
| 3722 inq->inq_len = 31; /* Additional length */ | |
| 3723 inq->inq_dualp = 0; /* dual port device - NO */ | |
| 3724 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ | |
| 3725 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ | |
| 3726 inq->inq_linked = 0; /* Supports linked commands - NO */ | |
| 3727 /* | |
| 3728 * Queuing support - controller has to | |
| 3729 * support some sort of command queuing. | |
| 3730 */ | |
| 3731 if (SATA_QDEPTH(sata_hba_inst) > 1) | |
| 3732 inq->inq_cmdque = 1; /* Supports command queueing - YES */ | |
| 3733 else | |
| 3734 inq->inq_cmdque = 0; /* Supports command queueing - NO */ | |
| 3735 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ | |
| 3736 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ | |
| 3737 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ | |
| 3738 | |
| 4582 | 3739 #ifdef _LITTLE_ENDIAN |
| 1258 | 3740 /* Swap text fields to match SCSI format */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3741 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3742 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3743 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3744 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3745 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3746 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ |
| 4582 | 3747 #else /* _LITTLE_ENDIAN */ |
| 3748 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ | |
| 3749 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3750 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3751 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3752 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3753 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ |
| 4582 | 3754 #endif /* _LITTLE_ENDIAN */ |
| 1258 | 3755 } |
| 3756 | |
| 3757 | |
| 3758 /* | |
| 3759 * Scsi response set up for invalid command (command not supported) | |
| 3760 * | |
| 3761 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3762 */ | |
| 3763 static int | |
| 3764 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) | |
| 3765 { | |
| 3766 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3767 struct scsi_extended_sense *sense; | |
| 3768 | |
| 3769 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3770 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3771 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3772 | |
| 3773 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3774 | |
| 3775 sense = sata_arq_sense(spx); | |
| 3776 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3777 sense->es_add_code = SD_SCSI_INVALID_COMMAND_CODE; | |
| 3778 | |
| 3779 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3780 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3781 | |
| 3782 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3783 scsipkt->pkt_comp != NULL) | |
| 3784 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3785 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3786 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3787 (void *)spx->txlt_scsi_pkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3788 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3789 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3790 return (TRAN_BUSY); |
| 1258 | 3791 return (TRAN_ACCEPT); |
| 3792 } | |
| 3793 | |
| 3794 /* | |
| 3795 * Scsi response setup for | |
| 3796 * emulated non-data command that requires no action/return data | |
| 3797 * | |
| 3798 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3799 */ | |
| 3800 static int | |
| 3801 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) | |
| 3802 { | |
| 3803 int rval; | |
| 3804 | |
| 3805 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3806 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3807 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3808 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 3809 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 3810 return (rval); | |
| 3811 } | |
| 3812 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3813 | |
| 3814 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3815 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3816 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; | |
| 3817 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; | |
| 3818 | |
| 3819 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3820 "Scsi_pkt completion reason %x\n", | |
| 3821 spx->txlt_scsi_pkt->pkt_reason); | |
| 3822 | |
| 3823 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3824 spx->txlt_scsi_pkt->pkt_comp != NULL) | |
| 3825 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3826 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3827 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3828 (void *)spx->txlt_scsi_pkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3829 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3830 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3831 return (TRAN_BUSY); |
| 1258 | 3832 return (TRAN_ACCEPT); |
| 3833 } | |
| 3834 | |
| 3835 | |
| 3836 /* | |
| 3837 * SATA translate command: Inquiry / Identify Device | |
| 3838 * Use cached Identify Device data for now, rather then issuing actual | |
| 3839 * Device Identify cmd request. If device is detached and re-attached, | |
| 3840 * asynchromous event processing should fetch and refresh Identify Device | |
| 3841 * data. | |
| 3842 * Two VPD pages are supported now: | |
| 3843 * Vital Product Data page | |
| 3844 * Unit Serial Number page | |
| 3845 * | |
| 3846 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3847 */ | |
| 3848 | |
| 3849 #define EVPD 1 /* Extended Vital Product Data flag */ | |
| 3850 #define CMDDT 2 /* Command Support Data - Obsolete */ | |
| 3851 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ | |
| 3852 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ | |
| 3853 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ | |
| 3854 | |
| 3855 static int | |
| 3856 sata_txlt_inquiry(sata_pkt_txlate_t *spx) | |
| 3857 { | |
| 3858 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3859 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 3860 sata_drive_info_t *sdinfo; | |
| 3861 struct scsi_extended_sense *sense; | |
| 3862 int count; | |
| 3863 uint8_t *p; | |
| 3864 int i, j; | |
| 3865 uint8_t page_buf[0xff]; /* Max length */ | |
| 3866 int rval; | |
| 3867 | |
| 3868 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3869 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3870 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
3871 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 3872 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 3873 return (rval); | |
| 3874 } | |
| 3875 | |
| 3876 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 3877 &spx->txlt_sata_pkt->satapkt_device); | |
| 3878 | |
| 3879 ASSERT(sdinfo != NULL); | |
| 3880 | |
| 3881 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3882 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4582 | 3883 STATE_SENT_CMD | STATE_GOT_STATUS; |
| 1258 | 3884 |
| 3885 /* Reject not supported request */ | |
| 3886 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ | |
| 3887 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3888 sense = sata_arq_sense(spx); | |
| 3889 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3890 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3891 goto done; | |
| 3892 } | |
| 3893 | |
| 3894 /* Valid Inquiry request */ | |
| 3895 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3896 | |
| 3897 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 3898 | |
| 3899 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { | |
| 3900 /* Standard Inquiry Data request */ | |
| 3901 struct scsi_inquiry inq; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3902 unsigned int bufsize; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3903 |
| 1258 | 3904 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, |
| 3905 sdinfo, (uint8_t *)&inq); | |
| 3906 /* Copy no more than requested */ | |
| 3907 count = MIN(bp->b_bcount, | |
| 3908 sizeof (struct scsi_inquiry)); | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3909 bufsize = scsipkt->pkt_cdbp[4]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3910 bufsize |= scsipkt->pkt_cdbp[3] << 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3911 count = MIN(count, bufsize); |
| 1258 | 3912 bcopy(&inq, bp->b_un.b_addr, count); |
| 3913 | |
| 3914 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3915 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3916 bufsize - count : 0; |
| 1258 | 3917 } else { |
| 3918 /* | |
| 3919 * peripheral_qualifier = 0; | |
| 3920 * | |
| 3921 * We are dealing only with HD and will be | |
| 3922 * dealing with CD/DVD devices soon | |
| 3923 */ | |
| 3924 uint8_t peripheral_device_type = | |
| 3925 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 4582 | 3926 DTYPE_DIRECT : DTYPE_RODIRECT; |
| 1258 | 3927 |
| 3928 switch ((uint_t)scsipkt->pkt_cdbp[2]) { | |
| 3929 case INQUIRY_SUP_VPD_PAGE: | |
| 3930 /* | |
| 3931 * Request for suported Vital Product Data | |
| 3932 * pages - assuming only 2 page codes | |
| 3933 * supported | |
| 3934 */ | |
| 3935 page_buf[0] = peripheral_device_type; | |
| 3936 page_buf[1] = INQUIRY_SUP_VPD_PAGE; | |
| 3937 page_buf[2] = 0; | |
| 3938 page_buf[3] = 2; /* page length */ | |
| 3939 page_buf[4] = INQUIRY_SUP_VPD_PAGE; | |
| 3940 page_buf[5] = INQUIRY_USN_PAGE; | |
| 3941 /* Copy no more than requested */ | |
| 3942 count = MIN(bp->b_bcount, 6); | |
| 3943 bcopy(page_buf, bp->b_un.b_addr, count); | |
| 3944 break; | |
| 3945 case INQUIRY_USN_PAGE: | |
| 3946 /* | |
| 3947 * Request for Unit Serial Number page | |
| 3948 */ | |
| 3949 page_buf[0] = peripheral_device_type; | |
| 3950 page_buf[1] = INQUIRY_USN_PAGE; | |
| 3951 page_buf[2] = 0; | |
| 3952 page_buf[3] = 20; /* remaining page length */ | |
| 3953 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); | |
| 3954 #ifdef _LITTLE_ENDIAN | |
| 3955 swab(p, &page_buf[4], 20); | |
| 3956 #else | |
| 3957 bcopy(p, &page_buf[4], 20); | |
| 3958 #endif | |
| 3959 for (i = 0; i < 20; i++) { | |
| 3960 if (page_buf[4 + i] == '\0' || | |
| 3961 page_buf[4 + i] == '\040') { | |
| 3962 break; | |
| 3963 } | |
| 3964 } | |
| 3965 /* | |
| 3966 * 'i' contains string length. | |
| 3967 * | |
| 3968 * Least significant character of the serial | |
| 3969 * number shall appear as the last byte, | |
| 3970 * according to SBC-3 spec. | |
| 3971 */ | |
| 3972 p = &page_buf[20 + 4 - 1]; | |
| 3973 for (j = i; j > 0; j--, p--) { | |
| 3974 *p = *(p - 20 + i); | |
| 3975 } | |
| 3976 p = &page_buf[4]; | |
| 3977 for (j = 20 - i; j > 0; j--) { | |
| 3978 *p++ = '\040'; | |
| 3979 } | |
| 3980 count = MIN(bp->b_bcount, 24); | |
| 3981 bcopy(page_buf, bp->b_un.b_addr, count); | |
| 3982 break; | |
| 3983 | |
| 3984 case INQUIRY_DEV_IDENTIFICATION_PAGE: | |
| 3985 /* | |
| 3986 * We may want to implement this page, when | |
| 3987 * identifiers are common for SATA devices | |
| 3988 * But not now. | |
| 3989 */ | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
3990 /*FALLTHROUGH*/ |
| 1258 | 3991 |
| 3992 default: | |
| 3993 /* Request for unsupported VPD page */ | |
| 3994 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3995 sense = sata_arq_sense(spx); | |
| 3996 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3997 sense->es_add_code = | |
| 3998 SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3999 goto done; | |
| 4000 } | |
| 4001 } | |
| 4002 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4003 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? | |
| 4004 scsipkt->pkt_cdbp[4] - count : 0; | |
| 4005 } | |
| 4006 done: | |
| 4007 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4008 | |
| 4009 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4010 "Scsi_pkt completion reason %x\n", | |
| 4011 scsipkt->pkt_reason); | |
| 4012 | |
| 4013 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4014 scsipkt->pkt_comp != NULL) { |
| 1258 | 4015 /* scsi callback required */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4016 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4017 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
4018 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4019 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4020 return (TRAN_BUSY); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4021 } |
| 1258 | 4022 return (TRAN_ACCEPT); |
| 4023 } | |
| 4024 | |
| 4025 /* | |
| 4026 * SATA translate command: Request Sense | |
| 4027 * emulated command (ATA version so far, no ATAPI) | |
| 4028 * Always NO SENSE, because any sense data should be reported by ARQ sense. | |
| 4029 * | |
| 4030 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4031 */ | |
| 4032 static int | |
| 4033 sata_txlt_request_sense(sata_pkt_txlate_t *spx) | |
| 4034 { | |
| 4035 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4036 struct scsi_extended_sense sense; | |
| 4037 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4038 int rval; | |
| 4039 | |
| 4040 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4041 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4042 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4043 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 4044 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 4045 return (rval); | |
| 4046 } | |
| 4047 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4048 | |
| 4049 | |
| 4050 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4051 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4052 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4053 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 4054 | |
| 4055 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 4056 int count = MIN(bp->b_bcount, | |
| 4057 sizeof (struct scsi_extended_sense)); | |
| 4058 bzero(&sense, sizeof (struct scsi_extended_sense)); | |
| 4059 sense.es_valid = 0; /* Valid LBA */ | |
| 4060 sense.es_class = 7; /* Response code 0x70 - current err */ | |
| 4061 sense.es_key = KEY_NO_SENSE; | |
| 4062 sense.es_add_len = 6; /* Additional length */ | |
| 4063 /* Copy no more than requested */ | |
| 4064 bcopy(&sense, bp->b_un.b_addr, count); | |
| 4065 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4066 scsipkt->pkt_resid = 0; | |
| 4067 } | |
| 4068 | |
| 4069 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4070 "Scsi_pkt completion reason %x\n", | |
| 4071 scsipkt->pkt_reason); | |
| 4072 | |
| 4073 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4074 scsipkt->pkt_comp != NULL) | |
| 4075 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4076 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4077 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
4078 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4079 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4080 return (TRAN_BUSY); |
| 1258 | 4081 return (TRAN_ACCEPT); |
| 4082 } | |
| 4083 | |
| 4084 /* | |
| 4085 * SATA translate command: Test Unit Ready | |
| 4086 * At the moment this is an emulated command (ATA version so far, no ATAPI). | |
| 4087 * May be translated into Check Power Mode command in the future | |
| 4088 * | |
| 4089 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4090 */ | |
| 4091 static int | |
| 4092 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) | |
| 4093 { | |
| 4094 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4095 struct scsi_extended_sense *sense; | |
| 4096 int power_state; | |
| 4097 int rval; | |
| 4098 | |
| 4099 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4100 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4101 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4102 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 4103 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 4104 return (rval); | |
| 4105 } | |
| 4106 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4107 | |
| 4108 /* At this moment, emulate it rather than execute anything */ | |
| 4109 power_state = SATA_PWRMODE_ACTIVE; | |
| 4110 | |
| 4111 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4112 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4113 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4114 | |
| 4115 switch (power_state) { | |
| 4116 case SATA_PWRMODE_ACTIVE: | |
| 4117 case SATA_PWRMODE_IDLE: | |
| 4118 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 4119 break; | |
| 4120 default: | |
| 4121 /* PWR mode standby */ | |
| 4122 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4123 sense = sata_arq_sense(spx); | |
| 4124 sense->es_key = KEY_NOT_READY; | |
| 4125 sense->es_add_code = SD_SCSI_LU_NOT_READY; | |
| 4126 break; | |
| 4127 } | |
| 4128 | |
| 4129 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4130 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4131 | |
| 4132 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4133 scsipkt->pkt_comp != NULL) | |
| 4134 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4135 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4136 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
4137 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4138 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4139 return (TRAN_BUSY); |
| 1258 | 4140 |
| 4141 return (TRAN_ACCEPT); | |
| 4142 } | |
| 4143 | |
| 4144 | |
| 4145 /* | |
| 4146 * SATA translate command: Start Stop Unit | |
| 4147 * Translation depends on a command: | |
| 4148 * Start Unit translated into Idle Immediate | |
| 4149 * Stop Unit translated into Standby Immediate | |
| 4150 * Unload Media / NOT SUPPORTED YET | |
| 4151 * Load Media / NOT SUPPROTED YET | |
| 4152 * Power condition bits are ignored, so is Immediate bit | |
| 4153 * Requesting synchronous execution. | |
| 4154 * | |
| 4155 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 4156 * appropriate values in scsi_pkt fields. | |
| 4157 */ | |
| 4158 static int | |
| 4159 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) | |
| 4160 { | |
| 4161 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4162 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 4163 struct scsi_extended_sense *sense; | |
| 4164 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 4165 int cport = SATA_TXLT_CPORT(spx); | |
| 4166 int rval; | |
| 4167 int synch; | |
| 4168 | |
| 4169 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4170 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); | |
| 4171 | |
| 4172 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); | |
| 4173 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4174 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4175 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 4176 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 4177 return (rval); | |
| 4178 } | |
| 4179 | |
| 4180 if (scsipkt->pkt_cdbp[4] & 2) { | |
| 4181 /* Load/Unload Media - invalid request */ | |
| 4182 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4183 sense = sata_arq_sense(spx); | |
| 4184 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4185 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 4186 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4187 | |
| 4188 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4189 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4190 | |
| 4191 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4192 scsipkt->pkt_comp != NULL) | |
| 4193 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4194 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4195 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
4196 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4197 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4198 return (TRAN_BUSY); |
| 1258 | 4199 |
| 4200 return (TRAN_ACCEPT); | |
| 4201 } | |
| 4202 scmd->satacmd_addr_type = 0; | |
| 4203 scmd->satacmd_sec_count_lsb = 0; | |
| 4204 scmd->satacmd_lba_low_lsb = 0; | |
| 4205 scmd->satacmd_lba_mid_lsb = 0; | |
| 4206 scmd->satacmd_lba_high_lsb = 0; | |
| 4207 scmd->satacmd_features_reg = 0; | |
| 4208 scmd->satacmd_device_reg = 0; | |
| 4209 scmd->satacmd_status_reg = 0; | |
| 4210 if (scsipkt->pkt_cdbp[4] & 1) { | |
| 4211 /* Start Unit */ | |
| 4212 scmd->satacmd_cmd_reg = SATAC_IDLE_IM; | |
| 4213 } else { | |
| 4214 /* Stop Unit */ | |
| 4215 scmd->satacmd_cmd_reg = SATAC_STANDBY_IM; | |
| 4216 } | |
| 4217 | |
| 4218 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 4219 /* Need to set-up a callback function */ | |
| 4220 spx->txlt_sata_pkt->satapkt_comp = | |
| 4221 sata_txlt_nodata_cmd_completion; | |
| 4222 synch = FALSE; | |
| 4223 } else { | |
| 4224 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; | |
| 4225 synch = TRUE; | |
| 4226 } | |
| 4227 | |
| 4228 /* Transfer command to HBA */ | |
| 4229 if (sata_hba_start(spx, &rval) != 0) { | |
| 4230 /* Pkt not accepted for execution */ | |
| 4231 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 4232 return (rval); | |
| 4233 } | |
| 4234 | |
| 4235 /* | |
| 4236 * If execution is non-synchronous, | |
| 4237 * a callback function will handle potential errors, translate | |
| 4238 * the response and will do a callback to a target driver. | |
| 4239 * If it was synchronous, check execution status using the same | |
| 4240 * framework callback. | |
| 4241 */ | |
| 4242 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 4243 if (synch) { | |
| 4244 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4245 "synchronous execution status %x\n", | |
| 4246 spx->txlt_sata_pkt->satapkt_reason); | |
| 4247 | |
| 4248 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); | |
| 4249 } | |
| 4250 return (TRAN_ACCEPT); | |
| 4251 | |
| 4252 } | |
| 4253 | |
| 4254 | |
| 4255 /* | |
| 4256 * SATA translate command: Read Capacity. | |
| 4257 * Emulated command for SATA disks. | |
| 4258 * Capacity is retrieved from cached Idenifty Device data. | |
| 4259 * Identify Device data shows effective disk capacity, not the native | |
| 4260 * capacity, which may be limitted by Set Max Address command. | |
| 4261 * This is ATA version (non-ATAPI). | |
| 4262 * | |
| 4263 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4264 */ | |
| 4265 static int | |
| 4266 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) | |
| 4267 { | |
| 4268 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4269 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4270 sata_drive_info_t *sdinfo; | |
| 4271 uint64_t val; | |
| 4272 uchar_t *rbuf; | |
| 4273 int rval; | |
| 4274 | |
| 4275 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4276 "sata_txlt_read_capacity: ", NULL); | |
| 4277 | |
| 4278 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4279 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4280 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4281 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 4282 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 4283 return (rval); | |
| 4284 } | |
| 4285 | |
| 4286 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4287 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4288 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4289 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 4290 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 4291 sdinfo = sata_get_device_info( | |
| 4292 spx->txlt_sata_hba_inst, | |
| 4293 &spx->txlt_sata_pkt->satapkt_device); | |
| 4294 /* Last logical block address */ | |
| 4295 val = sdinfo->satadrv_capacity - 1; | |
| 4296 rbuf = (uchar_t *)bp->b_un.b_addr; | |
| 4297 /* Need to swap endians to match scsi format */ | |
| 4298 rbuf[0] = (val >> 24) & 0xff; | |
| 4299 rbuf[1] = (val >> 16) & 0xff; | |
| 4300 rbuf[2] = (val >> 8) & 0xff; | |
| 4301 rbuf[3] = val & 0xff; | |
| 4302 /* block size - always 512 bytes, for now */ | |
| 4303 rbuf[4] = 0; | |
| 4304 rbuf[5] = 0; | |
| 4305 rbuf[6] = 0x02; | |
| 4306 rbuf[7] = 0; | |
| 4307 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4308 scsipkt->pkt_resid = 0; | |
| 4309 | |
| 4310 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", | |
| 4311 sdinfo->satadrv_capacity -1); | |
| 4312 } | |
| 4313 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4314 /* | |
| 4315 * If a callback was requested, do it now. | |
| 4316 */ | |
| 4317 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4318 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4319 | |
| 4320 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4321 scsipkt->pkt_comp != NULL) | |
| 4322 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4323 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4324 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
4325 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4326 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4327 return (TRAN_BUSY); |
| 1258 | 4328 |
| 4329 return (TRAN_ACCEPT); | |
| 4330 } | |
| 4331 | |
| 4332 /* | |
| 4333 * SATA translate command: Mode Sense. | |
| 4334 * Translated into appropriate SATA command or emulated. | |
| 4335 * Saved Values Page Control (03) are not supported. | |
| 4336 * | |
| 4337 * NOTE: only caching mode sense page is currently implemented. | |
| 4338 * | |
| 4339 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4340 */ | |
| 4341 | |
| 4342 static int | |
| 4343 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) | |
| 4344 { | |
| 4345 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4346 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4347 sata_drive_info_t *sdinfo; | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4348 sata_id_t *sata_id; |
| 1258 | 4349 struct scsi_extended_sense *sense; |
| 4350 int len, bdlen, count, alc_len; | |
| 4351 int pc; /* Page Control code */ | |
| 4352 uint8_t *buf; /* mode sense buffer */ | |
| 4353 int rval; | |
| 4354 | |
| 4355 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4356 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", | |
| 4357 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, | |
| 4358 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4359 | |
| 4360 buf = kmem_zalloc(1024, KM_SLEEP); | |
| 4361 | |
| 4362 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4363 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4364 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4365 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 4366 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 4367 kmem_free(buf, 1024); | |
| 4368 return (rval); | |
| 4369 } | |
| 4370 | |
| 4371 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4372 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4373 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4374 | |
| 4375 pc = scsipkt->pkt_cdbp[2] >> 6; | |
| 4376 | |
| 4377 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 4378 len = 0; | |
| 4379 bdlen = 0; | |
| 4380 if (!(scsipkt->pkt_cdbp[1] & 8)) { | |
| 4381 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && | |
| 4382 (scsipkt->pkt_cdbp[0] & 0x10)) | |
| 4383 bdlen = 16; | |
| 4384 else | |
| 4385 bdlen = 8; | |
| 4386 } | |
| 4387 /* Build mode parameter header */ | |
| 4388 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4389 /* 4-byte mode parameter header */ | |
| 4390 buf[len++] = 0; /* mode data length */ | |
| 4391 buf[len++] = 0; /* medium type */ | |
| 4392 buf[len++] = 0; /* dev-specific param */ | |
| 4393 buf[len++] = bdlen; /* Block Descriptor length */ | |
| 4394 } else { | |
| 4395 /* 8-byte mode parameter header */ | |
| 4396 buf[len++] = 0; /* mode data length */ | |
| 4397 buf[len++] = 0; | |
| 4398 buf[len++] = 0; /* medium type */ | |
| 4399 buf[len++] = 0; /* dev-specific param */ | |
| 4400 if (bdlen == 16) | |
| 4401 buf[len++] = 1; /* long lba descriptor */ | |
| 4402 else | |
| 4403 buf[len++] = 0; | |
| 4404 buf[len++] = 0; | |
| 4405 buf[len++] = 0; /* Block Descriptor length */ | |
| 4406 buf[len++] = bdlen; | |
| 4407 } | |
| 4408 | |
| 4409 sdinfo = sata_get_device_info( | |
| 4410 spx->txlt_sata_hba_inst, | |
| 4411 &spx->txlt_sata_pkt->satapkt_device); | |
| 4412 | |
| 4413 /* Build block descriptor only if not disabled (DBD) */ | |
| 4414 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { | |
| 4415 /* Block descriptor - direct-access device format */ | |
| 4416 if (bdlen == 8) { | |
| 4417 /* build regular block descriptor */ | |
| 4418 buf[len++] = | |
| 4419 (sdinfo->satadrv_capacity >> 24) & 0xff; | |
| 4420 buf[len++] = | |
| 4421 (sdinfo->satadrv_capacity >> 16) & 0xff; | |
| 4422 buf[len++] = | |
| 4423 (sdinfo->satadrv_capacity >> 8) & 0xff; | |
| 4424 buf[len++] = sdinfo->satadrv_capacity & 0xff; | |
| 4425 buf[len++] = 0; /* density code */ | |
| 4426 buf[len++] = 0; | |
| 4427 if (sdinfo->satadrv_type == | |
| 4428 SATA_DTYPE_ATADISK) | |
| 4429 buf[len++] = 2; | |
| 4430 else | |
| 4431 /* ATAPI */ | |
| 4432 buf[len++] = 8; | |
| 4433 buf[len++] = 0; | |
| 4434 } else if (bdlen == 16) { | |
| 4435 /* Long LBA Accepted */ | |
| 4436 /* build long lba block descriptor */ | |
| 4437 #ifndef __lock_lint | |
| 4438 buf[len++] = | |
| 4439 (sdinfo->satadrv_capacity >> 56) & 0xff; | |
| 4440 buf[len++] = | |
| 4441 (sdinfo->satadrv_capacity >> 48) & 0xff; | |
| 4442 buf[len++] = | |
| 4443 (sdinfo->satadrv_capacity >> 40) & 0xff; | |
| 4444 buf[len++] = | |
| 4445 (sdinfo->satadrv_capacity >> 32) & 0xff; | |
| 4446 #endif | |
| 4447 buf[len++] = | |
| 4448 (sdinfo->satadrv_capacity >> 24) & 0xff; | |
| 4449 buf[len++] = | |
| 4450 (sdinfo->satadrv_capacity >> 16) & 0xff; | |
| 4451 buf[len++] = | |
| 4452 (sdinfo->satadrv_capacity >> 8) & 0xff; | |
| 4453 buf[len++] = sdinfo->satadrv_capacity & 0xff; | |
| 4454 buf[len++] = 0; | |
| 4455 buf[len++] = 0; /* density code */ | |
| 4456 buf[len++] = 0; | |
| 4457 buf[len++] = 0; | |
| 4458 if (sdinfo->satadrv_type == | |
| 4459 SATA_DTYPE_ATADISK) | |
| 4460 buf[len++] = 2; | |
| 4461 else | |
| 4462 /* ATAPI */ | |
| 4463 buf[len++] = 8; | |
| 4464 buf[len++] = 0; | |
| 4465 } | |
| 4466 } | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4467 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4468 sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4469 |
| 1258 | 4470 /* |
| 4471 * Add requested pages. | |
| 4472 * Page 3 and 4 are obsolete and we are not supporting them. | |
| 4473 * We deal now with: | |
| 4474 * caching (read/write cache control). | |
| 4475 * We should eventually deal with following mode pages: | |
| 4476 * error recovery (0x01), | |
| 4477 * power condition (0x1a), | |
| 4478 * exception control page (enables SMART) (0x1c), | |
| 4479 * enclosure management (ses), | |
| 4480 * protocol-specific port mode (port control). | |
| 4481 */ | |
| 4482 switch (scsipkt->pkt_cdbp[2] & 0x3f) { | |
| 4483 case MODEPAGE_RW_ERRRECOV: | |
| 4484 /* DAD_MODE_ERR_RECOV */ | |
| 4485 /* R/W recovery */ | |
| 4486 len += sata_build_msense_page_1(sdinfo, pc, buf+len); | |
| 4487 break; | |
| 4488 case MODEPAGE_CACHING: | |
| 4489 /* DAD_MODE_CACHE */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4490 /* Reject not supported request for saved parameters */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4491 if (pc == 3) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4492 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4493 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4494 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4495 sense->es_add_code = |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4496 SD_SCSI_SAVING_PARAMS_NOT_SUP; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4497 goto done; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4498 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4499 |
| 1258 | 4500 /* caching */ |
| 4501 len += sata_build_msense_page_8(sdinfo, pc, buf+len); | |
| 4502 break; | |
| 4503 case MODEPAGE_INFO_EXCPT: | |
| 4504 /* exception cntrl */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4505 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4506 len += sata_build_msense_page_1c(sdinfo, pc, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4507 buf+len); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4508 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4509 else |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4510 goto err; |
| 1258 | 4511 break; |
| 4512 case MODEPAGE_POWER_COND: | |
| 4513 /* DAD_MODE_POWER_COND */ | |
| 4514 /* power condition */ | |
| 4515 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); | |
| 4516 break; | |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4517 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4518 case MODEPAGE_ACOUSTIC_MANAG: |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4519 /* acoustic management */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4520 len += sata_build_msense_page_30(sdinfo, pc, buf+len); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4521 break; |
| 1258 | 4522 case MODEPAGE_ALLPAGES: |
| 4523 /* all pages */ | |
| 4524 len += sata_build_msense_page_1(sdinfo, pc, buf+len); | |
| 4525 len += sata_build_msense_page_8(sdinfo, pc, buf+len); | |
| 4526 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4527 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4528 len += sata_build_msense_page_1c(sdinfo, pc, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4529 buf+len); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4530 } |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4531 len += sata_build_msense_page_30(sdinfo, pc, buf+len); |
| 1258 | 4532 break; |
| 4533 default: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4534 err: |
| 1258 | 4535 /* Invalid request */ |
| 4536 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4537 sense = sata_arq_sense(spx); | |
| 4538 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4539 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 4540 goto done; | |
| 4541 } | |
| 4542 | |
| 4543 /* fix total mode data length */ | |
| 4544 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4545 /* 4-byte mode parameter header */ | |
| 4546 buf[0] = len - 1; /* mode data length */ | |
| 4547 } else { | |
| 4548 buf[0] = (len -2) >> 8; | |
| 4549 buf[1] = (len -2) & 0xff; | |
| 4550 } | |
| 4551 | |
| 4552 | |
| 4553 /* Check allocation length */ | |
| 4554 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4555 alc_len = scsipkt->pkt_cdbp[4]; | |
| 4556 } else { | |
| 4557 alc_len = scsipkt->pkt_cdbp[7]; | |
| 4558 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; | |
| 4559 } | |
| 4560 /* | |
| 4561 * We do not check for possible parameters truncation | |
| 4562 * (alc_len < len) assuming that the target driver works | |
| 4563 * correctly. Just avoiding overrun. | |
| 4564 * Copy no more than requested and possible, buffer-wise. | |
| 4565 */ | |
| 4566 count = MIN(alc_len, len); | |
| 4567 count = MIN(bp->b_bcount, count); | |
| 4568 bcopy(buf, bp->b_un.b_addr, count); | |
| 4569 | |
| 4570 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4571 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; | |
| 4572 } | |
| 4573 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 4574 done: | |
| 4575 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4576 (void) kmem_free(buf, 1024); | |
| 4577 | |
| 4578 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4579 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4580 | |
| 4581 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4582 scsipkt->pkt_comp != NULL) | |
| 4583 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4584 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4585 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
4586 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4587 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4588 return (TRAN_BUSY); |
| 1258 | 4589 |
| 4590 return (TRAN_ACCEPT); | |
| 4591 } | |
| 4592 | |
| 4593 | |
| 4594 /* | |
| 4595 * SATA translate command: Mode Select. | |
| 4596 * Translated into appropriate SATA command or emulated. | |
| 4597 * Saving parameters is not supported. | |
| 4598 * Changing device capacity is not supported (although theoretically | |
| 4599 * possible by executing SET FEATURES/SET MAX ADDRESS) | |
| 4600 * | |
| 4601 * Assumption is that the target driver is working correctly. | |
| 4602 * | |
| 4603 * More than one SATA command may be executed to perform operations specified | |
| 4604 * by mode select pages. The first error terminates further execution. | |
| 4605 * Operations performed successully are not backed-up in such case. | |
| 4606 * | |
| 4607 * NOTE: only caching mode select page is implemented. | |
| 4608 * Caching setup is remembered so it could be re-stored in case of | |
| 4609 * an unexpected device reset. | |
| 4610 * | |
| 4611 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4612 */ | |
| 4613 | |
| 4614 static int | |
| 4615 sata_txlt_mode_select(sata_pkt_txlate_t *spx) | |
| 4616 { | |
| 4617 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4618 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4619 struct scsi_extended_sense *sense; | |
| 4620 int len, pagelen, count, pllen; | |
| 4621 uint8_t *buf; /* mode select buffer */ | |
| 4622 int rval, stat; | |
| 4623 uint_t nointr_flag; | |
| 4624 int dmod = 0; | |
| 4625 | |
| 4626 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4627 "sata_txlt_mode_select, pc %x page code 0x%02x\n", | |
| 4628 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, | |
| 4629 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4630 | |
| 4631 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4632 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4633 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4634 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 4635 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 4636 return (rval); | |
| 4637 } | |
| 4638 | |
| 4639 rval = TRAN_ACCEPT; | |
| 4640 | |
| 4641 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4642 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4643 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4644 | |
| 4645 /* Reject not supported request */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4646 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ |
| 1258 | 4647 *scsipkt->pkt_scbp = STATUS_CHECK; |
| 4648 sense = sata_arq_sense(spx); | |
| 4649 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4650 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 4651 goto done; | |
| 4652 } | |
| 4653 | |
| 4654 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { | |
| 4655 pllen = scsipkt->pkt_cdbp[4]; | |
| 4656 } else { | |
| 4657 pllen = scsipkt->pkt_cdbp[7]; | |
| 4658 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; | |
| 4659 } | |
| 4660 | |
| 4661 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ | |
| 4662 | |
| 4663 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { | |
| 4664 buf = (uint8_t *)bp->b_un.b_addr; | |
| 4665 count = MIN(bp->b_bcount, pllen); | |
| 4666 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4667 scsipkt->pkt_resid = 0; | |
| 4668 pllen = count; | |
| 4669 | |
| 4670 /* | |
| 4671 * Check the header to skip the block descriptor(s) - we | |
| 4672 * do not support setting device capacity. | |
| 4673 * Existing macros do not recognize long LBA dscriptor, | |
| 4674 * hence manual calculation. | |
| 4675 */ | |
| 4676 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { | |
| 4677 /* 6-bytes CMD, 4 bytes header */ | |
| 4678 if (count <= 4) | |
| 4679 goto done; /* header only */ | |
| 4680 len = buf[3] + 4; | |
| 4681 } else { | |
| 4682 /* 10-bytes CMD, 8 bytes header */ | |
| 4683 if (count <= 8) | |
| 4684 goto done; /* header only */ | |
| 4685 len = buf[6]; | |
| 4686 len = (len << 8) + buf[7] + 8; | |
| 4687 } | |
| 4688 if (len >= count) | |
| 4689 goto done; /* header + descriptor(s) only */ | |
| 4690 | |
| 4691 pllen -= len; /* remaining data length */ | |
| 4692 | |
| 4693 /* | |
| 4694 * We may be executing SATA command and want to execute it | |
| 4695 * in SYNCH mode, regardless of scsi_pkt setting. | |
| 4696 * Save scsi_pkt setting and indicate SYNCH mode | |
| 4697 */ | |
| 4698 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; | |
| 4699 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4700 scsipkt->pkt_comp != NULL) { | |
| 4701 scsipkt->pkt_flags |= FLAG_NOINTR; | |
| 4702 } | |
| 4703 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; | |
| 4704 | |
| 4705 /* | |
| 4706 * len is now the offset to a first mode select page | |
| 4707 * Process all pages | |
| 4708 */ | |
| 4709 while (pllen > 0) { | |
| 4710 switch ((int)buf[len]) { | |
| 4711 case MODEPAGE_CACHING: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4712 /* No support for SP (saving) */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4713 if (scsipkt->pkt_cdbp[1] & 0x01) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4714 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4715 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4716 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4717 sense->es_add_code = |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4718 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4719 goto done; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4720 } |
| 1258 | 4721 stat = sata_mode_select_page_8(spx, |
| 4722 (struct mode_cache_scsi3 *)&buf[len], | |
| 4723 pllen, &pagelen, &rval, &dmod); | |
| 4724 /* | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4725 * The pagelen value indicates the number of |
| 1258 | 4726 * parameter bytes already processed. |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4727 * The rval is the return value from |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4728 * sata_tran_start(). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4729 * The stat indicates the overall status of |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4730 * the operation(s). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4731 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4732 if (stat != SATA_SUCCESS) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4733 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4734 * Page processing did not succeed - |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4735 * all error info is already set-up, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4736 * just return |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4737 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4738 pllen = 0; /* this breaks the loop */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4739 else { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4740 len += pagelen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4741 pllen -= pagelen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4742 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4743 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4744 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4745 case MODEPAGE_INFO_EXCPT: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4746 stat = sata_mode_select_page_1c(spx, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4747 (struct mode_info_excpt_page *)&buf[len], |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4748 pllen, &pagelen, &rval, &dmod); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4749 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4750 * The pagelen value indicates the number of |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4751 * parameter bytes already processed. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4752 * The rval is the return value from |
| 1258 | 4753 * sata_tran_start(). |
| 4754 * The stat indicates the overall status of | |
| 4755 * the operation(s). | |
| 4756 */ | |
| 4757 if (stat != SATA_SUCCESS) | |
| 4758 /* | |
| 4759 * Page processing did not succeed - | |
| 4760 * all error info is already set-up, | |
| 4761 * just return | |
| 4762 */ | |
| 4763 pllen = 0; /* this breaks the loop */ | |
| 4764 else { | |
| 4765 len += pagelen; | |
| 4766 pllen -= pagelen; | |
| 4767 } | |
| 4768 break; | |
| 4769 | |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4770 case MODEPAGE_ACOUSTIC_MANAG: |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4771 stat = sata_mode_select_page_30(spx, |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4772 (struct mode_acoustic_management *) |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4773 &buf[len], pllen, &pagelen, &rval, &dmod); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4774 /* |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4775 * The pagelen value indicates the number of |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4776 * parameter bytes already processed. |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4777 * The rval is the return value from |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4778 * sata_tran_start(). |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4779 * The stat indicates the overall status of |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4780 * the operation(s). |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4781 */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4782 if (stat != SATA_SUCCESS) |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4783 /* |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4784 * Page processing did not succeed - |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4785 * all error info is already set-up, |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4786 * just return |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4787 */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4788 pllen = 0; /* this breaks the loop */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4789 else { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4790 len += pagelen; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4791 pllen -= pagelen; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4792 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4793 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
4794 break; |
| 1258 | 4795 default: |
| 4796 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4797 sense = sata_arq_sense(spx); | |
| 4798 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4799 sense->es_add_code = | |
| 4800 SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; | |
| 4801 goto done; | |
| 4802 } | |
| 4803 } | |
| 4804 } | |
| 4805 done: | |
| 4806 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4807 /* | |
| 4808 * If device parameters were modified, fetch and store the new | |
| 4809 * Identify Device data. Since port mutex could have been released | |
| 4810 * for accessing HBA driver, we need to re-check device existence. | |
| 4811 */ | |
| 4812 if (dmod != 0) { | |
| 4813 sata_drive_info_t new_sdinfo, *sdinfo; | |
| 4814 int rv; | |
| 4815 | |
| 4816 new_sdinfo.satadrv_addr = | |
| 4817 spx->txlt_sata_pkt->satapkt_device.satadev_addr; | |
| 4818 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, | |
| 4819 &new_sdinfo); | |
| 4820 | |
| 4821 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4822 /* | |
| 4823 * Since port mutex could have been released when | |
| 4824 * accessing HBA driver, we need to re-check that the | |
| 4825 * framework still holds the device info structure. | |
| 4826 */ | |
| 4827 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 4828 &spx->txlt_sata_pkt->satapkt_device); | |
| 4829 if (sdinfo != NULL) { | |
| 4830 /* | |
| 4831 * Device still has info structure in the | |
| 4832 * sata framework. Copy newly fetched info | |
| 4833 */ | |
| 4834 if (rv == 0) { | |
| 4835 sdinfo->satadrv_id = new_sdinfo.satadrv_id; | |
| 4836 sata_save_drive_settings(sdinfo); | |
| 4837 } else { | |
| 4838 /* | |
| 4839 * Could not fetch new data - invalidate | |
| 4840 * sata_drive_info. That makes device | |
| 4841 * unusable. | |
| 4842 */ | |
| 4843 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 4844 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 4845 } | |
| 4846 } | |
| 4847 if (rv != 0 || sdinfo == NULL) { | |
| 4848 /* | |
| 4849 * This changes the overall mode select completion | |
| 4850 * reason to a failed one !!!!! | |
| 4851 */ | |
| 4852 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4853 sense = sata_arq_sense(spx); | |
| 4854 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 4855 rval = TRAN_ACCEPT; | |
| 4856 } | |
| 4857 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4858 } | |
| 4859 /* Restore the scsi pkt flags */ | |
| 4860 scsipkt->pkt_flags &= ~FLAG_NOINTR; | |
| 4861 scsipkt->pkt_flags |= nointr_flag; | |
| 4862 | |
| 4863 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4864 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4865 | |
| 4866 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4867 scsipkt->pkt_comp != NULL) | |
| 4868 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4869 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4870 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
4871 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4872 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4873 return (TRAN_BUSY); |
| 1258 | 4874 |
| 4875 return (rval); | |
| 4876 } | |
| 4877 | |
| 4878 | |
| 4879 | |
| 4880 /* | |
| 4881 * Translate command: Log Sense | |
| 4882 */ | |
| 4883 static int | |
| 4884 sata_txlt_log_sense(sata_pkt_txlate_t *spx) | |
| 4885 { | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4886 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4887 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4888 sata_drive_info_t *sdinfo; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4889 struct scsi_extended_sense *sense; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4890 int len, count, alc_len; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4891 int pc; /* Page Control code */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4892 int page_code; /* Page code */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4893 uint8_t *buf; /* log sense buffer */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4894 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4895 #define MAX_LOG_SENSE_PAGE_SIZE 512 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4896 |
| 1258 | 4897 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4898 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", |
| 1258 | 4899 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, |
| 4900 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4901 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4902 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4903 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4904 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4905 |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4906 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
4907 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4908 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4909 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4910 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4911 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4912 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4913 scsipkt->pkt_reason = CMD_CMPLT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4914 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4915 STATE_SENT_CMD | STATE_GOT_STATUS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4916 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4917 pc = scsipkt->pkt_cdbp[2] >> 6; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4918 page_code = scsipkt->pkt_cdbp[2] & 0x3f; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4919 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
4920 /* Reject not supported request for all but cumulative values */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4921 switch (pc) { |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
4922 case PC_CUMULATIVE_VALUES: |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4923 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4924 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4925 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4926 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4927 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4928 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4929 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4930 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4931 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4932 switch (page_code) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4933 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4934 case PAGE_CODE_SELF_TEST_RESULTS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4935 case PAGE_CODE_INFORMATION_EXCEPTIONS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4936 case PAGE_CODE_SMART_READ_DATA: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4937 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4938 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4939 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4940 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4941 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4942 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4943 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4944 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4945 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4946 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4947 sata_id_t *sata_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4948 len = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4949 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4950 /* Build log parameter header */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4951 buf[len++] = page_code; /* page code as in the CDB */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4952 buf[len++] = 0; /* reserved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4953 buf[len++] = 0; /* Zero out page length for now (MSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4954 buf[len++] = 0; /* (LSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4955 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4956 sdinfo = sata_get_device_info( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4957 spx->txlt_sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4958 &spx->txlt_sata_pkt->satapkt_device); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4959 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4960 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4961 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4962 * Add requested pages. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4963 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4964 switch (page_code) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4965 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4966 len = sata_build_lsense_page_0(sdinfo, buf + len); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4967 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4968 case PAGE_CODE_SELF_TEST_RESULTS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4969 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4970 if ((! (sata_id->ai_cmdset84 & |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4971 SATA_SMART_SELF_TEST_SUPPORTED)) || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4972 (! (sata_id->ai_features87 & |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4973 SATA_SMART_SELF_TEST_SUPPORTED))) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4974 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4975 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4976 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4977 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4978 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4979 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4980 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4981 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4982 len = sata_build_lsense_page_10(sdinfo, buf + len, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4983 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4984 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4985 case PAGE_CODE_INFORMATION_EXCEPTIONS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4986 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4987 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4988 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4989 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4990 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4991 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4992 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4993 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4994 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4995 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4996 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4997 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4998 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4999 sense->es_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5000 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5001 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5002 sense->es_qual_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5003 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5004 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5005 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5006 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5007 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5008 len = sata_build_lsense_page_2f(sdinfo, buf + len, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5009 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5010 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5011 case PAGE_CODE_SMART_READ_DATA: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5012 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5013 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5014 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5015 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5016 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5017 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5018 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5019 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5020 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5021 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5022 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5023 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5024 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5025 sense->es_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5026 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5027 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5028 sense->es_qual_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5029 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5030 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5031 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5032 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5033 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5034 /* This page doesn't include a page header */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5035 len = sata_build_lsense_page_30(sdinfo, buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5036 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5037 goto no_header; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5038 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5039 /* Invalid request */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5040 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5041 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5042 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5043 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5044 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5045 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5046 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5047 /* set parameter log sense data length */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5048 buf[2] = len >> 8; /* log sense length (MSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5049 buf[3] = len & 0xff; /* log sense length (LSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5050 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5051 len += SCSI_LOG_PAGE_HDR_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5052 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5053 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5054 no_header: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5055 /* Check allocation length */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5056 alc_len = scsipkt->pkt_cdbp[7]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5057 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5058 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5059 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5060 * We do not check for possible parameters truncation |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5061 * (alc_len < len) assuming that the target driver works |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5062 * correctly. Just avoiding overrun. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5063 * Copy no more than requested and possible, buffer-wise. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5064 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5065 count = MIN(alc_len, len); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5066 count = MIN(bp->b_bcount, count); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5067 bcopy(buf, bp->b_un.b_addr, count); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5068 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5069 scsipkt->pkt_state |= STATE_XFERRED_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5070 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5071 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5072 *scsipkt->pkt_scbp = STATUS_GOOD; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5073 done: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5074 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5075 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5076 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5077 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5078 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5079 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5080 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5081 scsipkt->pkt_comp != NULL) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5082 /* scsi callback required */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5083 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5084 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5085 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5086 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5087 return (TRAN_BUSY); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5088 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5089 return (TRAN_ACCEPT); |
| 1258 | 5090 } |
| 5091 | |
| 5092 /* | |
| 5093 * Translate command: Log Select | |
| 5094 * Not implemented at this time - returns invalid command response. | |
| 5095 */ | |
| 5096 static int | |
| 5097 sata_txlt_log_select(sata_pkt_txlate_t *spx) | |
| 5098 { | |
| 5099 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5100 "sata_txlt_log_select\n", NULL); | |
| 5101 | |
| 5102 return (sata_txlt_invalid_command(spx)); | |
| 5103 } | |
| 5104 | |
| 5105 | |
| 5106 /* | |
| 5107 * Translate command: Read (various types). | |
| 5108 * Translated into appropriate type of ATA READ command | |
| 5109 * (NO ATAPI implementation yet). | |
| 5110 * Both the device capabilities and requested operation mode are | |
| 5111 * considered. | |
| 5112 * | |
| 5113 * Following scsi cdb fields are ignored: | |
| 5114 * rdprotect, dpo, fua, fua_nv, group_number. | |
| 5115 * | |
| 5116 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework | |
| 5117 * enable variable sata_func_enable), the capability of the controller and | |
| 5118 * capability of a device are checked and if both support queueing, read | |
| 5119 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT | |
| 5120 * command rather than plain READ_XXX command. | |
| 5121 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and | |
| 5122 * both the controller and device suport such functionality, the read | |
| 5123 * request will be translated to READ_FPDMA_QUEUED command. | |
| 5124 * | |
| 5125 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 5126 * appropriate values in scsi_pkt fields. | |
| 5127 */ | |
| 5128 static int | |
| 5129 sata_txlt_read(sata_pkt_txlate_t *spx) | |
| 5130 { | |
| 5131 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5132 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5133 sata_drive_info_t *sdinfo; | |
| 5134 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5135 int cport = SATA_TXLT_CPORT(spx); | |
| 5136 uint16_t sec_count; | |
| 5137 uint64_t lba; | |
| 5138 int rval; | |
| 5139 int synch; | |
| 5140 | |
| 5141 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5142 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5143 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5144 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 5145 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 5146 return (rval); | |
| 5147 } | |
| 5148 | |
| 5149 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 5150 &spx->txlt_sata_pkt->satapkt_device); | |
| 5151 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5152 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
| 1258 | 5153 /* |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5154 * Extract LBA and sector count from scsi CDB. |
| 1258 | 5155 */ |
| 5156 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 5157 case SCMD_READ: | |
| 5158 /* 6-byte scsi read cmd : 0x08 */ | |
| 5159 lba = (scsipkt->pkt_cdbp[1] & 0x1f); | |
| 5160 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; | |
| 5161 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5162 sec_count = scsipkt->pkt_cdbp[4]; | |
| 5163 /* sec_count 0 will be interpreted as 256 by a device */ | |
| 5164 break; | |
| 5165 case SCMD_READ_G1: | |
| 5166 /* 10-bytes scsi read command : 0x28 */ | |
| 5167 lba = scsipkt->pkt_cdbp[2]; | |
| 5168 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5169 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5170 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5171 sec_count = scsipkt->pkt_cdbp[7]; | |
| 5172 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5173 break; | |
| 5174 case SCMD_READ_G5: | |
| 5175 /* 12-bytes scsi read command : 0xA8 */ | |
| 5176 lba = scsipkt->pkt_cdbp[2]; | |
| 5177 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5178 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5179 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5180 sec_count = scsipkt->pkt_cdbp[6]; | |
| 5181 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; | |
| 5182 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5183 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; | |
| 5184 break; | |
| 5185 case SCMD_READ_G4: | |
| 5186 /* 16-bytes scsi read command : 0x88 */ | |
| 5187 lba = scsipkt->pkt_cdbp[2]; | |
| 5188 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5189 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5190 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5191 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; | |
| 5192 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; | |
| 5193 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; | |
| 5194 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; | |
| 5195 sec_count = scsipkt->pkt_cdbp[10]; | |
| 5196 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; | |
| 5197 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; | |
| 5198 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; | |
| 5199 break; | |
| 5200 default: | |
| 5201 /* Unsupported command */ | |
| 5202 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5203 return (sata_txlt_invalid_command(spx)); | |
| 5204 } | |
| 5205 | |
| 5206 /* | |
| 5207 * Check if specified address exceeds device capacity | |
| 5208 */ | |
| 5209 if ((lba >= sdinfo->satadrv_capacity) || | |
|
2593
79c4a3cba4f1
6462265 sata: framework rejects last addressable LBA on disk as invalid one
pawelw
parents:
2553
diff
changeset
|
5210 ((lba + sec_count) > sdinfo->satadrv_capacity)) { |
| 1258 | 5211 /* LBA out of range */ |
| 5212 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5213 return (sata_txlt_lba_out_of_range(spx)); | |
| 5214 } | |
| 5215 | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5216 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5217 * For zero-length transfer, emulate good completion of the command |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5218 * (reasons for rejecting the command were already checked). |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5219 * No DMA resources were allocated. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5220 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5221 if (spx->txlt_dma_cookie_list == NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5222 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5223 return (sata_emul_rw_completion(spx)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5224 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5225 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5226 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5227 * Build cmd block depending on the device capability and |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5228 * requested operation mode. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5229 * Do not bother with non-dma mode - we are working only with |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5230 * devices supporting DMA. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5231 */ |
| 1258 | 5232 scmd->satacmd_addr_type = ATA_ADDR_LBA; |
| 5233 scmd->satacmd_device_reg = SATA_ADH_LBA; | |
| 5234 scmd->satacmd_cmd_reg = SATAC_READ_DMA; | |
| 5235 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { | |
| 5236 scmd->satacmd_addr_type = ATA_ADDR_LBA48; | |
| 5237 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; | |
| 5238 scmd->satacmd_sec_count_msb = sec_count >> 8; | |
| 5239 #ifndef __lock_lint | |
| 5240 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; | |
| 5241 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; | |
| 5242 scmd->satacmd_lba_high_msb = lba >> 40; | |
| 5243 #endif | |
| 5244 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { | |
| 5245 scmd->satacmd_addr_type = ATA_ADDR_LBA28; | |
| 5246 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); | |
| 5247 } | |
| 5248 scmd->satacmd_sec_count_lsb = sec_count & 0xff; | |
| 5249 scmd->satacmd_lba_low_lsb = lba & 0xff; | |
| 5250 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; | |
| 5251 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; | |
| 5252 scmd->satacmd_features_reg = 0; | |
| 5253 scmd->satacmd_status_reg = 0; | |
| 5254 scmd->satacmd_error_reg = 0; | |
| 5255 | |
| 5256 /* | |
| 5257 * Check if queueing commands should be used and switch | |
| 5258 * to appropriate command if possible | |
| 5259 */ | |
| 5260 if (sata_func_enable & SATA_ENABLE_QUEUING) { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5261 boolean_t using_queuing; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5262 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5263 /* Queuing supported by controller and device? */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5264 if ((sata_func_enable & SATA_ENABLE_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5265 (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5266 SATA_DEV_F_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5267 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5268 SATA_CTLF_NCQ)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5269 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5270 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5271 /* NCQ supported - use FPDMA READ */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5272 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5273 SATAC_READ_FPDMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5274 scmd->satacmd_features_reg_ext = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5275 scmd->satacmd_sec_count_msb; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5276 scmd->satacmd_sec_count_msb = 0; |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
5277 scmd->satacmd_rle_sata_cmd = &sata_rle_cmd; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5278 } else if ((sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5279 SATA_DEV_F_TCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5280 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5281 SATA_CTLF_QCMD)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5282 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5283 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5284 /* Legacy queueing */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5285 if (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5286 SATA_DEV_F_LBA48) { |
| 1258 | 5287 scmd->satacmd_cmd_reg = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5288 SATAC_READ_DMA_QUEUED_EXT; |
| 1258 | 5289 scmd->satacmd_features_reg_ext = |
| 5290 scmd->satacmd_sec_count_msb; | |
| 5291 scmd->satacmd_sec_count_msb = 0; | |
| 5292 } else { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5293 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5294 SATAC_READ_DMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5295 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5296 } else /* Queuing not supported */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5297 using_queuing = B_FALSE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5298 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5299 /* |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5300 * If queuing, the sector count goes in the features register |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5301 * and the secount count will contain the tag. |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5302 */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5303 if (using_queuing) { |
| 1258 | 5304 scmd->satacmd_features_reg = |
| 5305 scmd->satacmd_sec_count_lsb; | |
| 5306 scmd->satacmd_sec_count_lsb = 0; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5307 scmd->satacmd_flags.sata_queued = B_TRUE; |
| 1258 | 5308 } |
| 5309 } | |
| 5310 | |
| 5311 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, | |
| 5312 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", | |
| 5313 scmd->satacmd_cmd_reg, lba, sec_count); | |
| 5314 | |
| 5315 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5316 /* Need callback function */ | |
| 5317 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; | |
| 5318 synch = FALSE; | |
| 5319 } else | |
| 5320 synch = TRUE; | |
| 5321 | |
| 5322 /* Transfer command to HBA */ | |
| 5323 if (sata_hba_start(spx, &rval) != 0) { | |
| 5324 /* Pkt not accepted for execution */ | |
| 5325 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5326 return (rval); | |
| 5327 } | |
| 5328 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5329 /* | |
| 5330 * If execution is non-synchronous, | |
| 5331 * a callback function will handle potential errors, translate | |
| 5332 * the response and will do a callback to a target driver. | |
| 5333 * If it was synchronous, check execution status using the same | |
| 5334 * framework callback. | |
| 5335 */ | |
| 5336 if (synch) { | |
| 5337 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5338 "synchronous execution status %x\n", | |
| 5339 spx->txlt_sata_pkt->satapkt_reason); | |
| 5340 sata_txlt_rw_completion(spx->txlt_sata_pkt); | |
| 5341 } | |
| 5342 return (TRAN_ACCEPT); | |
| 5343 } | |
| 5344 | |
| 5345 | |
| 5346 /* | |
| 5347 * SATA translate command: Write (various types) | |
| 5348 * Translated into appropriate type of ATA WRITE command | |
| 5349 * (NO ATAPI implementation yet). | |
| 5350 * Both the device capabilities and requested operation mode are | |
| 5351 * considered. | |
| 5352 * | |
| 5353 * Following scsi cdb fields are ignored: | |
| 5354 * rwprotect, dpo, fua, fua_nv, group_number. | |
| 5355 * | |
| 5356 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 5357 * appropriate values in scsi_pkt fields. | |
| 5358 */ | |
| 5359 static int | |
| 5360 sata_txlt_write(sata_pkt_txlate_t *spx) | |
| 5361 { | |
| 5362 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5363 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5364 sata_drive_info_t *sdinfo; | |
| 5365 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5366 int cport = SATA_TXLT_CPORT(spx); | |
| 5367 uint16_t sec_count; | |
| 5368 uint64_t lba; | |
| 5369 int rval; | |
| 5370 int synch; | |
| 5371 | |
| 5372 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5373 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5374 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5375 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 5376 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 5377 return (rval); | |
| 5378 } | |
| 5379 | |
| 5380 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 5381 &spx->txlt_sata_pkt->satapkt_device); | |
| 5382 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5383 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; |
| 1258 | 5384 /* |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5385 * Extract LBA and sector count from scsi CDB |
| 1258 | 5386 */ |
| 5387 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 5388 case SCMD_WRITE: | |
| 5389 /* 6-byte scsi read cmd : 0x0A */ | |
| 5390 lba = (scsipkt->pkt_cdbp[1] & 0x1f); | |
| 5391 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; | |
| 5392 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5393 sec_count = scsipkt->pkt_cdbp[4]; | |
| 5394 /* sec_count 0 will be interpreted as 256 by a device */ | |
| 5395 break; | |
| 5396 case SCMD_WRITE_G1: | |
| 5397 /* 10-bytes scsi write command : 0x2A */ | |
| 5398 lba = scsipkt->pkt_cdbp[2]; | |
| 5399 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5400 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5401 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5402 sec_count = scsipkt->pkt_cdbp[7]; | |
| 5403 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5404 break; | |
| 5405 case SCMD_WRITE_G5: | |
| 5406 /* 12-bytes scsi read command : 0xAA */ | |
| 5407 lba = scsipkt->pkt_cdbp[2]; | |
| 5408 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5409 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5410 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5411 sec_count = scsipkt->pkt_cdbp[6]; | |
| 5412 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; | |
| 5413 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5414 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; | |
| 5415 break; | |
| 5416 case SCMD_WRITE_G4: | |
| 5417 /* 16-bytes scsi write command : 0x8A */ | |
| 5418 lba = scsipkt->pkt_cdbp[2]; | |
| 5419 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5420 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5421 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5422 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; | |
| 5423 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; | |
| 5424 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; | |
| 5425 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; | |
| 5426 sec_count = scsipkt->pkt_cdbp[10]; | |
| 5427 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; | |
| 5428 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; | |
| 5429 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; | |
| 5430 break; | |
| 5431 default: | |
| 5432 /* Unsupported command */ | |
| 5433 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5434 return (sata_txlt_invalid_command(spx)); | |
| 5435 } | |
| 5436 | |
| 5437 /* | |
| 5438 * Check if specified address and length exceeds device capacity | |
| 5439 */ | |
| 5440 if ((lba >= sdinfo->satadrv_capacity) || | |
|
2593
79c4a3cba4f1
6462265 sata: framework rejects last addressable LBA on disk as invalid one
pawelw
parents:
2553
diff
changeset
|
5441 ((lba + sec_count) > sdinfo->satadrv_capacity)) { |
| 1258 | 5442 /* LBA out of range */ |
| 5443 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5444 return (sata_txlt_lba_out_of_range(spx)); | |
| 5445 } | |
| 5446 | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5447 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5448 * For zero-length transfer, emulate good completion of the command |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5449 * (reasons for rejecting the command were already checked). |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5450 * No DMA resources were allocated. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5451 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5452 if (spx->txlt_dma_cookie_list == NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5453 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5454 return (sata_emul_rw_completion(spx)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5455 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5456 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5457 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5458 * Build cmd block depending on the device capability and |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5459 * requested operation mode. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5460 * Do not bother with non-dma mode- we are working only with |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5461 * devices supporting DMA. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
5462 */ |
| 1258 | 5463 scmd->satacmd_addr_type = ATA_ADDR_LBA; |
| 5464 scmd->satacmd_device_reg = SATA_ADH_LBA; | |
| 5465 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; | |
| 5466 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { | |
| 5467 scmd->satacmd_addr_type = ATA_ADDR_LBA48; | |
| 5468 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; | |
| 5469 scmd->satacmd_sec_count_msb = sec_count >> 8; | |
| 5470 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; | |
| 5471 #ifndef __lock_lint | |
| 5472 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; | |
| 5473 scmd->satacmd_lba_high_msb = lba >> 40; | |
| 5474 #endif | |
| 5475 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { | |
| 5476 scmd->satacmd_addr_type = ATA_ADDR_LBA28; | |
| 5477 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); | |
| 5478 } | |
| 5479 scmd->satacmd_sec_count_lsb = sec_count & 0xff; | |
| 5480 scmd->satacmd_lba_low_lsb = lba & 0xff; | |
| 5481 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; | |
| 5482 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; | |
| 5483 scmd->satacmd_features_reg = 0; | |
| 5484 scmd->satacmd_status_reg = 0; | |
| 5485 scmd->satacmd_error_reg = 0; | |
| 5486 | |
| 5487 /* | |
| 5488 * Check if queueing commands should be used and switch | |
| 5489 * to appropriate command if possible | |
| 5490 */ | |
| 5491 if (sata_func_enable & SATA_ENABLE_QUEUING) { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5492 boolean_t using_queuing; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5493 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5494 /* Queuing supported by controller and device? */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5495 if ((sata_func_enable & SATA_ENABLE_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5496 (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5497 SATA_DEV_F_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5498 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5499 SATA_CTLF_NCQ)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5500 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5501 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5502 /* NCQ supported - use FPDMA WRITE */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5503 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5504 SATAC_WRITE_FPDMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5505 scmd->satacmd_features_reg_ext = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5506 scmd->satacmd_sec_count_msb; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5507 scmd->satacmd_sec_count_msb = 0; |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
5508 scmd->satacmd_rle_sata_cmd = &sata_rle_cmd; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5509 } else if ((sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5510 SATA_DEV_F_TCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5511 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5512 SATA_CTLF_QCMD)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5513 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5514 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5515 /* Legacy queueing */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5516 if (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5517 SATA_DEV_F_LBA48) { |
| 1258 | 5518 scmd->satacmd_cmd_reg = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5519 SATAC_WRITE_DMA_QUEUED_EXT; |
| 1258 | 5520 scmd->satacmd_features_reg_ext = |
| 5521 scmd->satacmd_sec_count_msb; | |
| 5522 scmd->satacmd_sec_count_msb = 0; | |
| 5523 } else { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5524 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5525 SATAC_WRITE_DMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5526 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5527 } else /* Queuing not supported */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5528 using_queuing = B_FALSE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5529 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5530 if (using_queuing) { |
| 1258 | 5531 scmd->satacmd_features_reg = |
| 5532 scmd->satacmd_sec_count_lsb; | |
| 5533 scmd->satacmd_sec_count_lsb = 0; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5534 scmd->satacmd_flags.sata_queued = B_TRUE; |
| 1258 | 5535 } |
| 5536 } | |
| 5537 | |
| 5538 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5539 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", | |
| 5540 scmd->satacmd_cmd_reg, lba, sec_count); | |
| 5541 | |
| 5542 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5543 /* Need callback function */ | |
| 5544 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; | |
| 5545 synch = FALSE; | |
| 5546 } else | |
| 5547 synch = TRUE; | |
| 5548 | |
| 5549 /* Transfer command to HBA */ | |
| 5550 if (sata_hba_start(spx, &rval) != 0) { | |
| 5551 /* Pkt not accepted for execution */ | |
| 5552 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5553 return (rval); | |
| 5554 } | |
| 5555 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5556 | |
| 5557 /* | |
| 5558 * If execution is non-synchronous, | |
| 5559 * a callback function will handle potential errors, translate | |
| 5560 * the response and will do a callback to a target driver. | |
| 5561 * If it was synchronous, check execution status using the same | |
| 5562 * framework callback. | |
| 5563 */ | |
| 5564 if (synch) { | |
| 5565 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5566 "synchronous execution status %x\n", | |
| 5567 spx->txlt_sata_pkt->satapkt_reason); | |
| 5568 sata_txlt_rw_completion(spx->txlt_sata_pkt); | |
| 5569 } | |
| 5570 return (TRAN_ACCEPT); | |
| 5571 } | |
| 5572 | |
| 5573 | |
| 5574 /* | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5575 * Implements SCSI SBC WRITE BUFFER command download microcode option |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5576 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5577 static int |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5578 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5579 { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5580 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5581 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5582 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5583 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5584 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5585 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5586 struct scsi_extended_sense *sense; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5587 int rval, mode, sector_count; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5588 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5589 int cport = SATA_TXLT_CPORT(spx); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5590 boolean_t synch; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5591 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5592 synch = (spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH) != 0; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5593 mode = scsipkt->pkt_cdbp[1] & 0x1f; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5594 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5595 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5596 "sata_txlt_write_buffer, mode 0x%x\n", mode); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5597 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5598 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5599 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5600 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5601 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5602 return (rval); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5603 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5604 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5605 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5606 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5607 scsipkt->pkt_reason = CMD_CMPLT; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5608 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5609 STATE_SENT_CMD | STATE_GOT_STATUS; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5610 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5611 /* |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5612 * The SCSI to ATA translation specification only calls |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5613 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5614 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5615 * ATA 8 (draft) got rid of download microcode for temp |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5616 * and it is even optional for ATA 7, so it may be aborted. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5617 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5618 * it is not specified and the buffer offset for SCSI is a 16-bit |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5619 * value in bytes, but for ATA it is a 16-bit offset in 512 byte |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5620 * sectors. Thus the offset really doesn't buy us anything. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5621 * If and when ATA 8 is stabilized and the SCSI to ATA specification |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5622 * is revised, this can be revisisted. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5623 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5624 /* Reject not supported request */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5625 switch (mode) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5626 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5627 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5628 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5629 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5630 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5631 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5632 default: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5633 goto bad_param; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5634 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5635 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5636 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5637 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5638 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5639 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5640 goto bad_param; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5641 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5642 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5643 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5644 scmd->satacmd_lba_mid_lsb = 0; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5645 scmd->satacmd_lba_high_lsb = 0; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5646 scmd->satacmd_device_reg = 0; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5647 spx->txlt_sata_pkt->satapkt_comp = |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5648 sata_txlt_download_mcode_cmd_completion; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5649 scmd->satacmd_addr_type = 0; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5650 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5651 /* Transfer command to HBA */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5652 if (sata_hba_start(spx, &rval) != 0) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5653 /* Pkt not accepted for execution */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5654 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5655 return (rval); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5656 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5657 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5658 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5659 /* |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5660 * If execution is non-synchronous, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5661 * a callback function will handle potential errors, translate |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5662 * the response and will do a callback to a target driver. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5663 * If it was synchronous, check execution status using the same |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5664 * framework callback. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5665 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5666 if (synch) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5667 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5668 "synchronous execution\n", NULL); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5669 /* Calling pre-set completion routine */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5670 (*spx->txlt_sata_pkt->satapkt_comp)(spx->txlt_sata_pkt); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5671 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5672 return (TRAN_ACCEPT); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5673 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5674 bad_param: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5675 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5676 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5677 sense = sata_arq_sense(spx); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5678 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5679 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5680 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5681 scsipkt->pkt_comp != NULL) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5682 /* scsi callback required */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5683 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5684 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5685 TQ_SLEEP) == 0) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5686 /* Scheduling the callback failed */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5687 rval = TRAN_BUSY; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5688 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5689 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5690 return (rval); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5691 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5692 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5693 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5694 /* |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5695 * Retry identify device when command returns SATA_INCOMPLETE_DATA |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5696 * after doing a firmware download. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5697 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5698 static void |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5699 sata_retry_identify_device(void *arg) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5700 { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5701 #define DOWNLOAD_WAIT_TIME_SECS 60 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5702 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5703 int rval; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5704 int retry_cnt; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5705 sata_pkt_t *sata_pkt = (sata_pkt_t *)arg; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5706 sata_pkt_txlate_t *spx = |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5707 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5708 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5709 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5710 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5711 sata_drive_info_t *sdinfo; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5712 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5713 /* |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5714 * Before returning good status, probe device. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5715 * Device probing will get IDENTIFY DEVICE data, if possible. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5716 * The assumption is that the new microcode is applied by the |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5717 * device. It is a caller responsibility to verify this. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5718 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5719 for (retry_cnt = 0; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5720 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5721 retry_cnt++) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5722 rval = sata_probe_device(sata_hba_inst, &sata_device); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5723 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5724 if (rval == SATA_SUCCESS) { /* Set default features */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5725 sdinfo = sata_get_device_info(sata_hba_inst, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5726 &sata_device); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5727 if (sata_initialize_device(sata_hba_inst, sdinfo) != |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5728 SATA_SUCCESS) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5729 /* retry */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5730 (void) sata_initialize_device(sata_hba_inst, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5731 sdinfo); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5732 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5733 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5734 scsipkt->pkt_comp != NULL) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5735 (*scsipkt->pkt_comp)(scsipkt); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5736 return; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5737 } else if (rval == SATA_RETRY) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5738 delay(drv_usectohz(1000000 * |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5739 DOWNLOAD_WAIT_INTERVAL_SECS)); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5740 continue; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5741 } else /* failed - no reason to retry */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5742 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5743 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5744 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5745 /* |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5746 * Something went wrong, device probing failed. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5747 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5748 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5749 "Cannot probe device after downloading microcode\n")); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5750 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5751 /* Reset device to force retrying the probe. */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5752 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5753 (SATA_DIP(sata_hba_inst), &sata_device); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5754 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5755 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5756 scsipkt->pkt_comp != NULL) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5757 (*scsipkt->pkt_comp)(scsipkt); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5758 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5759 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5760 /* |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5761 * Translate completion status of download microcode command. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5762 * pkt completion_reason is checked to determine the completion status. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5763 * Do scsi callback if necessary (FLAG_NOINTR == 0) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5764 * |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5765 * Note: this function may be called also for synchronously executed |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5766 * command. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5767 * This function may be used only if scsi_pkt is non-NULL. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5768 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5769 static void |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5770 sata_txlt_download_mcode_cmd_completion(sata_pkt_t *sata_pkt) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5771 { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5772 sata_pkt_txlate_t *spx = |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5773 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5774 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5775 struct scsi_extended_sense *sense; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5776 sata_drive_info_t *sdinfo; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5777 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5778 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5779 int rval; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5780 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5781 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5782 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5783 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5784 scsipkt->pkt_reason = CMD_CMPLT; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5785 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5786 rval = sata_probe_device(sata_hba_inst, &sata_device); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5787 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5788 if (rval == SATA_SUCCESS) { /* Set default features */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5789 sdinfo = sata_get_device_info(sata_hba_inst, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5790 &sata_device); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5791 if (sata_initialize_device(sata_hba_inst, sdinfo) != |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5792 SATA_SUCCESS) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5793 /* retry */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5794 (void) sata_initialize_device(sata_hba_inst, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5795 sdinfo); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5796 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5797 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5798 scsipkt->pkt_comp != NULL) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5799 (*scsipkt->pkt_comp)(scsipkt); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5800 } else { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5801 (void) ddi_taskq_dispatch( |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5802 (ddi_taskq_t *)SATA_TXLT_TASKQ(spx), |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5803 sata_retry_identify_device, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5804 (void *)sata_pkt, TQ_NOSLEEP); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5805 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5806 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5807 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5808 } else { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5809 /* Something went wrong, microcode download command failed */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5810 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5811 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5812 sense = sata_arq_sense(spx); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5813 switch (sata_pkt->satapkt_reason) { |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5814 case SATA_PKT_PORT_ERROR: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5815 /* |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5816 * We have no device data. Assume no data transfered. |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5817 */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5818 sense->es_key = KEY_HARDWARE_ERROR; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5819 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5820 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5821 case SATA_PKT_DEV_ERROR: |
| 4582 | 5822 if (sata_pkt->satapkt_cmd.satacmd_status_reg & |
| 5823 SATA_STATUS_ERR) { | |
| 5824 /* | |
| 5825 * determine dev error reason from error | |
| 5826 * reg content | |
| 5827 */ | |
| 5828 sata_decode_device_error(spx, sense); | |
| 5829 break; | |
| 5830 } | |
| 5831 /* No extended sense key - no info available */ | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5832 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5833 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5834 case SATA_PKT_TIMEOUT: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5835 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5836 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5837 /* No extended sense key ? */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5838 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5839 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5840 case SATA_PKT_ABORTED: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5841 scsipkt->pkt_reason = CMD_ABORTED; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5842 /* No extended sense key ? */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5843 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5844 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5845 case SATA_PKT_RESET: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5846 /* pkt aborted by an explicit reset from a host */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5847 scsipkt->pkt_reason = CMD_RESET; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5848 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5849 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5850 default: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5851 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5852 "sata_txlt_nodata_cmd_completion: " |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5853 "invalid packet completion reason %d", |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5854 sata_pkt->satapkt_reason)); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5855 scsipkt->pkt_reason = CMD_TRAN_ERR; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5856 break; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5857 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5858 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5859 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5860 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5861 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5862 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5863 scsipkt->pkt_comp != NULL) |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5864 /* scsi callback required */ |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5865 (*scsipkt->pkt_comp)(scsipkt); |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5866 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5867 } |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5868 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5869 |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
5870 /* |
| 1258 | 5871 * NOTE: NOT FUNCTIONAL IMPLEMENTATION. THIS IS A PLACEHOLDER for the function |
| 5872 * that will be fixed in phase 2 of the development. | |
| 5873 * Currently ATAPI is not supported. ATAPI devices are threated as not-valid | |
| 5874 * devices. | |
| 5875 * This function is not called, since scsi_sata_start() will bail-out prior | |
| 5876 * to calling it. | |
| 5877 */ | |
| 5878 static int | |
| 5879 sata_txlt_atapi(sata_pkt_txlate_t *spx) | |
| 5880 { | |
| 5881 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5882 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5883 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 5884 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5885 int cport = SATA_TXLT_CPORT(spx); | |
| 5886 int rval; | |
| 5887 int synch; | |
| 5888 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; | |
| 5889 | |
| 5890 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5891 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5892 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5893 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 5894 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 5895 return (rval); | |
| 5896 } | |
| 5897 | |
| 5898 /* | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5899 * scmd->satacmd_flags.sata_data_direction default - |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5900 * SATA_DIR_NODATA_XFER - is set by |
| 1258 | 5901 * sata_txlt_generic_pkt_info(). |
| 5902 */ | |
| 5903 if (scmd->satacmd_bp) { | |
| 5904 if (scmd->satacmd_bp->b_flags & B_READ) { | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5905 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
| 1258 | 5906 } else { |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5907 scmd->satacmd_flags.sata_data_direction = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5908 SATA_DIR_WRITE; |
| 1258 | 5909 } |
| 5910 } | |
| 5911 | |
| 5912 scmd->satacmd_acdb_len = scsi_cdb_size[GETGROUP(cdbp)]; | |
| 5913 scmd->satacmd_cmd_reg = SATAC_PACKET; | |
| 5914 bcopy(cdbp, scmd->satacmd_acdb, 16); | |
| 5915 | |
| 5916 /* | |
| 5917 * For non-read/write commands we need to | |
| 5918 * map buffer | |
| 5919 */ | |
| 5920 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 5921 case SCMD_READ: | |
| 5922 case SCMD_READ_G1: | |
| 5923 case SCMD_READ_G5: | |
| 5924 case SCMD_READ_G4: | |
| 5925 case SCMD_WRITE: | |
| 5926 case SCMD_WRITE_G1: | |
| 5927 case SCMD_WRITE_G5: | |
| 5928 case SCMD_WRITE_G4: | |
| 5929 break; | |
| 5930 default: | |
| 5931 if (bp->b_flags & (B_PHYS | B_PAGEIO)) | |
| 5932 bp_mapin(bp); | |
| 5933 break; | |
| 5934 } | |
| 5935 | |
| 5936 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5937 /* Need callback function */ | |
| 5938 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; | |
| 5939 synch = FALSE; | |
| 5940 } else | |
| 5941 synch = TRUE; | |
| 5942 | |
| 5943 /* Transfer command to HBA */ | |
| 5944 if (sata_hba_start(spx, &rval) != 0) { | |
| 5945 /* Pkt not accepted for execution */ | |
| 5946 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5947 return (rval); | |
| 5948 } | |
| 5949 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5950 /* | |
| 5951 * If execution is non-synchronous, | |
| 5952 * a callback function will handle potential errors, translate | |
| 5953 * the response and will do a callback to a target driver. | |
| 5954 * If it was synchronous, check execution status using the same | |
| 5955 * framework callback. | |
| 5956 */ | |
| 5957 if (synch) { | |
| 5958 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5959 "synchronous execution status %x\n", | |
| 5960 spx->txlt_sata_pkt->satapkt_reason); | |
| 5961 sata_txlt_atapi_completion(spx->txlt_sata_pkt); | |
| 5962 } | |
| 5963 return (TRAN_ACCEPT); | |
| 5964 } | |
| 5965 | |
| 5966 /* | |
| 5967 * Translate command: Synchronize Cache. | |
| 5968 * Translates into Flush Cache command. | |
| 5969 * (NO ATAPI implementation yet). | |
| 5970 * | |
| 5971 * NOTE: We should check if Flush Cache is supported by the device (ATAPI | |
| 5972 * devices) | |
| 5973 * | |
| 5974 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 5975 * appropriate values in scsi_pkt fields. | |
| 5976 */ | |
| 5977 static int | |
| 5978 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) | |
| 5979 { | |
| 5980 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5981 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5982 int cport = SATA_TXLT_CPORT(spx); | |
| 5983 int rval; | |
| 5984 int synch; | |
| 5985 | |
| 5986 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5987 | |
|
4010
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5988 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || |
|
d83e031dd201
6543221 sata: should abort processing a command when device is gone and scsi pkt callback is scheduled
pawelw
parents:
3935
diff
changeset
|
5989 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { |
| 1258 | 5990 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
| 5991 return (rval); | |
| 5992 } | |
| 5993 | |
| 5994 scmd->satacmd_addr_type = 0; | |
| 5995 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; | |
| 5996 scmd->satacmd_device_reg = 0; | |
| 5997 scmd->satacmd_sec_count_lsb = 0; | |
| 5998 scmd->satacmd_lba_low_lsb = 0; | |
| 5999 scmd->satacmd_lba_mid_lsb = 0; | |
| 6000 scmd->satacmd_lba_high_lsb = 0; | |
| 6001 scmd->satacmd_features_reg = 0; | |
| 6002 scmd->satacmd_status_reg = 0; | |
| 6003 scmd->satacmd_error_reg = 0; | |
| 6004 | |
| 6005 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6006 "sata_txlt_synchronize_cache\n", NULL); | |
| 6007 | |
| 6008 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 6009 /* Need to set-up a callback function */ | |
| 6010 spx->txlt_sata_pkt->satapkt_comp = | |
| 6011 sata_txlt_nodata_cmd_completion; | |
| 6012 synch = FALSE; | |
| 6013 } else | |
| 6014 synch = TRUE; | |
| 6015 | |
| 6016 /* Transfer command to HBA */ | |
| 6017 if (sata_hba_start(spx, &rval) != 0) { | |
| 6018 /* Pkt not accepted for execution */ | |
| 6019 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 6020 return (rval); | |
| 6021 } | |
| 6022 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 6023 | |
| 6024 /* | |
| 6025 * If execution non-synchronous, it had to be completed | |
| 6026 * a callback function will handle potential errors, translate | |
| 6027 * the response and will do a callback to a target driver. | |
| 6028 * If it was synchronous, check status, using the same | |
| 6029 * framework callback. | |
| 6030 */ | |
| 6031 if (synch) { | |
| 6032 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6033 "synchronous execution status %x\n", | |
| 6034 spx->txlt_sata_pkt->satapkt_reason); | |
| 6035 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); | |
| 6036 } | |
| 6037 return (TRAN_ACCEPT); | |
| 6038 } | |
| 6039 | |
| 6040 /* | |
| 6041 * Send pkt to SATA HBA driver | |
| 6042 * | |
| 6043 * This function may be called only if the operation is requested by scsi_pkt, | |
| 6044 * i.e. scsi_pkt is not NULL. | |
| 6045 * | |
| 6046 * This function has to be called with cport mutex held. It does release | |
| 6047 * the mutex when it calls HBA driver sata_tran_start function and | |
| 6048 * re-acquires it afterwards. | |
| 6049 * | |
| 6050 * If return value is 0, pkt was accepted, -1 otherwise | |
| 6051 * rval is set to appropriate sata_scsi_start return value. | |
| 6052 * | |
| 6053 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not | |
| 6054 * have called the sata_pkt callback function for this packet. | |
| 6055 * | |
| 6056 * The scsi callback has to be performed by the caller of this routine. | |
| 6057 * | |
| 6058 * Note 2: No port multiplier support for now. | |
| 6059 */ | |
| 6060 static int | |
| 6061 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) | |
| 6062 { | |
|
3116
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6063 int stat, cport; |
| 1258 | 6064 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; |
| 6065 sata_drive_info_t *sdinfo; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6066 sata_device_t *sata_device; |
| 1258 | 6067 uint8_t cmd; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6068 struct sata_cmd_flags cmd_flags; |
| 1258 | 6069 |
| 6070 ASSERT(spx->txlt_sata_pkt != NULL); | |
|
3116
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6071 |
|
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6072 cport = SATA_TXLT_CPORT(spx); |
|
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6073 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); |
| 1258 | 6074 |
| 6075 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 6076 &spx->txlt_sata_pkt->satapkt_device); | |
| 6077 ASSERT(sdinfo != NULL); | |
| 6078 | |
| 6079 /* Clear device reset state? */ | |
| 6080 if (sdinfo->satadrv_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6081 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6082 sata_clear_dev_reset = B_TRUE; |
| 1258 | 6083 sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET; |
| 6084 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 6085 "sata_hba_start: clearing device reset state\n", NULL); | |
| 6086 } | |
| 6087 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; | |
| 6088 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6089 sata_device = &spx->txlt_sata_pkt->satapkt_device; |
| 1258 | 6090 |
|
3116
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6091 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); |
| 1258 | 6092 |
| 6093 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6094 "Sata cmd 0x%2x\n", cmd); | |
| 6095 | |
| 6096 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), | |
| 6097 spx->txlt_sata_pkt); | |
| 6098 | |
|
3116
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6099 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); |
|
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6100 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); |
| 1258 | 6101 /* |
| 6102 * If sata pkt was accepted and executed in asynchronous mode, i.e. | |
| 6103 * with the sata callback, the sata_pkt could be already destroyed | |
| 6104 * by the time we check ther return status from the hba_start() | |
| 6105 * function, because sata_scsi_destroy_pkt() could have been already | |
| 6106 * called (perhaps in the interrupt context). So, in such case, there | |
| 6107 * should be no references to it. In other cases, sata_pkt still | |
| 6108 * exists. | |
| 6109 */ | |
| 6110 switch (stat) { | |
| 6111 case SATA_TRAN_ACCEPTED: | |
| 6112 /* | |
| 6113 * pkt accepted for execution. | |
| 6114 * If it was executed synchronously, it is already completed | |
| 6115 * and pkt completion_reason indicates completion status. | |
| 6116 */ | |
| 6117 *rval = TRAN_ACCEPT; | |
| 6118 return (0); | |
| 6119 | |
| 6120 case SATA_TRAN_QUEUE_FULL: | |
| 6121 /* | |
| 6122 * Controller detected queue full condition. | |
| 6123 */ | |
| 6124 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, | |
| 6125 "sata_hba_start: queue full\n", NULL); | |
| 6126 | |
| 6127 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 6128 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; | |
| 6129 | |
| 6130 *rval = TRAN_BUSY; | |
| 6131 break; | |
| 6132 | |
| 6133 case SATA_TRAN_PORT_ERROR: | |
| 6134 /* | |
| 6135 * Communication/link with device or general port error | |
| 6136 * detected before pkt execution begun. | |
| 6137 */ | |
| 6138 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6139 SATA_ADDR_CPORT || |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6140 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6141 SATA_ADDR_DCPORT) |
| 1258 | 6142 sata_log(sata_hba_inst, CE_CONT, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6143 "SATA port %d error", |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6144 sata_device->satadev_addr.cport); |
| 1258 | 6145 else |
| 6146 sata_log(sata_hba_inst, CE_CONT, | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6147 "SATA port %d pmport %d error\n", |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6148 sata_device->satadev_addr.cport, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6149 sata_device->satadev_addr.pmport); |
| 1258 | 6150 |
| 6151 /* | |
| 6152 * Update the port/device structure. | |
| 6153 * sata_pkt should be still valid. Since port error is | |
| 6154 * returned, sata_device content should reflect port | |
| 6155 * state - it means, that sata address have been changed, | |
| 6156 * because original packet's sata address refered to a device | |
| 6157 * attached to some port. | |
| 6158 */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6159 sata_update_port_info(sata_hba_inst, sata_device); |
| 1258 | 6160 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; |
| 6161 *rval = TRAN_FATAL_ERROR; | |
| 6162 break; | |
| 6163 | |
| 6164 case SATA_TRAN_CMD_UNSUPPORTED: | |
| 6165 /* | |
| 6166 * Command rejected by HBA as unsupported. It was HBA driver | |
| 6167 * that rejected the command, command was not sent to | |
| 6168 * an attached device. | |
| 6169 */ | |
|
3116
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6170 if ((sdinfo != NULL) && |
|
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6171 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) |
| 1258 | 6172 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, |
| 6173 "sat_hba_start: cmd 0x%2x rejected " | |
| 6174 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); | |
| 6175 | |
|
3116
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6176 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); |
|
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6177 (void) sata_txlt_invalid_command(spx); |
|
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6178 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); |
|
e4293e8671d8
6488114 system panic after unplugging disks during diskomizer/dd run
yt160523
parents:
3023
diff
changeset
|
6179 |
| 1258 | 6180 *rval = TRAN_ACCEPT; |
| 6181 break; | |
| 6182 | |
| 6183 case SATA_TRAN_BUSY: | |
| 6184 /* | |
| 6185 * Command rejected by HBA because other operation prevents | |
| 6186 * accepting the packet, or device is in RESET condition. | |
| 6187 */ | |
| 6188 if (sdinfo != NULL) { | |
| 6189 sdinfo->satadrv_state = | |
| 6190 spx->txlt_sata_pkt->satapkt_device.satadev_state; | |
| 6191 | |
| 6192 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { | |
| 6193 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 6194 "sata_hba_start: cmd 0x%2x rejected " | |
| 6195 "because of device reset condition\n", | |
| 6196 cmd); | |
| 6197 } else { | |
| 6198 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 6199 "sata_hba_start: cmd 0x%2x rejected " | |
| 6200 "with SATA_TRAN_BUSY status\n", | |
| 6201 cmd); | |
| 6202 } | |
| 6203 } | |
| 6204 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 6205 *rval = TRAN_BUSY; | |
| 6206 break; | |
| 6207 | |
| 6208 default: | |
| 6209 /* Unrecognized HBA response */ | |
| 6210 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 6211 "sata_hba_start: unrecognized HBA response " | |
| 6212 "to cmd : 0x%2x resp 0x%x", cmd, rval)); | |
| 6213 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; | |
| 6214 *rval = TRAN_FATAL_ERROR; | |
| 6215 break; | |
| 6216 } | |
| 6217 | |
| 6218 /* | |
| 6219 * If we got here, the packet was rejected. | |
| 6220 * Check if we need to remember reset state clearing request | |
| 6221 */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6222 if (cmd_flags.sata_clear_dev_reset) { |
| 1258 | 6223 /* |
| 6224 * Check if device is still configured - it may have | |
| 6225 * disapeared from the configuration | |
| 6226 */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
6227 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); |
| 1258 | 6228 if (sdinfo != NULL) { |
| 6229 /* | |
| 6230 * Restore the flag that requests clearing of | |
| 6231 * the device reset state, | |
| 6232 * so the next sata packet may carry it to HBA. | |
| 6233 */ | |
| 6234 sdinfo->satadrv_event_flags |= | |
| 6235 SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 6236 } | |
| 6237 } | |
| 6238 return (-1); | |
| 6239 } | |
| 6240 | |
| 6241 /* | |
| 6242 * Scsi response setup for invalid LBA | |
| 6243 * | |
| 6244 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 6245 */ | |
| 6246 static int | |
| 6247 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) | |
| 6248 { | |
| 6249 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6250 struct scsi_extended_sense *sense; | |
| 6251 | |
| 6252 scsipkt->pkt_reason = CMD_CMPLT; | |
| 6253 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4582 | 6254 STATE_SENT_CMD | STATE_GOT_STATUS; |
| 1258 | 6255 *scsipkt->pkt_scbp = STATUS_CHECK; |
| 6256 | |
| 6257 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 6258 sense = sata_arq_sense(spx); | |
| 6259 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 6260 sense->es_add_code = SD_SCSI_LBA_OUT_OF_RANGE; | |
| 6261 | |
| 6262 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6263 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 6264 | |
| 6265 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 6266 scsipkt->pkt_comp != NULL) | |
| 6267 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
6268 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
6269 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6270 TQ_SLEEP) == NULL) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
6271 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
6272 return (TRAN_BUSY); |
| 1258 | 6273 return (TRAN_ACCEPT); |
| 6274 } | |
| 6275 | |
| 6276 | |
| 6277 /* | |
| 6278 * Analyze device status and error registers and translate them into | |
| 6279 * appropriate scsi sense codes. | |
| 6280 * NOTE: non-packet commands only for now | |
| 6281 */ | |
| 6282 static void | |
| 6283 sata_decode_device_error(sata_pkt_txlate_t *spx, | |
| 6284 struct scsi_extended_sense *sense) | |
| 6285 { | |
| 6286 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; | |
| 6287 | |
| 6288 ASSERT(sense != NULL); | |
| 6289 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 6290 SATA_STATUS_ERR); | |
| 6291 | |
| 6292 | |
| 6293 if (err_reg & SATA_ERROR_ICRC) { | |
| 6294 sense->es_key = KEY_ABORTED_COMMAND; | |
| 6295 sense->es_add_code = 0x08; /* Communication failure */ | |
| 6296 return; | |
| 6297 } | |
| 6298 | |
| 6299 if (err_reg & SATA_ERROR_UNC) { | |
| 6300 sense->es_key = KEY_MEDIUM_ERROR; | |
| 6301 /* Information bytes (LBA) need to be set by a caller */ | |
| 6302 return; | |
| 6303 } | |
| 6304 | |
| 6305 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ | |
| 6306 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { | |
| 6307 sense->es_key = KEY_UNIT_ATTENTION; | |
| 6308 sense->es_add_code = 0x3a; /* No media present */ | |
| 6309 return; | |
| 6310 } | |
| 6311 | |
| 6312 if (err_reg & SATA_ERROR_IDNF) { | |
| 6313 if (err_reg & SATA_ERROR_ABORT) { | |
| 6314 sense->es_key = KEY_ABORTED_COMMAND; | |
| 6315 } else { | |
| 6316 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 6317 sense->es_add_code = 0x21; /* LBA out of range */ | |
| 6318 } | |
| 6319 return; | |
| 6320 } | |
| 6321 | |
| 6322 if (err_reg & SATA_ERROR_ABORT) { | |
| 6323 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 6324 sense->es_key = KEY_ABORTED_COMMAND; | |
| 6325 return; | |
| 6326 } | |
| 6327 } | |
| 6328 | |
| 6329 /* | |
| 6330 * Extract error LBA from sata_pkt.satapkt_cmd register fields | |
| 6331 */ | |
| 6332 static void | |
| 6333 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) | |
| 6334 { | |
| 6335 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 6336 | |
| 6337 *lba = 0; | |
| 6338 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { | |
| 6339 *lba = sata_cmd->satacmd_lba_high_msb; | |
| 6340 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; | |
| 6341 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; | |
| 6342 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { | |
| 6343 *lba = sata_cmd->satacmd_device_reg & 0xf; | |
| 6344 } | |
| 6345 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; | |
| 6346 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
6347 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; |
| 1258 | 6348 } |
| 6349 | |
| 6350 /* | |
| 6351 * This is fixed sense format - if LBA exceeds the info field size, | |
| 6352 * no valid info will be returned (valid bit in extended sense will | |
| 6353 * be set to 0). | |
| 6354 */ | |
| 6355 static struct scsi_extended_sense * | |
| 6356 sata_arq_sense(sata_pkt_txlate_t *spx) | |
| 6357 { | |
| 6358 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6359 struct scsi_arq_status *arqs; | |
| 6360 struct scsi_extended_sense *sense; | |
| 6361 | |
| 6362 /* Fill ARQ sense data */ | |
| 6363 scsipkt->pkt_state |= STATE_ARQ_DONE; | |
| 6364 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; | |
| 6365 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; | |
| 6366 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; | |
| 6367 arqs->sts_rqpkt_reason = CMD_CMPLT; | |
| 6368 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6369 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 6370 arqs->sts_rqpkt_resid = 0; | |
| 6371 sense = &arqs->sts_sensedata; | |
| 6372 bzero(sense, sizeof (struct scsi_extended_sense)); | |
| 6373 sense->es_valid = 1; /* Valid sense */ | |
| 6374 sense->es_class = 7; /* Response code 0x70 - current err */ | |
| 6375 sense->es_key = KEY_NO_SENSE; | |
| 6376 sense->es_info_1 = 0; | |
| 6377 sense->es_info_2 = 0; | |
| 6378 sense->es_info_3 = 0; | |
| 6379 sense->es_info_4 = 0; | |
| 6380 sense->es_add_len = 6; /* Additional length */ | |
| 6381 sense->es_cmd_info[0] = 0; | |
| 6382 sense->es_cmd_info[1] = 0; | |
| 6383 sense->es_cmd_info[2] = 0; | |
| 6384 sense->es_cmd_info[3] = 0; | |
| 6385 sense->es_add_code = 0; | |
| 6386 sense->es_qual_code = 0; | |
| 6387 return (sense); | |
| 6388 } | |
| 6389 | |
| 6390 | |
| 6391 /* | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6392 * Emulated SATA Read/Write command completion for zero-length requests. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6393 * This request always succedes, so in synchronous mode it always returns |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6394 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6395 * callback cannot be scheduled. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6396 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6397 static int |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6398 sata_emul_rw_completion(sata_pkt_txlate_t *spx) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6399 { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6400 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6401 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6402 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6403 STATE_SENT_CMD | STATE_GOT_STATUS; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6404 scsipkt->pkt_reason = CMD_CMPLT; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6405 *scsipkt->pkt_scbp = STATUS_GOOD; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6406 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6407 /* scsi callback required - have to schedule it */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6408 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6409 (task_func_t *)scsipkt->pkt_comp, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6410 (void *)scsipkt, TQ_SLEEP) == NULL) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6411 /* Scheduling the callback failed */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6412 return (TRAN_BUSY); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6413 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6414 return (TRAN_ACCEPT); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6415 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6416 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6417 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
6418 /* |
| 1258 | 6419 * Translate completion status of SATA read/write commands into scsi response. |
| 6420 * pkt completion_reason is checked to determine the completion status. | |
| 6421 * Do scsi callback if necessary. | |
| 6422 * | |
| 6423 * Note: this function may be called also for synchronously executed | |
| 6424 * commands. | |
| 6425 * This function may be used only if scsi_pkt is non-NULL. | |
| 6426 */ | |
| 6427 static void | |
| 6428 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) | |
| 6429 { | |
| 6430 sata_pkt_txlate_t *spx = | |
| 6431 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 6432 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; | |
| 6433 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6434 struct scsi_extended_sense *sense; | |
| 6435 uint64_t lba; | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6436 struct buf *bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6437 int rval; |
| 1258 | 6438 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { |
| 6439 /* Normal completion */ | |
| 6440 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6441 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; | |
| 6442 scsipkt->pkt_reason = CMD_CMPLT; | |
| 6443 *scsipkt->pkt_scbp = STATUS_GOOD; | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6444 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6445 /* Temporary buffer was used */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6446 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6447 if (bp->b_flags & B_READ) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6448 rval = ddi_dma_sync( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6449 spx->txlt_buf_dma_handle, 0, 0, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6450 DDI_DMA_SYNC_FORCPU); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6451 ASSERT(rval == DDI_SUCCESS); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6452 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6453 bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6454 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
6455 } |
| 1258 | 6456 } else { |
| 6457 /* | |
| 6458 * Something went wrong - analyze return | |
| 6459 */ | |
| 6460 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6461 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 6462 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 6463 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 6464 sense = sata_arq_sense(spx); | |
| 6465 ASSERT(sense != NULL); | |
| 6466 | |
| 6467 /* | |
| 6468 * SATA_PKT_DEV_ERROR is the only case where we may be able to | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6469 * extract from device registers the failing LBA. |
| 1258 | 6470 */ |
| 6471 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { | |
| 6472 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && | |
| 6473 (scmd->satacmd_lba_mid_msb != 0 || | |
| 6474 scmd->satacmd_lba_high_msb != 0)) { | |
| 6475 /* | |
| 6476 * We have problem reporting this cmd LBA | |
| 6477 * in fixed sense data format, because of | |
| 6478 * the size of the scsi LBA fields. | |
| 6479 */ | |
| 6480 sense->es_valid = 0; | |
| 6481 } else { | |
| 6482 sata_extract_error_lba(spx, &lba); | |
| 6483 sense->es_info_1 = (lba & 0xFF000000) >> 24; | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
6484 sense->es_info_2 = (lba & 0xFF0000) >> 16; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
6485 sense->es_info_3 = (lba & 0xFF00) >> 8; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
6486 sense->es_info_4 = lba & 0xFF; |
| 1258 | 6487 } |
| 6488 } else { | |
| 6489 /* Invalid extended sense info */ | |
| 6490 sense->es_valid = 0; | |
| 6491 } | |
| 6492 | |
| 6493 switch (sata_pkt->satapkt_reason) { | |
| 6494 case SATA_PKT_PORT_ERROR: | |
| 6495 /* We may want to handle DEV GONE state as well */ | |
| 6496 /* | |
| 6497 * We have no device data. Assume no data transfered. | |
| 6498 */ | |
| 6499 sense->es_key = KEY_HARDWARE_ERROR; | |
| 6500 break; | |
| 6501 | |
| 6502 case SATA_PKT_DEV_ERROR: | |
| 6503 if (sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 6504 SATA_STATUS_ERR) { | |
| 6505 /* | |
| 6506 * determine dev error reason from error | |
| 6507 * reg content | |
| 6508 */ | |
| 6509 sata_decode_device_error(spx, sense); | |
| 6510 if (sense->es_key == KEY_MEDIUM_ERROR) { | |
| 6511 switch (scmd->satacmd_cmd_reg) { | |
| 6512 case SATAC_READ_DMA: | |
| 6513 case SATAC_READ_DMA_EXT: | |
| 6514 case SATAC_READ_DMA_QUEUED: | |
| 6515 case SATAC_READ_DMA_QUEUED_EXT: | |
| 6516 case SATAC_READ_FPDMA_QUEUED: | |
| 6517 /* Unrecovered read error */ | |
| 6518 sense->es_add_code = | |
| 6519 SD_SCSI_UNREC_READ_ERROR; | |
| 6520 break; | |
| 6521 case SATAC_WRITE_DMA: | |
| 6522 case SATAC_WRITE_DMA_EXT: | |
| 6523 case SATAC_WRITE_DMA_QUEUED: | |
| 6524 case SATAC_WRITE_DMA_QUEUED_EXT: | |
| 6525 case SATAC_WRITE_FPDMA_QUEUED: | |
| 6526 /* Write error */ | |
| 6527 sense->es_add_code = | |
| 6528 SD_SCSI_WRITE_ERROR; | |
| 6529 break; | |
| 6530 default: | |
| 6531 /* Internal error */ | |
| 6532 SATA_LOG_D(( | |
| 6533 spx->txlt_sata_hba_inst, | |
| 6534 CE_WARN, | |
| 6535 "sata_txlt_rw_completion :" | |
| 6536 "internal error - invalid " | |
| 6537 "command 0x%2x", | |
| 6538 scmd->satacmd_cmd_reg)); | |
| 6539 break; | |
| 6540 } | |
| 6541 } | |
| 6542 break; | |
| 6543 } | |
| 6544 /* No extended sense key - no info available */ | |
| 6545 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 6546 break; | |
| 6547 | |
| 6548 case SATA_PKT_TIMEOUT: | |
| 6549 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ | |
| 6550 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 6551 /* No extended sense key ? */ | |
| 6552 break; | |
| 6553 | |
| 6554 case SATA_PKT_ABORTED: | |
| 6555 scsipkt->pkt_reason = CMD_ABORTED; | |
| 6556 /* No extended sense key ? */ | |
| 6557 break; | |
| 6558 | |
| 6559 case SATA_PKT_RESET: | |
| 6560 scsipkt->pkt_reason = CMD_RESET; | |
| 6561 break; | |
| 6562 | |
| 6563 default: | |
| 6564 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 6565 "sata_txlt_rw_completion: " | |
| 6566 "invalid packet completion reason")); | |
| 6567 scsipkt->pkt_reason = CMD_TRAN_ERR; | |
| 6568 break; | |
| 6569 } | |
| 6570 } | |
| 6571 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6572 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 6573 | |
| 6574 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 6575 scsipkt->pkt_comp != NULL) | |
| 6576 /* scsi callback required */ | |
| 6577 (*scsipkt->pkt_comp)(scsipkt); | |
| 6578 } | |
| 6579 | |
| 6580 /* | |
| 6581 * NON FUNCTIONAL IMPLEMENTATION. THIS IS A PLACE HOLDER. | |
| 6582 * ATAPI devices are not supported currently (are not be attached recognized | |
| 6583 * as valid devices). | |
| 6584 * Will be fixed in phase 2 of the development. | |
| 6585 */ | |
| 6586 static void | |
| 6587 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) | |
| 6588 { | |
| 6589 sata_pkt_txlate_t *spx = | |
| 6590 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 6591 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6592 struct scsi_arq_status *arqs; | |
| 6593 | |
| 6594 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { | |
| 6595 /* Normal completion */ | |
| 6596 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6597 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; | |
| 6598 scsipkt->pkt_reason = CMD_CMPLT; | |
| 6599 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 6600 scsipkt->pkt_resid = 0; | |
| 6601 } else { | |
| 6602 /* | |
| 6603 * Something went wrong - analyze return | |
| 6604 */ | |
| 6605 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6606 STATE_SENT_CMD | STATE_GOT_STATUS | STATE_ARQ_DONE; | |
| 6607 scsipkt->pkt_reason = CMD_CMPLT; | |
| 6608 | |
| 6609 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; | |
| 6610 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; | |
| 6611 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; | |
| 6612 arqs->sts_rqpkt_reason = CMD_CMPLT; | |
| 6613 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6614 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 6615 arqs->sts_rqpkt_resid = 0; | |
| 6616 | |
| 6617 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, | |
| 6618 &arqs->sts_sensedata, SATA_ATAPI_RQSENSE_LEN); | |
| 6619 } | |
| 6620 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6621 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 6622 | |
| 6623 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 6624 scsipkt->pkt_comp != NULL) { | |
| 6625 /* scsi callback required */ | |
| 6626 (*scsipkt->pkt_comp)(scsipkt); | |
| 6627 } | |
| 6628 } | |
| 6629 | |
| 6630 | |
| 6631 /* | |
| 6632 * Translate completion status of non-data commands (i.e. commands returning | |
| 6633 * no data). | |
| 6634 * pkt completion_reason is checked to determine the completion status. | |
| 6635 * Do scsi callback if necessary (FLAG_NOINTR == 0) | |
| 6636 * | |
| 6637 * Note: this function may be called also for synchronously executed | |
| 6638 * commands. | |
| 6639 * This function may be used only if scsi_pkt is non-NULL. | |
| 6640 */ | |
| 6641 | |
| 6642 static void | |
| 6643 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) | |
| 6644 { | |
| 6645 sata_pkt_txlate_t *spx = | |
| 6646 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 6647 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6648 struct scsi_extended_sense *sense; | |
| 6649 | |
| 6650 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6651 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 6652 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { | |
| 6653 /* Normal completion */ | |
| 6654 scsipkt->pkt_reason = CMD_CMPLT; | |
| 6655 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 6656 } else { | |
| 6657 /* Something went wrong */ | |
| 6658 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 6659 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 6660 sense = sata_arq_sense(spx); | |
| 6661 switch (sata_pkt->satapkt_reason) { | |
| 6662 case SATA_PKT_PORT_ERROR: | |
| 6663 /* | |
| 6664 * We have no device data. Assume no data transfered. | |
| 6665 */ | |
| 6666 sense->es_key = KEY_HARDWARE_ERROR; | |
| 6667 break; | |
| 6668 | |
| 6669 case SATA_PKT_DEV_ERROR: | |
| 4582 | 6670 if (sata_pkt->satapkt_cmd.satacmd_status_reg & |
| 6671 SATA_STATUS_ERR) { | |
| 6672 /* | |
| 6673 * determine dev error reason from error | |
| 6674 * reg content | |
| 6675 */ | |
| 6676 sata_decode_device_error(spx, sense); | |
| 6677 break; | |
| 6678 } | |
| 6679 /* No extended sense key - no info available */ | |
| 1258 | 6680 break; |
| 6681 | |
| 6682 case SATA_PKT_TIMEOUT: | |
| 6683 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ | |
| 6684 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 6685 /* No extended sense key ? */ | |
| 6686 break; | |
| 6687 | |
| 6688 case SATA_PKT_ABORTED: | |
| 6689 scsipkt->pkt_reason = CMD_ABORTED; | |
| 6690 /* No extended sense key ? */ | |
| 6691 break; | |
| 6692 | |
| 6693 case SATA_PKT_RESET: | |
| 6694 /* pkt aborted by an explicit reset from a host */ | |
| 6695 scsipkt->pkt_reason = CMD_RESET; | |
| 6696 break; | |
| 6697 | |
| 6698 default: | |
| 6699 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 6700 "sata_txlt_nodata_cmd_completion: " | |
| 6701 "invalid packet completion reason %d", | |
| 6702 sata_pkt->satapkt_reason)); | |
| 6703 scsipkt->pkt_reason = CMD_TRAN_ERR; | |
| 6704 break; | |
| 6705 } | |
| 6706 | |
| 6707 } | |
| 6708 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6709 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 6710 | |
| 6711 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 6712 scsipkt->pkt_comp != NULL) | |
| 6713 /* scsi callback required */ | |
| 6714 (*scsipkt->pkt_comp)(scsipkt); | |
| 6715 } | |
| 6716 | |
| 6717 | |
| 6718 /* | |
| 6719 * Build Mode sense R/W recovery page | |
| 6720 * NOT IMPLEMENTED | |
| 6721 */ | |
| 6722 | |
| 6723 static int | |
| 6724 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6725 { | |
| 6726 #ifndef __lock_lint | |
| 6727 _NOTE(ARGUNUSED(sdinfo)) | |
| 6728 _NOTE(ARGUNUSED(pcntrl)) | |
| 6729 _NOTE(ARGUNUSED(buf)) | |
| 6730 #endif | |
| 6731 return (0); | |
| 6732 } | |
| 6733 | |
| 6734 /* | |
| 6735 * Build Mode sense caching page - scsi-3 implementation. | |
| 6736 * Page length distinguishes previous format from scsi-3 format. | |
| 6737 * buf must have space for 0x12 bytes. | |
| 6738 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. | |
| 6739 * | |
| 6740 */ | |
| 6741 static int | |
| 6742 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6743 { | |
| 6744 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; | |
| 6745 sata_id_t *sata_id = &sdinfo->satadrv_id; | |
| 6746 | |
| 6747 /* | |
| 6748 * Most of the fields are set to 0, being not supported and/or disabled | |
| 6749 */ | |
| 6750 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); | |
| 6751 | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6752 /* Saved paramters not supported */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6753 if (pcntrl == 3) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6754 return (0); |
| 1258 | 6755 if (pcntrl == 0 || pcntrl == 2) { |
| 6756 /* | |
| 6757 * For now treat current and default parameters as same | |
| 6758 * That may have to change, if target driver will complain | |
| 6759 */ | |
| 6760 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ | |
| 6761 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; | |
| 6762 | |
| 6763 if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 6764 !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) { | |
| 6765 page->dra = 1; /* Read Ahead disabled */ | |
| 6766 page->rcd = 1; /* Read Cache disabled */ | |
| 6767 } | |
| 6768 if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) && | |
| 6769 (sata_id->ai_features85 & SATA_WRITE_CACHE)) | |
| 6770 page->wce = 1; /* Write Cache enabled */ | |
| 6771 } else { | |
| 6772 /* Changeable parameters */ | |
| 6773 page->mode_page.code = MODEPAGE_CACHING; | |
| 6774 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; | |
| 6775 if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) { | |
| 6776 page->dra = 1; | |
| 6777 page->rcd = 1; | |
| 6778 } | |
| 6779 if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE) | |
| 6780 page->wce = 1; | |
| 6781 } | |
| 6782 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + | |
| 4582 | 6783 sizeof (struct mode_page)); |
| 1258 | 6784 } |
| 6785 | |
| 6786 /* | |
| 6787 * Build Mode sense exception cntrl page | |
| 6788 */ | |
| 6789 static int | |
| 6790 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6791 { | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6792 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6793 sata_id_t *sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6794 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6795 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6796 * Most of the fields are set to 0, being not supported and/or disabled |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6797 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6798 bzero(buf, PAGELENGTH_INFO_EXCPT); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6799 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6800 page->mode_page.code = MODEPAGE_INFO_EXCPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6801 page->mode_page.length = PAGELENGTH_INFO_EXCPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6802 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6803 /* Indicate that this is page is saveable */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6804 page->mode_page.ps = 1; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6805 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6806 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6807 * We will return the same data for default, current and saved page. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6808 * The only changeable bit is dexcpt and that bit is required |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6809 * by the ATA specification to be preserved across power cycles. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6810 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6811 if (pcntrl != 1) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6812 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6813 page->mrie = MRIE_ONLY_ON_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6814 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6815 else |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6816 page->dexcpt = 1; /* Only changeable parameter */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6817 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6818 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page)); |
| 1258 | 6819 } |
| 6820 | |
| 6821 | |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6822 static int |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6823 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6824 { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6825 struct mode_acoustic_management *page = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6826 (struct mode_acoustic_management *)buf; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6827 sata_id_t *sata_id = &sdinfo->satadrv_id; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6828 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6829 /* |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6830 * Most of the fields are set to 0, being not supported and/or disabled |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6831 */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6832 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6833 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6834 switch (pcntrl) { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6835 case P_CNTRL_DEFAULT: |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6836 /* default paramters not supported */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6837 return (0); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6838 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6839 case P_CNTRL_CURRENT: |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6840 case P_CNTRL_SAVED: |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6841 /* Saved and current are supported and are identical */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6842 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6843 page->mode_page.length = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6844 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6845 page->mode_page.ps = 1; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6846 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6847 /* Word 83 indicates if feature is supported */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6848 /* If feature is not supported */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6849 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6850 page->acoustic_manag_enable = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6851 ACOUSTIC_DISABLED; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6852 } else { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6853 page->acoustic_manag_enable = |
|
4837
fe2f53c9eb50
6556577 Need to support Advanced Acoustic Management Feature (AAM (fix lint)
ls24207
parents:
4836
diff
changeset
|
6854 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6855 != 0); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6856 /* Word 94 inidicates the value */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6857 #ifdef _LITTLE_ENDIAN |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6858 page->acoustic_manag_level = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6859 (uchar_t)sata_id->ai_acoustic; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6860 page->vendor_recommended_value = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6861 sata_id->ai_acoustic >> 8; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6862 #else |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6863 page->acoustic_manag_level = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6864 sata_id->ai_acoustic >> 8; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6865 page->vendor_recommended_value = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6866 (uchar_t)sata_id->ai_acoustic; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6867 #endif |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6868 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6869 break; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6870 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6871 case P_CNTRL_CHANGEABLE: |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6872 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6873 page->mode_page.length = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6874 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6875 page->mode_page.ps = 1; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6876 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6877 /* Word 83 indicates if the feature is supported */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6878 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6879 page->acoustic_manag_enable = |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6880 ACOUSTIC_ENABLED; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6881 page->acoustic_manag_level = 0xff; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6882 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6883 break; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6884 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6885 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6886 sizeof (struct mode_page)); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6887 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6888 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
6889 |
| 1258 | 6890 /* |
| 6891 * Build Mode sense power condition page | |
| 6892 * NOT IMPLEMENTED. | |
| 6893 */ | |
| 6894 static int | |
| 6895 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6896 { | |
| 6897 #ifndef __lock_lint | |
| 6898 _NOTE(ARGUNUSED(sdinfo)) | |
| 6899 _NOTE(ARGUNUSED(pcntrl)) | |
| 6900 _NOTE(ARGUNUSED(buf)) | |
| 6901 #endif | |
| 6902 return (0); | |
| 6903 } | |
| 6904 | |
| 6905 | |
| 6906 /* | |
| 6907 * Process mode select caching page 8 (scsi3 format only). | |
| 6908 * Read Ahead (same as read cache) and Write Cache may be turned on and off | |
| 6909 * if these features are supported by the device. If these features are not | |
| 6910 * supported, quietly ignore them. | |
| 6911 * This function fails only if the SET FEATURE command sent to | |
| 6912 * the device fails. The page format is not varified, assuming that the | |
| 6913 * target driver operates correctly - if parameters length is too short, | |
| 6914 * we just drop the page. | |
| 6915 * Two command may be sent if both Read Cache/Read Ahead and Write Cache | |
| 6916 * setting have to be changed. | |
| 6917 * SET FEATURE command is executed synchronously, i.e. we wait here until | |
| 6918 * it is completed, regardless of the scsi pkt directives. | |
| 6919 * | |
| 6920 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. | |
| 6921 * changing DRA will change RCD. | |
| 6922 * | |
| 6923 * More than one SATA command may be executed to perform operations specified | |
| 6924 * by mode select pages. The first error terminates further execution. | |
| 6925 * Operations performed successully are not backed-up in such case. | |
| 6926 * | |
| 6927 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. | |
| 6928 * If operation resulted in changing device setup, dmod flag should be set to | |
| 6929 * one (1). If parameters were not changed, dmod flag should be set to 0. | |
| 6930 * Upon return, if operation required sending command to the device, the rval | |
| 6931 * should be set to the value returned by sata_hba_start. If operation | |
| 6932 * did not require device access, rval should be set to TRAN_ACCEPT. | |
| 6933 * The pagelen should be set to the length of the page. | |
| 6934 * | |
| 6935 * This function has to be called with a port mutex held. | |
| 6936 * | |
| 6937 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. | |
| 6938 */ | |
| 6939 int | |
| 6940 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, | |
| 6941 int parmlen, int *pagelen, int *rval, int *dmod) | |
| 6942 { | |
| 6943 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6944 sata_drive_info_t *sdinfo; | |
| 6945 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 6946 sata_id_t *sata_id; | |
| 6947 struct scsi_extended_sense *sense; | |
| 6948 int wce, dra; /* Current settings */ | |
| 6949 | |
| 6950 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 6951 &spx->txlt_sata_pkt->satapkt_device); | |
| 6952 sata_id = &sdinfo->satadrv_id; | |
| 6953 *dmod = 0; | |
| 6954 | |
| 6955 /* Verify parameters length. If too short, drop it */ | |
| 6956 if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + | |
| 6957 sizeof (struct mode_page) < parmlen) { | |
| 6958 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 6959 sense = sata_arq_sense(spx); | |
| 6960 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 6961 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; | |
| 6962 *pagelen = parmlen; | |
| 6963 *rval = TRAN_ACCEPT; | |
| 6964 return (SATA_FAILURE); | |
| 6965 } | |
| 6966 | |
| 6967 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); | |
| 6968 | |
| 6969 /* | |
| 6970 * We can manipulate only write cache and read ahead | |
| 6971 * (read cache) setting. | |
| 6972 */ | |
| 6973 if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 6974 !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 6975 /* | |
| 6976 * None of the features is supported - ignore | |
| 6977 */ | |
| 6978 *rval = TRAN_ACCEPT; | |
| 6979 return (SATA_SUCCESS); | |
| 6980 } | |
| 6981 | |
| 6982 /* Current setting of Read Ahead (and Read Cache) */ | |
| 6983 if (sata_id->ai_features85 & SATA_LOOK_AHEAD) | |
| 6984 dra = 0; /* 0 == not disabled */ | |
| 6985 else | |
| 6986 dra = 1; | |
| 6987 /* Current setting of Write Cache */ | |
| 6988 if (sata_id->ai_features85 & SATA_WRITE_CACHE) | |
| 6989 wce = 1; | |
| 6990 else | |
| 6991 wce = 0; | |
| 6992 | |
| 6993 if (page->dra == dra && page->wce == wce && page->rcd == dra) { | |
| 6994 /* nothing to do */ | |
| 6995 *rval = TRAN_ACCEPT; | |
| 6996 return (SATA_SUCCESS); | |
| 6997 } | |
| 6998 /* | |
| 6999 * Need to flip some setting | |
| 7000 * Set-up Internal SET FEATURES command(s) | |
| 7001 */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7002 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
| 1258 | 7003 scmd->satacmd_addr_type = 0; |
| 7004 scmd->satacmd_device_reg = 0; | |
| 7005 scmd->satacmd_status_reg = 0; | |
| 7006 scmd->satacmd_error_reg = 0; | |
| 7007 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; | |
| 7008 if (page->dra != dra || page->rcd != dra) { | |
| 7009 /* Need to flip read ahead setting */ | |
| 7010 if (dra == 0) | |
| 7011 /* Disable read ahead / read cache */ | |
| 7012 scmd->satacmd_features_reg = | |
| 7013 SATAC_SF_DISABLE_READ_AHEAD; | |
| 7014 else | |
| 7015 /* Enable read ahead / read cache */ | |
| 7016 scmd->satacmd_features_reg = | |
| 7017 SATAC_SF_ENABLE_READ_AHEAD; | |
| 7018 | |
| 7019 /* Transfer command to HBA */ | |
| 7020 if (sata_hba_start(spx, rval) != 0) | |
| 7021 /* | |
| 7022 * Pkt not accepted for execution. | |
| 7023 */ | |
| 7024 return (SATA_FAILURE); | |
| 7025 | |
| 7026 *dmod = 1; | |
| 7027 | |
| 7028 /* Now process return */ | |
| 7029 if (spx->txlt_sata_pkt->satapkt_reason != | |
| 7030 SATA_PKT_COMPLETED) { | |
| 7031 goto failure; /* Terminate */ | |
| 7032 } | |
| 7033 } | |
| 7034 | |
| 7035 /* Note that the packet is not removed, so it could be re-used */ | |
| 7036 if (page->wce != wce) { | |
| 7037 /* Need to flip Write Cache setting */ | |
| 7038 if (page->wce == 1) | |
| 7039 /* Enable write cache */ | |
| 7040 scmd->satacmd_features_reg = | |
| 7041 SATAC_SF_ENABLE_WRITE_CACHE; | |
| 7042 else | |
| 7043 /* Disable write cache */ | |
| 7044 scmd->satacmd_features_reg = | |
| 7045 SATAC_SF_DISABLE_WRITE_CACHE; | |
| 7046 | |
| 7047 /* Transfer command to HBA */ | |
| 7048 if (sata_hba_start(spx, rval) != 0) | |
| 7049 /* | |
| 7050 * Pkt not accepted for execution. | |
| 7051 */ | |
| 7052 return (SATA_FAILURE); | |
| 7053 | |
| 7054 *dmod = 1; | |
| 7055 | |
| 7056 /* Now process return */ | |
| 7057 if (spx->txlt_sata_pkt->satapkt_reason != | |
| 7058 SATA_PKT_COMPLETED) { | |
| 7059 goto failure; | |
| 7060 } | |
| 7061 } | |
| 7062 return (SATA_SUCCESS); | |
| 7063 | |
| 7064 failure: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7065 sata_xlate_errors(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7066 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7067 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7068 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7069 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7070 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7071 * Process mode select informational exceptions control page 0x1c |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7072 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7073 * The only changeable bit is dexcpt (disable exceptions). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7074 * MRIE (method of reporting informational exceptions) must be |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7075 * "only on request". |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7076 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7077 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7078 * If operation resulted in changing device setup, dmod flag should be set to |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7079 * one (1). If parameters were not changed, dmod flag should be set to 0. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7080 * Upon return, if operation required sending command to the device, the rval |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7081 * should be set to the value returned by sata_hba_start. If operation |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7082 * did not require device access, rval should be set to TRAN_ACCEPT. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7083 * The pagelen should be set to the length of the page. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7084 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7085 * This function has to be called with a port mutex held. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7086 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7087 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7088 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7089 static int |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7090 sata_mode_select_page_1c( |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7091 sata_pkt_txlate_t *spx, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7092 struct mode_info_excpt_page *page, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7093 int parmlen, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7094 int *pagelen, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7095 int *rval, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7096 int *dmod) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7097 { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7098 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7099 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7100 sata_drive_info_t *sdinfo; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7101 sata_id_t *sata_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7102 struct scsi_extended_sense *sense; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7103 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7104 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7105 &spx->txlt_sata_pkt->satapkt_device); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7106 sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7107 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7108 *dmod = 0; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7109 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7110 /* Verify parameters length. If too short, drop it */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7111 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) < parmlen) || |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7112 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7113 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7114 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7115 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7116 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7117 *pagelen = parmlen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7118 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7119 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7120 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7121 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7122 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7123 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7124 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7125 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7126 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7127 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7128 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7129 *pagelen = parmlen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7130 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7131 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7132 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7133 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7134 /* If already in the state requested, we are done */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7135 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7136 /* nothing to do */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7137 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7138 return (SATA_SUCCESS); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7139 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7140 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7141 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7142 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7143 /* Build SMART_ENABLE or SMART_DISABLE command */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7144 scmd->satacmd_addr_type = 0; /* N/A */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7145 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7146 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7147 scmd->satacmd_features_reg = page->dexcpt ? |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7148 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7149 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7150 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7151 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7152 /* Transfer command to HBA */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7153 if (sata_hba_start(spx, rval) != 0) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7154 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7155 * Pkt not accepted for execution. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7156 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7157 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7158 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7159 *dmod = 1; /* At least may have been modified */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7160 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7161 /* Now process return */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7162 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7163 return (SATA_SUCCESS); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7164 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7165 /* Packet did not complete successfully */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7166 sata_xlate_errors(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
7167 |
| 1258 | 7168 return (SATA_FAILURE); |
| 7169 } | |
| 7170 | |
|
4836
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7171 int |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7172 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7173 mode_acoustic_management *page, int parmlen, int *pagelen, |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7174 int *rval, int *dmod) |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7175 { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7176 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7177 sata_drive_info_t *sdinfo; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7178 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7179 sata_id_t *sata_id; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7180 struct scsi_extended_sense *sense; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7181 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7182 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7183 &spx->txlt_sata_pkt->satapkt_device); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7184 sata_id = &sdinfo->satadrv_id; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7185 *dmod = 0; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7186 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7187 /* If parmlen is too short or the feature is not supported, drop it */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7188 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7189 sizeof (struct mode_page)) < parmlen) || |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7190 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7191 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7192 sense = sata_arq_sense(spx); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7193 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7194 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7195 *pagelen = parmlen; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7196 *rval = TRAN_ACCEPT; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7197 return (SATA_FAILURE); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7198 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7199 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7200 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7201 sizeof (struct mode_page); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7202 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7203 /* |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7204 * We can enable and disable acoustice management and |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7205 * set the acoustic management level. |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7206 */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7207 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7208 /* |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7209 * Set-up Internal SET FEATURES command(s) |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7210 */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7211 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7212 scmd->satacmd_addr_type = 0; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7213 scmd->satacmd_device_reg = 0; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7214 scmd->satacmd_status_reg = 0; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7215 scmd->satacmd_error_reg = 0; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7216 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7217 if (page->acoustic_manag_enable) { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7218 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7219 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7220 } else { /* disabling acoustic management */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7221 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7222 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7223 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7224 /* Transfer command to HBA */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7225 if (sata_hba_start(spx, rval) != 0) |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7226 /* |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7227 * Pkt not accepted for execution. |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7228 */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7229 return (SATA_FAILURE); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7230 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7231 /* Now process return */ |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7232 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7233 sata_xlate_errors(spx); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7234 return (SATA_FAILURE); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7235 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7236 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7237 *dmod = 1; |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7238 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7239 return (SATA_SUCCESS); |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7240 } |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7241 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7242 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7243 |
|
7e0fe47fd304
PSARC/2007/422 Acoustic Management support under SATA module
ls24207
parents:
4659
diff
changeset
|
7244 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7245 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7246 * sata_build_lsense_page0() is used to create the |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7247 * SCSI LOG SENSE page 0 (supported log pages) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7248 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7249 * Currently supported pages are 0, 0x10, 0x2f and 0x30 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7250 * (supported log pages, self-test results, informational exceptions |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7251 * and Sun vendor specific ATA SMART data). |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7252 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7253 * Takes a sata_drive_info t * and the address of a buffer |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7254 * in which to create the page information. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7255 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7256 * Returns the number of bytes valid in the buffer. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7257 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7258 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7259 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7260 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7261 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7262 uint8_t *page_ptr = (uint8_t *)lpp->param_values; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7263 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7264 sata_id_t *sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7265 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7266 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7267 lpp->param_code[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7268 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7269 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7270 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7271 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7272 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7273 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7274 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7275 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7276 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7277 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7278 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7279 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7280 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7281 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7282 lpp->param_len = num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7283 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7284 return ((&lpp->param_values[0] - (uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7285 num_pages_supported); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7286 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7287 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7288 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7289 * sata_build_lsense_page_10() is used to create the |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7290 * SCSI LOG SENSE page 0x10 (self-test results) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7291 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7292 * Takes a sata_drive_info t * and the address of a buffer |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7293 * in which to create the page information as well as a sata_hba_inst_t *. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7294 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7295 * Returns the number of bytes valid in the buffer. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7296 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7297 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7298 sata_build_lsense_page_10( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7299 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7300 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7301 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7302 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7303 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7304 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7305 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7306 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7307 struct smart_ext_selftest_log *ext_selftest_log; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7308 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7309 ext_selftest_log = kmem_zalloc( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7310 sizeof (struct smart_ext_selftest_log), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7311 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7312 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7313 ext_selftest_log, 0); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7314 if (rval == 0) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7315 int index, start_index; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7316 struct smart_ext_selftest_log_entry *entry; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7317 static const struct smart_ext_selftest_log_entry empty = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7318 {0}; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7319 uint16_t block_num; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7320 int count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7321 boolean_t only_one_block = B_FALSE; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7322 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7323 index = ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7324 smart_ext_selftest_log_index[0]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7325 index |= ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7326 smart_ext_selftest_log_index[1] << 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7327 if (index == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7328 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7329 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7330 --index; /* Correct for 0 origin */ |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7331 start_index = index; /* remember where we started */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7332 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7333 if (block_num != 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7334 rval = sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7335 sata_hba_inst, sdinfo, ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7336 block_num); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7337 if (rval != 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7338 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7339 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7340 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7341 entry = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7342 &ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7343 smart_ext_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7344 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7345 for (count = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7346 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7347 ++count) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7348 uint8_t status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7349 uint8_t code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7350 uint8_t sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7351 uint8_t add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7352 uint8_t add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7353 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7354 /* If this is an unused entry, we are done */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7355 if (bcmp(entry, &empty, sizeof (empty)) == 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7356 /* Broken firmware on some disks */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7357 if (index + 1 == |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7358 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7359 --entry; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7360 --index; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7361 if (bcmp(entry, &empty, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7362 sizeof (empty)) == 0) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7363 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7364 } else |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7365 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7366 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7367 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7368 if (only_one_block && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7369 start_index == index) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7370 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7371 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7372 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7373 lpp->param_code[1] = count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7374 lpp->param_ctrl_flags = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7375 LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7376 lpp->param_len = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7377 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7378 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7379 status = entry->smart_ext_selftest_log_status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7380 status >>= 4; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7381 switch (status) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7382 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7383 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7384 sense_key = KEY_NO_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7385 add_sense_code = SD_SCSI_NO_ADD_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7386 add_sense_code_qual = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7387 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7388 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7389 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7390 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7391 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7392 add_sense_code_qual = SCSI_COMPONENT_81; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7393 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7394 case 2: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7395 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7396 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7397 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7398 add_sense_code_qual = SCSI_COMPONENT_82; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7399 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7400 case 3: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7401 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7402 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7403 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7404 add_sense_code_qual = SCSI_COMPONENT_83; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7405 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7406 case 4: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7407 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7408 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7409 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7410 add_sense_code_qual = SCSI_COMPONENT_84; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7411 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7412 case 5: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7413 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7414 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7415 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7416 add_sense_code_qual = SCSI_COMPONENT_85; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7417 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7418 case 6: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7419 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7420 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7421 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7422 add_sense_code_qual = SCSI_COMPONENT_86; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7423 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7424 case 7: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7425 sense_key = KEY_MEDIUM_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7426 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7427 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7428 add_sense_code_qual = SCSI_COMPONENT_87; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7429 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7430 case 8: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7431 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7432 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7433 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7434 add_sense_code_qual = SCSI_COMPONENT_88; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7435 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7436 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7437 code = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7438 status |= (code << 4); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7439 lpp->param_values[0] = status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7440 lpp->param_values[1] = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7441 lpp->param_values[2] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7442 smart_ext_selftest_log_timestamp[1]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7443 lpp->param_values[3] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7444 smart_ext_selftest_log_timestamp[0]; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7445 if (status != 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7446 lpp->param_values[4] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7447 lpp->param_values[5] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7448 lpp->param_values[6] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7449 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7450 [5]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7451 lpp->param_values[7] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7452 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7453 [4]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7454 lpp->param_values[8] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7455 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7456 [3]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7457 lpp->param_values[9] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7458 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7459 [2]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7460 lpp->param_values[10] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7461 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7462 [1]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7463 lpp->param_values[11] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7464 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7465 [0]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7466 } else { /* No bad block address */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7467 lpp->param_values[4] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7468 lpp->param_values[5] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7469 lpp->param_values[6] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7470 lpp->param_values[7] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7471 lpp->param_values[8] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7472 lpp->param_values[9] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7473 lpp->param_values[10] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7474 lpp->param_values[11] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7475 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7476 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7477 lpp->param_values[12] = sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7478 lpp->param_values[13] = add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7479 lpp->param_values[14] = add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7480 lpp->param_values[15] = 0; /* undefined */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7481 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7482 lpp = (struct log_parameter *) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7483 (((uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7484 SCSI_LOG_PARAM_HDR_LEN + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7485 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7486 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7487 --index; /* Back up to previous entry */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7488 if (index < 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7489 if (block_num > 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7490 --block_num; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7491 } else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7492 struct read_log_ext_directory |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7493 logdir; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7494 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7495 rval = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7496 sata_read_log_ext_directory( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7497 sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7498 &logdir); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7499 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7500 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7501 if ((logdir.read_log_ext_vers |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7502 [0] == 0) && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7503 (logdir.read_log_ext_vers |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7504 [1] == 0)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7505 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7506 block_num = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7507 logdir.read_log_ext_nblks |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7508 [EXT_SMART_SELFTEST_LOG_PAGE |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7509 - 1][0]; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7510 block_num |= logdir. |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7511 read_log_ext_nblks |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7512 [EXT_SMART_SELFTEST_LOG_PAGE |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7513 - 1][1] << 8; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7514 --block_num; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7515 only_one_block = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7516 (block_num == 0); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7517 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7518 rval = sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7519 sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7520 ext_selftest_log, block_num); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7521 if (rval != 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7522 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7523 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7524 index = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7525 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7526 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7527 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7528 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7529 entry = &ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7530 smart_ext_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7531 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7532 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7533 out: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7534 kmem_free(ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7535 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7536 } else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7537 struct smart_selftest_log *selftest_log; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7538 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7539 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7540 KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7541 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7542 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7543 selftest_log); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7544 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7545 if (rval == 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7546 int index; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7547 int count; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7548 struct smart_selftest_log_entry *entry; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7549 static const struct smart_selftest_log_entry empty = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7550 { 0 }; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7551 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7552 index = selftest_log->smart_selftest_log_index; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7553 if (index == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7554 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7555 --index; /* Correct for 0 origin */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7556 entry = &selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7557 smart_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7558 for (count = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7559 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7560 ++count) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7561 uint8_t status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7562 uint8_t code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7563 uint8_t sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7564 uint8_t add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7565 uint8_t add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7566 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7567 if (bcmp(entry, &empty, sizeof (empty)) == 0) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7568 goto done; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7569 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7570 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7571 lpp->param_code[1] = count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7572 lpp->param_ctrl_flags = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7573 LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7574 lpp->param_len = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7575 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7576 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7577 status = entry->smart_selftest_log_status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7578 status >>= 4; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7579 switch (status) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7580 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7581 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7582 sense_key = KEY_NO_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7583 add_sense_code = SD_SCSI_NO_ADD_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7584 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7585 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7586 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7587 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7588 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7589 add_sense_code_qual = SCSI_COMPONENT_81; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7590 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7591 case 2: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7592 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7593 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7594 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7595 add_sense_code_qual = SCSI_COMPONENT_82; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7596 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7597 case 3: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7598 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7599 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7600 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7601 add_sense_code_qual = SCSI_COMPONENT_83; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7602 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7603 case 4: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7604 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7605 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7606 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7607 add_sense_code_qual = SCSI_COMPONENT_84; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7608 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7609 case 5: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7610 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7611 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7612 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7613 add_sense_code_qual = SCSI_COMPONENT_85; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7614 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7615 case 6: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7616 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7617 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7618 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7619 add_sense_code_qual = SCSI_COMPONENT_86; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7620 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7621 case 7: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7622 sense_key = KEY_MEDIUM_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7623 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7624 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7625 add_sense_code_qual = SCSI_COMPONENT_87; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7626 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7627 case 8: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7628 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7629 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7630 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7631 add_sense_code_qual = SCSI_COMPONENT_88; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7632 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7633 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7634 code = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7635 status |= (code << 4); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7636 lpp->param_values[0] = status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7637 lpp->param_values[1] = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7638 lpp->param_values[2] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7639 smart_selftest_log_timestamp[1]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7640 lpp->param_values[3] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7641 smart_selftest_log_timestamp[0]; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7642 if (status != 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7643 lpp->param_values[4] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7644 lpp->param_values[5] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7645 lpp->param_values[6] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7646 lpp->param_values[7] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7647 lpp->param_values[8] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7648 smart_selftest_log_failing_lba[3]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7649 lpp->param_values[9] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7650 smart_selftest_log_failing_lba[2]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7651 lpp->param_values[10] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7652 smart_selftest_log_failing_lba[1]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7653 lpp->param_values[11] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7654 smart_selftest_log_failing_lba[0]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7655 } else { /* No block address */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7656 lpp->param_values[4] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7657 lpp->param_values[5] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7658 lpp->param_values[6] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7659 lpp->param_values[7] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7660 lpp->param_values[8] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7661 lpp->param_values[9] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7662 lpp->param_values[10] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7663 lpp->param_values[11] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7664 } |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7665 lpp->param_values[12] = sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7666 lpp->param_values[13] = add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7667 lpp->param_values[14] = add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7668 lpp->param_values[15] = 0; /* undefined */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7669 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7670 lpp = (struct log_parameter *) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7671 (((uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7672 SCSI_LOG_PARAM_HDR_LEN + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7673 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7674 --index; /* back up to previous entry */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7675 if (index < 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7676 index = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7677 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7678 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7679 entry = &selftest_log-> |
| 4582 | 7680 smart_selftest_log_entries[index]; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7681 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7682 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7683 done: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7684 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7685 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7686 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7687 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7688 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7689 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7690 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7691 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7692 * sata_build_lsense_page_2f() is used to create the |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7693 * SCSI LOG SENSE page 0x10 (informational exceptions) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7694 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7695 * Takes a sata_drive_info t * and the address of a buffer |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7696 * in which to create the page information as well as a sata_hba_inst_t *. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7697 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7698 * Returns the number of bytes valid in the buffer. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7699 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7700 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7701 sata_build_lsense_page_2f( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7702 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7703 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7704 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7705 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7706 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7707 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7708 uint8_t *smart_data; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7709 uint8_t temp; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7710 sata_id_t *sata_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7711 #define SMART_NO_TEMP 0xff |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7712 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7713 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7714 lpp->param_code[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7715 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7716 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7717 /* Now get the SMART status w.r.t. threshold exceeded */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7718 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7719 switch (rval) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7720 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7721 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7722 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7723 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7724 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7725 case -1: /* failed to get data */ |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7726 lpp->param_values[0] = 0; /* No failure predicted */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7727 lpp->param_values[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7728 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7729 #if defined(SATA_DEBUG) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7730 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7731 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7732 /* NOTREACHED */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7733 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7734 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7735 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7736 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7737 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7738 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7739 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7740 /* Now get the temperature */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7741 smart_data = kmem_zalloc(512, KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7742 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7743 SCT_STATUS_LOG_PAGE, 1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7744 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7745 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7746 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7747 temp = smart_data[200]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7748 if (temp & 0x80) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7749 if (temp & 0x7f) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7750 temp = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7751 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7752 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7753 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7754 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7755 kmem_free(smart_data, 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7756 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7757 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7758 lpp->param_values[2] = temp; /* most recent temperature */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
7759 lpp->param_values[3] = 0; /* required vendor specific byte */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7760 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7761 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7762 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7763 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7764 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7765 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7766 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7767 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7768 * sata_build_lsense_page_30() is used to create the |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7769 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7770 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7771 * Takes a sata_drive_info t * and the address of a buffer |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7772 * in which to create the page information as well as a sata_hba_inst_t *. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7773 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7774 * Returns the number of bytes valid in the buffer. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7775 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7776 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7777 sata_build_lsense_page_30( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7778 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7779 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7780 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7781 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7782 struct smart_data *smart_data = (struct smart_data *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7783 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7784 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7785 /* Now do the SMART READ DATA */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7786 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7787 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7788 return (0); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7789 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7790 return (sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7791 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7792 |
| 1258 | 7793 |
| 7794 | |
| 7795 | |
| 7796 | |
| 7797 /* ************************** LOCAL FUNCTIONS ************************** */ | |
| 7798 | |
| 7799 /* | |
| 7800 * Validate sata_tran info | |
| 7801 * SATA_FAILURE returns if structure is inconsistent or structure revision | |
| 7802 * does not match one used by the framework. | |
| 7803 * | |
| 7804 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains | |
| 7805 * required function pointers. | |
| 7806 * Returns SATA_FAILURE otherwise. | |
| 7807 */ | |
| 7808 static int | |
| 7809 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) | |
| 7810 { | |
| 7811 if (sata_tran->sata_tran_hba_rev != SATA_TRAN_HBA_REV) { | |
| 7812 sata_log(NULL, CE_WARN, | |
| 7813 "sata: invalid sata_hba_tran version %d for driver %s", | |
| 7814 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); | |
| 7815 return (SATA_FAILURE); | |
| 7816 } | |
| 7817 | |
| 7818 if (dip != sata_tran->sata_tran_hba_dip) { | |
| 7819 SATA_LOG_D((NULL, CE_WARN, | |
| 7820 "sata: inconsistent sata_tran_hba_dip " | |
| 7821 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); | |
| 7822 return (SATA_FAILURE); | |
| 7823 } | |
| 7824 | |
| 7825 if (sata_tran->sata_tran_probe_port == NULL || | |
| 7826 sata_tran->sata_tran_start == NULL || | |
| 7827 sata_tran->sata_tran_abort == NULL || | |
| 7828 sata_tran->sata_tran_reset_dport == NULL) { | |
| 7829 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " | |
| 7830 "required functions")); | |
| 7831 } | |
| 7832 return (SATA_SUCCESS); | |
| 7833 } | |
| 7834 | |
| 7835 /* | |
| 7836 * Remove HBA instance from sata_hba_list. | |
| 7837 */ | |
| 7838 static void | |
| 7839 sata_remove_hba_instance(dev_info_t *dip) | |
| 7840 { | |
| 7841 sata_hba_inst_t *sata_hba_inst; | |
| 7842 | |
| 7843 mutex_enter(&sata_mutex); | |
| 7844 for (sata_hba_inst = sata_hba_list; | |
| 7845 sata_hba_inst != (struct sata_hba_inst *)NULL; | |
| 7846 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 7847 if (sata_hba_inst->satahba_dip == dip) | |
| 7848 break; | |
| 7849 } | |
| 7850 | |
| 7851 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { | |
| 7852 #ifdef SATA_DEBUG | |
| 7853 cmn_err(CE_WARN, "sata_remove_hba_instance: " | |
| 7854 "unknown HBA instance\n"); | |
| 7855 #endif | |
| 7856 ASSERT(FALSE); | |
| 7857 } | |
| 7858 if (sata_hba_inst == sata_hba_list) { | |
| 7859 sata_hba_list = sata_hba_inst->satahba_next; | |
| 7860 if (sata_hba_list) { | |
| 7861 sata_hba_list->satahba_prev = | |
| 7862 (struct sata_hba_inst *)NULL; | |
| 7863 } | |
| 7864 if (sata_hba_inst == sata_hba_list_tail) { | |
| 7865 sata_hba_list_tail = NULL; | |
| 7866 } | |
| 7867 } else if (sata_hba_inst == sata_hba_list_tail) { | |
| 7868 sata_hba_list_tail = sata_hba_inst->satahba_prev; | |
| 7869 if (sata_hba_list_tail) { | |
| 7870 sata_hba_list_tail->satahba_next = | |
| 7871 (struct sata_hba_inst *)NULL; | |
| 7872 } | |
| 7873 } else { | |
| 7874 sata_hba_inst->satahba_prev->satahba_next = | |
| 7875 sata_hba_inst->satahba_next; | |
| 7876 sata_hba_inst->satahba_next->satahba_prev = | |
| 7877 sata_hba_inst->satahba_prev; | |
| 7878 } | |
| 7879 mutex_exit(&sata_mutex); | |
| 7880 } | |
| 7881 | |
| 7882 | |
| 7883 | |
| 7884 | |
| 7885 | |
| 7886 /* | |
| 7887 * Probe all SATA ports of the specified HBA instance. | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7888 * The assumption is that there are no target and attachment point minor nodes |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7889 * created by the boot subsystems, so we do not need to prune device tree. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7890 * |
| 1258 | 7891 * This function is called only from sata_hba_attach(). It does not have to |
| 7892 * be protected by controller mutex, because the hba_attached flag is not set | |
| 7893 * yet and no one would be touching this HBA instance other then this thread. | |
| 7894 * Determines if port is active and what type of the device is attached | |
| 7895 * (if any). Allocates necessary structures for each port. | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7896 * |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7897 * An AP (Attachement Point) node is created for each SATA device port even |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7898 * when there is no device attached. |
| 1258 | 7899 */ |
| 7900 | |
| 7901 static void | |
| 7902 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) | |
| 7903 { | |
| 7904 dev_info_t *dip = SATA_DIP(sata_hba_inst); | |
| 7905 int ncport, npmport; | |
| 7906 sata_cport_info_t *cportinfo; | |
| 7907 sata_drive_info_t *drive; | |
| 7908 sata_pmult_info_t *pminfo; | |
| 7909 sata_pmport_info_t *pmportinfo; | |
| 7910 sata_device_t sata_device; | |
| 7911 int rval; | |
| 7912 dev_t minor_number; | |
| 7913 char name[16]; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7914 clock_t start_time, cur_time; |
| 1258 | 7915 |
| 7916 /* | |
| 7917 * Probe controller ports first, to find port status and | |
| 7918 * any port multiplier attached. | |
| 7919 */ | |
| 7920 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 7921 /* allocate cport structure */ | |
| 7922 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); | |
| 7923 ASSERT(cportinfo != NULL); | |
| 7924 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 7925 | |
| 7926 mutex_enter(&cportinfo->cport_mutex); | |
| 7927 | |
| 7928 cportinfo->cport_addr.cport = ncport; | |
| 7929 cportinfo->cport_addr.pmport = 0; | |
| 7930 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; | |
| 7931 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; | |
| 7932 cportinfo->cport_state |= SATA_STATE_PROBING; | |
| 7933 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; | |
| 7934 | |
| 7935 /* | |
| 7936 * Regardless if a port is usable or not, create | |
| 7937 * an attachment point | |
| 7938 */ | |
| 7939 mutex_exit(&cportinfo->cport_mutex); | |
| 7940 minor_number = | |
| 7941 SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0); | |
| 7942 (void) sprintf(name, "%d", ncport); | |
| 7943 if (ddi_create_minor_node(dip, name, S_IFCHR, | |
| 7944 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != | |
| 7945 DDI_SUCCESS) { | |
| 7946 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
7947 "cannot create SATA attachment point for port %d", |
| 1258 | 7948 ncport); |
| 7949 } | |
| 7950 | |
| 7951 /* Probe port */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7952 start_time = ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7953 reprobe_cport: |
| 1258 | 7954 sata_device.satadev_addr.cport = ncport; |
| 7955 sata_device.satadev_addr.pmport = 0; | |
| 7956 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 7957 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 7958 | |
| 7959 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7960 (dip, &sata_device); | |
| 7961 | |
| 7962 mutex_enter(&cportinfo->cport_mutex); | |
| 7963 sata_update_port_scr(&cportinfo->cport_scr, &sata_device); | |
| 7964 if (rval != SATA_SUCCESS) { | |
| 7965 /* Something went wrong? Fail the port */ | |
| 7966 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 7967 mutex_exit(&cportinfo->cport_mutex); | |
| 7968 continue; | |
| 7969 } | |
| 7970 cportinfo->cport_state &= ~SATA_STATE_PROBING; | |
| 7971 cportinfo->cport_state |= SATA_STATE_PROBED; | |
| 7972 cportinfo->cport_dev_type = sata_device.satadev_type; | |
| 7973 | |
| 7974 cportinfo->cport_state |= SATA_STATE_READY; | |
| 7975 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { | |
| 7976 mutex_exit(&cportinfo->cport_mutex); | |
| 7977 continue; | |
| 7978 } | |
| 7979 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 7980 /* | |
| 7981 * There is some device attached. | |
| 7982 * Allocate device info structure | |
| 7983 */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7984 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7985 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7986 SATA_CPORTINFO_DRV_INFO(cportinfo) = |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7987 kmem_zalloc(sizeof (sata_drive_info_t), |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7988 KM_SLEEP); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7989 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7990 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7991 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); |
| 1258 | 7992 drive->satadrv_addr = cportinfo->cport_addr; |
| 7993 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; | |
| 7994 drive->satadrv_type = cportinfo->cport_dev_type; | |
| 7995 drive->satadrv_state = SATA_STATE_UNKNOWN; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7996 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7997 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7998 if (sata_add_device(dip, sata_hba_inst, ncport, 0) != |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
7999 SATA_SUCCESS) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8000 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8001 * Plugged device was not correctly identified. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8002 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8003 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8004 cur_time = ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8005 if ((cur_time - start_time) < |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8006 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8007 /* sleep for a while */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8008 delay(drv_usectohz( |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8009 SATA_DEV_IDENTIFY_RETRY_DELAY)); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8010 goto reprobe_cport; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8011 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8012 } |
| 1258 | 8013 } else { |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8014 mutex_exit(&cportinfo->cport_mutex); |
| 1258 | 8015 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); |
| 8016 pminfo = kmem_zalloc(sizeof (sata_pmult_info_t), | |
| 8017 KM_SLEEP); | |
| 8018 mutex_enter(&cportinfo->cport_mutex); | |
| 8019 ASSERT(pminfo != NULL); | |
| 8020 SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo; | |
| 8021 pminfo->pmult_addr.cport = cportinfo->cport_addr.cport; | |
| 8022 pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT; | |
| 8023 pminfo->pmult_addr.qual = SATA_ADDR_PMPORT; | |
| 8024 pminfo->pmult_num_dev_ports = | |
| 8025 sata_device.satadev_add_info; | |
| 8026 mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER, | |
| 8027 NULL); | |
| 8028 pminfo->pmult_state = SATA_STATE_PROBING; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8029 mutex_exit(&cportinfo->cport_mutex); |
| 1258 | 8030 |
| 8031 /* Probe Port Multiplier ports */ | |
| 8032 for (npmport = 0; | |
| 8033 npmport < pminfo->pmult_num_dev_ports; | |
| 8034 npmport++) { | |
| 8035 pmportinfo = kmem_zalloc( | |
| 8036 sizeof (sata_pmport_info_t), KM_SLEEP); | |
| 8037 mutex_enter(&cportinfo->cport_mutex); | |
| 8038 ASSERT(pmportinfo != NULL); | |
| 8039 pmportinfo->pmport_addr.cport = ncport; | |
| 8040 pmportinfo->pmport_addr.pmport = npmport; | |
| 8041 pmportinfo->pmport_addr.qual = | |
| 8042 SATA_ADDR_PMPORT; | |
| 8043 pminfo->pmult_dev_port[npmport] = pmportinfo; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8044 |
| 1258 | 8045 mutex_init(&pmportinfo->pmport_mutex, NULL, |
| 8046 MUTEX_DRIVER, NULL); | |
| 8047 | |
| 8048 mutex_exit(&cportinfo->cport_mutex); | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8049 |
| 1258 | 8050 /* Create an attachment point */ |
| 8051 minor_number = SATA_MAKE_AP_MINOR( | |
| 8052 ddi_get_instance(dip), ncport, npmport, 1); | |
| 8053 (void) sprintf(name, "%d.%d", ncport, npmport); | |
| 8054 if (ddi_create_minor_node(dip, name, S_IFCHR, | |
| 8055 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, | |
| 8056 0) != DDI_SUCCESS) { | |
| 8057 sata_log(sata_hba_inst, CE_WARN, | |
| 8058 "sata_hba_attach: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8059 "cannot create SATA attachment " |
| 1258 | 8060 "point for port %d pmult port %d", |
| 8061 ncport, npmport); | |
| 8062 } | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8063 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8064 start_time = ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8065 reprobe_pmport: |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8066 sata_device.satadev_addr.pmport = npmport; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8067 sata_device.satadev_addr.qual = |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8068 SATA_ADDR_PMPORT; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8069 |
| 1258 | 8070 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) |
| 8071 (dip, &sata_device); | |
| 8072 mutex_enter(&cportinfo->cport_mutex); | |
| 8073 | |
| 8074 /* sata_update_port_info() */ | |
| 8075 sata_update_port_scr(&pmportinfo->pmport_scr, | |
| 8076 &sata_device); | |
| 8077 | |
| 8078 if (rval != SATA_SUCCESS) { | |
| 8079 pmportinfo->pmport_state = | |
| 8080 SATA_PSTATE_FAILED; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8081 mutex_exit(&cportinfo->cport_mutex); |
| 1258 | 8082 continue; |
| 8083 } | |
| 8084 pmportinfo->pmport_state &= | |
| 8085 ~SATA_STATE_PROBING; | |
| 8086 pmportinfo->pmport_state |= SATA_STATE_PROBED; | |
| 8087 pmportinfo->pmport_dev_type = | |
| 8088 sata_device.satadev_type; | |
| 8089 | |
| 8090 pmportinfo->pmport_state |= SATA_STATE_READY; | |
| 8091 if (pmportinfo->pmport_dev_type == | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8092 SATA_DTYPE_NONE) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8093 mutex_exit(&cportinfo->cport_mutex); |
| 1258 | 8094 continue; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8095 } |
| 1258 | 8096 /* Port multipliers cannot be chained */ |
| 8097 ASSERT(pmportinfo->pmport_dev_type != | |
| 8098 SATA_DTYPE_PMULT); | |
| 8099 /* | |
| 8100 * There is something attached to Port | |
| 8101 * Multiplier device port | |
| 8102 * Allocate device info structure | |
| 8103 */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8104 if (pmportinfo->pmport_sata_drive == NULL) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8105 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8106 pmportinfo->pmport_sata_drive = |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8107 kmem_zalloc( |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8108 sizeof (sata_drive_info_t), |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8109 KM_SLEEP); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8110 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8111 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8112 drive = pmportinfo->pmport_sata_drive; |
| 1258 | 8113 drive->satadrv_addr.cport = |
| 8114 pmportinfo->pmport_addr.cport; | |
| 8115 drive->satadrv_addr.pmport = npmport; | |
| 8116 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; | |
| 8117 drive->satadrv_type = pmportinfo-> | |
| 8118 pmport_dev_type; | |
| 8119 drive->satadrv_state = SATA_STATE_UNKNOWN; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8120 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8121 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8122 if (sata_add_device(dip, sata_hba_inst, ncport, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8123 npmport) != SATA_SUCCESS) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8124 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8125 * Plugged device was not correctly |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8126 * identified. Retry, within the |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8127 * SATA_DEV_IDENTIFY_TIMEOUT |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8128 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8129 cur_time = ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8130 if ((cur_time - start_time) < |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8131 drv_usectohz( |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8132 SATA_DEV_IDENTIFY_TIMEOUT)) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8133 /* sleep for a while */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8134 delay(drv_usectohz( |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8135 SATA_DEV_IDENTIFY_RETRY_DELAY)); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8136 goto reprobe_pmport; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8137 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8138 } |
| 1258 | 8139 } |
| 8140 pmportinfo->pmport_state = | |
| 8141 SATA_STATE_PROBED | SATA_STATE_READY; | |
| 8142 } | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8143 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8144 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8145 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8146 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8147 * Add SATA device for specified HBA instance & port (SCSI target |
| 1258 | 8148 * device nodes). |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8149 * This function is called (indirectly) only from sata_hba_attach(). |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8150 * A target node is created when there is a supported type device attached, |
| 1258 | 8151 * but may be removed if it cannot be put online. |
| 8152 * | |
| 8153 * This function cannot be called from an interrupt context. | |
| 8154 * | |
| 8155 * ONLY DISK TARGET NODES ARE CREATED NOW | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8156 * |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8157 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8158 * device identification failed - adding a device could be retried. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8159 * |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8160 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8161 static int |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8162 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, int cport, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8163 int pmport) |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8164 { |
| 1258 | 8165 sata_cport_info_t *cportinfo; |
| 8166 sata_pmult_info_t *pminfo; | |
| 8167 sata_pmport_info_t *pmportinfo; | |
| 8168 dev_info_t *cdip; /* child dip */ | |
| 8169 sata_device_t sata_device; | |
| 8170 int rval; | |
| 8171 | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8172 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8173 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8174 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8175 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8176 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8177 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8178 * Some device is attached to a controller port. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8179 * We rely on controllers distinquishing between no-device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8180 * attached port multiplier and other kind of attached device. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8181 * We need to get Identify Device data and determine |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8182 * positively the dev type before trying to attach |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8183 * the target driver. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8184 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8185 sata_device.satadev_rev = SATA_DEVICE_REV; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8186 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8187 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8188 * Not port multiplier. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8189 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8190 sata_device.satadev_addr = cportinfo->cport_addr; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8191 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8192 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8193 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8194 rval = sata_probe_device(sata_hba_inst, &sata_device); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8195 if (rval != SATA_SUCCESS || |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8196 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8197 return (SATA_FAILURE); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8198 |
| 1258 | 8199 mutex_enter(&cportinfo->cport_mutex); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8200 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { |
| 1258 | 8201 /* |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8202 * Could not determine device type or |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8203 * a device is not supported. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8204 * Degrade this device to unknown. |
| 1258 | 8205 */ |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8206 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; |
| 1258 | 8207 mutex_exit(&cportinfo->cport_mutex); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8208 return (SATA_SUCCESS); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8209 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8210 cportinfo->cport_dev_type = sata_device.satadev_type; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8211 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8212 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8213 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8214 * Initialize device to the desired state. Even if it |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8215 * fails, the device will still attach but syslog |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8216 * will show the warning. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8217 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8218 if (sata_initialize_device(sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8219 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8220 /* Retry */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8221 (void) sata_initialize_device(sata_hba_inst, |
| 1258 | 8222 SATA_CPORTINFO_DRV_INFO(cportinfo)); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8223 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8224 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8225 sata_show_drive_info(sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8226 SATA_CPORTINFO_DRV_INFO(cportinfo)); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8227 cportinfo->cport_tgtnode_clean = B_TRUE; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8228 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8229 cdip = sata_create_target_node(pdip, sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8230 &sata_device.satadev_addr); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8231 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8232 if (cdip == NULL) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8233 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8234 * Attaching target node failed. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8235 * We retain sata_drive_info structure... |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8236 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8237 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8238 satadrv_type = SATA_DTYPE_UNKNOWN; |
| 1258 | 8239 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8240 satadrv_state = SATA_STATE_UNKNOWN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8241 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8242 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8243 return (SATA_SUCCESS); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8244 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8245 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8246 satadrv_state = SATA_STATE_READY; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8247 } else { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8248 /* This must be Port Multiplier type */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8249 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8250 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8251 "sata_add_device: " |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8252 "unrecognized dev type %x", |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8253 cportinfo->cport_dev_type)); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8254 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8255 return (SATA_SUCCESS); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8256 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8257 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8258 pmportinfo = pminfo->pmult_dev_port[pmport]; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8259 sata_device.satadev_addr = pmportinfo->pmport_addr; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8260 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; |
| 1258 | 8261 mutex_exit(&cportinfo->cport_mutex); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8262 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8263 rval = sata_probe_device(sata_hba_inst, &sata_device); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8264 if (rval != SATA_SUCCESS || |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8265 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8266 return (SATA_FAILURE); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8267 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8268 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8269 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8270 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8271 * Could not determine device type. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8272 * Degrade this device to unknown. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8273 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8274 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8275 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8276 return (SATA_SUCCESS); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8277 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8278 pmportinfo->pmport_dev_type = sata_device.satadev_type; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8279 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8280 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8281 * Initialize device to the desired state. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8282 * Even if it fails, the device will still |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8283 * attach but syslog will show the warning. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8284 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8285 if (sata_initialize_device(sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8286 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8287 /* Retry */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8288 (void) sata_initialize_device(sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8289 pmportinfo->pmport_sata_drive); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8290 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8291 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8292 sata_show_drive_info(sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8293 pmportinfo->pmport_sata_drive); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8294 pmportinfo->pmport_tgtnode_clean = B_TRUE; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8295 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8296 cdip = sata_create_target_node(pdip, sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8297 &sata_device.satadev_addr); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8298 mutex_enter(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8299 if (cdip == NULL) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8300 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8301 * Attaching target node failed. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8302 * We retain sata_drive_info structure... |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8303 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8304 pmportinfo->pmport_sata_drive-> |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8305 satadrv_type = SATA_DTYPE_UNKNOWN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8306 pmportinfo->pmport_sata_drive-> |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8307 satadrv_state = SATA_STATE_UNKNOWN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8308 pmportinfo->pmport_dev_type = |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8309 SATA_DTYPE_UNKNOWN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8310 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8311 return (SATA_SUCCESS); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8312 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8313 pmportinfo->pmport_sata_drive->satadrv_state |= |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8314 SATA_STATE_READY; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8315 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8316 mutex_exit(&cportinfo->cport_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8317 return (SATA_SUCCESS); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8318 } |
| 1258 | 8319 |
| 8320 | |
| 8321 /* | |
| 8322 * Create scsi target node for attached device, create node properties and | |
| 8323 * attach the node. | |
| 8324 * The node could be removed if the device onlining fails. | |
| 8325 * | |
| 8326 * A dev_info_t pointer is returned if operation is successful, NULL is | |
| 8327 * returned otherwise. | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8328 * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8329 * No port multiplier support. |
| 1258 | 8330 */ |
| 8331 | |
| 8332 static dev_info_t * | |
| 8333 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, | |
| 8334 sata_address_t *sata_addr) | |
| 8335 { | |
| 8336 dev_info_t *cdip = NULL; | |
| 8337 int rval; | |
| 8338 char *nname = NULL; | |
| 8339 char **compatible = NULL; | |
| 8340 int ncompatible; | |
| 8341 struct scsi_inquiry inq; | |
| 8342 sata_device_t sata_device; | |
| 8343 sata_drive_info_t *sdinfo; | |
| 8344 int target; | |
| 8345 int i; | |
| 8346 | |
| 8347 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 8348 sata_device.satadev_addr = *sata_addr; | |
| 8349 | |
| 8350 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); | |
| 8351 | |
| 8352 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 8353 | |
| 8354 target = SATA_TO_SCSI_TARGET(sata_addr->cport, | |
| 8355 sata_addr->pmport, sata_addr->qual); | |
| 8356 | |
| 8357 if (sdinfo == NULL) { | |
| 8358 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8359 sata_addr->cport))); | |
| 8360 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 8361 "sata_create_target_node: no sdinfo for target %x", | |
| 8362 target)); | |
| 8363 return (NULL); | |
| 8364 } | |
| 8365 | |
| 8366 /* | |
| 8367 * create scsi inquiry data, expected by | |
| 8368 * scsi_hba_nodename_compatible_get() | |
| 8369 */ | |
| 8370 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, (uint8_t *)&inq); | |
| 8371 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); | |
| 8372 | |
| 8373 /* determine the node name and compatible */ | |
| 8374 scsi_hba_nodename_compatible_get(&inq, NULL, | |
| 8375 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); | |
| 8376 | |
| 8377 #ifdef SATA_DEBUG | |
| 8378 if (sata_debug_flags & SATA_DBG_NODES) { | |
| 8379 if (nname == NULL) { | |
| 8380 cmn_err(CE_NOTE, "sata_create_target_node: " | |
| 8381 "cannot determine nodename for target %d\n", | |
| 8382 target); | |
| 8383 } else { | |
| 8384 cmn_err(CE_WARN, "sata_create_target_node: " | |
| 8385 "target %d nodename: %s\n", target, nname); | |
| 8386 } | |
| 8387 if (compatible == NULL) { | |
| 8388 cmn_err(CE_WARN, | |
| 8389 "sata_create_target_node: no compatible name\n"); | |
| 8390 } else { | |
| 8391 for (i = 0; i < ncompatible; i++) { | |
| 8392 cmn_err(CE_WARN, "sata_create_target_node: " | |
| 8393 "compatible name: %s\n", compatible[i]); | |
| 8394 } | |
| 8395 } | |
| 8396 } | |
| 8397 #endif | |
| 8398 | |
| 8399 /* if nodename can't be determined, log error and exit */ | |
| 8400 if (nname == NULL) { | |
| 8401 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 8402 "sata_create_target_node: cannot determine nodename " | |
| 8403 "for target %d\n", target)); | |
| 8404 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 8405 return (NULL); | |
| 8406 } | |
| 8407 /* | |
| 8408 * Create scsi target node | |
| 8409 */ | |
| 8410 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); | |
| 8411 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, | |
| 8412 "device-type", "scsi"); | |
| 8413 | |
| 8414 if (rval != DDI_PROP_SUCCESS) { | |
| 8415 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 8416 "updating device_type prop failed %d", rval)); | |
| 8417 goto fail; | |
| 8418 } | |
| 8419 | |
| 8420 /* | |
| 8421 * Create target node properties: target & lun | |
| 8422 */ | |
| 8423 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); | |
| 8424 if (rval != DDI_PROP_SUCCESS) { | |
| 8425 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 8426 "updating target prop failed %d", rval)); | |
| 8427 goto fail; | |
| 8428 } | |
| 8429 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); | |
| 8430 if (rval != DDI_PROP_SUCCESS) { | |
| 8431 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 8432 "updating target prop failed %d", rval)); | |
| 8433 goto fail; | |
| 8434 } | |
| 8435 | |
| 8436 /* decorate the node with compatible */ | |
| 8437 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", | |
| 8438 compatible, ncompatible) != DDI_PROP_SUCCESS) { | |
| 8439 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 8440 "sata_create_target_node: FAIL compatible props cdip 0x%p", | |
| 8441 (void *)cdip)); | |
| 8442 goto fail; | |
| 8443 } | |
| 8444 | |
| 8445 /* | |
| 8446 * Now, try to attach the driver. If probing of the device fails, | |
| 8447 * the target node may be removed | |
| 8448 */ | |
| 8449 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); | |
| 8450 | |
| 8451 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 8452 | |
| 8453 if (rval == NDI_SUCCESS) | |
| 8454 return (cdip); | |
| 8455 | |
| 8456 /* target node was removed - are we sure? */ | |
| 8457 return (NULL); | |
| 8458 | |
| 8459 fail: | |
| 8460 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 8461 ddi_prop_remove_all(cdip); | |
| 8462 rval = ndi_devi_free(cdip); | |
| 8463 if (rval != NDI_SUCCESS) { | |
| 8464 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 8465 "node removal failed %d", rval)); | |
| 8466 } | |
| 8467 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8468 "cannot create target node for SATA device at port %d", |
| 1258 | 8469 sata_addr->cport); |
| 8470 return (NULL); | |
| 8471 } | |
| 8472 | |
| 8473 | |
| 8474 | |
| 8475 /* | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8476 * Re-probe sata port, check for a device and attach info |
| 1258 | 8477 * structures when necessary. Identify Device data is fetched, if possible. |
| 8478 * Assumption: sata address is already validated. | |
| 8479 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of | |
| 8480 * the presence of a device and its type. | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8481 * |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8482 * flag arg specifies that the function should try multiple times to identify |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8483 * device type and to initialize it, or it should return immediately on failure. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8484 * SATA_DEV_IDENTIFY_RETRY - retry |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8485 * SATA_DEV_IDENTIFY_NORETRY - no retry |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8486 * |
| 1258 | 8487 * SATA_FAILURE is returned if one of the operations failed. |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8488 * |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8489 * This function cannot be called in interrupt context - it may sleep. |
| 1258 | 8490 */ |
| 8491 static int | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8492 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8493 int flag) |
| 1258 | 8494 { |
| 8495 sata_cport_info_t *cportinfo; | |
| 8496 sata_drive_info_t *sdinfo; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8497 boolean_t init_device = B_FALSE; |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8498 int prev_device_type = SATA_DTYPE_NONE; |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8499 int prev_device_settings = 0; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8500 clock_t start_time; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8501 int retry = B_FALSE; |
| 1258 | 8502 int rval; |
| 8503 | |
| 8504 /* We only care about host sata cport for now */ | |
| 8505 cportinfo = SATA_CPORT_INFO(sata_hba_inst, | |
| 8506 sata_device->satadev_addr.cport); | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8507 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8508 if (sdinfo != NULL) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8509 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8510 * We are re-probing port with a previously attached device. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8511 * Save previous device type and settings |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8512 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8513 prev_device_type = cportinfo->cport_dev_type; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8514 prev_device_settings = sdinfo->satadrv_settings; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8515 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8516 if (flag == SATA_DEV_IDENTIFY_RETRY) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8517 start_time = ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8518 retry = B_TRUE; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8519 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8520 retry_probe: |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8521 |
| 1258 | 8522 /* probe port */ |
| 8523 mutex_enter(&cportinfo->cport_mutex); | |
| 8524 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; | |
| 8525 cportinfo->cport_state |= SATA_STATE_PROBING; | |
| 8526 mutex_exit(&cportinfo->cport_mutex); | |
| 8527 | |
| 8528 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 8529 (SATA_DIP(sata_hba_inst), sata_device); | |
| 8530 | |
| 8531 mutex_enter(&cportinfo->cport_mutex); | |
| 8532 if (rval != SATA_SUCCESS) { | |
| 8533 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 8534 mutex_exit(&cportinfo->cport_mutex); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8535 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8536 "SATA port %d probing failed", |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
8537 cportinfo->cport_addr.cport)); |
| 1258 | 8538 return (SATA_FAILURE); |
| 8539 } | |
| 8540 | |
| 8541 /* | |
| 8542 * update sata port state and set device type | |
| 8543 */ | |
| 8544 sata_update_port_info(sata_hba_inst, sata_device); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8545 cportinfo->cport_state &= ~SATA_STATE_PROBING; |
| 1258 | 8546 |
| 8547 /* | |
| 8548 * Sanity check - Port is active? Is the link active? | |
| 8549 * Is there any device attached? | |
| 8550 */ | |
| 8551 if ((cportinfo->cport_state & | |
| 8552 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || | |
| 8553 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != | |
| 8554 SATA_PORT_DEVLINK_UP) { | |
| 8555 /* | |
| 8556 * Port in non-usable state or no link active/no device. | |
| 8557 * Free info structure if necessary (direct attached drive | |
| 8558 * only, for now! | |
| 8559 */ | |
| 8560 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 8561 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 8562 /* Add here differentiation for device attached or not */ | |
| 8563 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 8564 mutex_exit(&cportinfo->cport_mutex); | |
| 8565 if (sdinfo != NULL) | |
| 8566 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 8567 return (SATA_SUCCESS); | |
| 8568 } | |
| 8569 | |
| 8570 cportinfo->cport_state |= SATA_STATE_READY; | |
| 8571 cportinfo->cport_dev_type = sata_device->satadev_type; | |
| 8572 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 8573 | |
| 8574 /* | |
| 8575 * If we are re-probing the port, there may be | |
| 8576 * sata_drive_info structure attached | |
| 8577 * (or sata_pm_info, if PMult is supported). | |
| 8578 */ | |
| 8579 if (sata_device->satadev_type == SATA_DTYPE_NONE) { | |
| 8580 /* | |
| 8581 * There is no device, so remove device info structure, | |
| 8582 * if necessary. Direct attached drive only! | |
| 8583 */ | |
| 8584 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 8585 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 8586 if (sdinfo != NULL) { | |
| 8587 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 8588 sata_log(sata_hba_inst, CE_WARN, | |
| 8589 "SATA device detached " | |
| 8590 "from port %d", cportinfo->cport_addr.cport); | |
| 8591 } | |
| 8592 mutex_exit(&cportinfo->cport_mutex); | |
| 8593 return (SATA_SUCCESS); | |
| 8594 } | |
| 8595 | |
| 8596 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { | |
| 8597 if (sdinfo == NULL) { | |
| 8598 /* | |
| 8599 * There is some device attached, but there is | |
| 8600 * no sata_drive_info structure - allocate one | |
| 8601 */ | |
| 8602 mutex_exit(&cportinfo->cport_mutex); | |
| 8603 sdinfo = kmem_zalloc( | |
| 8604 sizeof (sata_drive_info_t), KM_SLEEP); | |
| 8605 mutex_enter(&cportinfo->cport_mutex); | |
| 8606 /* | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8607 * Recheck, that the port state did not change when we |
| 1258 | 8608 * released mutex. |
| 8609 */ | |
| 8610 if (cportinfo->cport_state & SATA_STATE_READY) { | |
| 8611 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; | |
| 8612 sdinfo->satadrv_addr = cportinfo->cport_addr; | |
| 8613 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; | |
| 8614 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8615 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 8616 } else { | |
| 8617 /* | |
| 8618 * Port is not in ready state, we | |
| 8619 * cannot attach a device. | |
| 8620 */ | |
| 8621 mutex_exit(&cportinfo->cport_mutex); | |
| 8622 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 8623 return (SATA_SUCCESS); | |
| 8624 } | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8625 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8626 * Since we are adding device, presumably new one, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8627 * indicate that it should be initalized, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8628 * as well as some internal framework states). |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8629 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8630 init_device = B_TRUE; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8631 } |
| 1258 | 8632 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; |
| 8633 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; | |
| 8634 } else { | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8635 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8636 * The device is a port multiplier - not handled now. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8637 */ |
| 1258 | 8638 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; |
| 8639 mutex_exit(&cportinfo->cport_mutex); | |
| 8640 return (SATA_SUCCESS); | |
| 8641 } | |
| 8642 mutex_exit(&cportinfo->cport_mutex); | |
| 8643 /* | |
| 8644 * Figure out what kind of device we are really | |
| 8645 * dealing with. | |
| 8646 */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8647 rval = sata_probe_device(sata_hba_inst, sata_device); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8648 |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8649 if (rval == SATA_SUCCESS) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8650 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8651 * If we are dealing with the same type of a device as before, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8652 * restore its settings flags. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8653 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8654 if (sata_device->satadev_type == prev_device_type) |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8655 sdinfo->satadrv_settings = prev_device_settings; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8656 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8657 /* Set initial device features, if necessary */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8658 if (init_device == B_TRUE) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8659 rval = sata_initialize_device(sata_hba_inst, sdinfo); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8660 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8661 if (rval == SATA_SUCCESS) |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8662 return (rval); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8663 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8664 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8665 if (retry) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8666 clock_t cur_time = ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8667 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8668 * A device was not successfully identified or initialized. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8669 * Track retry time for device identification. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8670 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8671 if ((cur_time - start_time) < |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8672 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8673 /* sleep for a while */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8674 delay(drv_usectohz(SATA_DEV_IDENTIFY_RETRY_DELAY)); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8675 goto retry_probe; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8676 } |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8677 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8678 return (rval); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8679 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8680 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8681 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8682 * Initialize device |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8683 * Specified device is initialized to a default state. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8684 * At this point only read cache and UDMA modes are set here. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8685 * Write cache mode should be set when a disk is configured. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8686 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8687 * Only SATA disks are initialized for now. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8688 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8689 * Returns SATA_SUCCESS if all device features are set successfully, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8690 * SATA_FAILURE otherwise |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8691 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8692 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8693 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8694 sata_drive_info_t *sdinfo) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8695 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8696 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8697 sata_save_drive_settings(sdinfo); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8698 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8699 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8700 |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8701 sata_init_write_cache_mode(sdinfo); |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8702 |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8703 return (sata_set_drive_features(sata_hba_inst, sdinfo, 0)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8704 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8705 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8706 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8707 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8708 * Initialize write cache mode. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8709 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8710 * The default write cache setting is provided by sata_write_cache |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8711 * static variable: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8712 * 1 - enable |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8713 * 0 - disable |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8714 * any other value - current drive setting |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8715 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8716 * In the future, it may be overridden by the |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8717 * disk-write-cache-enable property setting, if it is defined. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8718 * Returns SATA_SUCCESS if all device features are set successfully, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8719 * SATA_FAILURE otherwise. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8720 */ |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8721 static void |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8722 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8723 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8724 if (sata_write_cache == 1) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8725 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8726 else if (sata_write_cache == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8727 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8728 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8729 * When sata_write_cache value is not 0 or 1, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
8730 * a current setting of the drive's write cache is used. |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8731 */ |
| 1258 | 8732 } |
| 8733 | |
| 8734 | |
| 8735 /* | |
| 8736 * Validate sata address. | |
| 8737 * Specified cport, pmport and qualifier has to match | |
| 8738 * passed sata_scsi configuration info. | |
| 8739 * The presence of an attached device is not verified. | |
| 8740 * | |
| 8741 * Returns 0 when address is valid, -1 otherwise. | |
| 8742 */ | |
| 8743 static int | |
| 8744 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, | |
| 8745 int pmport, int qual) | |
| 8746 { | |
| 8747 if (qual == SATA_ADDR_DCPORT && pmport != 0) | |
| 8748 goto invalid_address; | |
| 8749 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 8750 goto invalid_address; | |
| 8751 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && | |
| 8752 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || | |
| 8753 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || | |
| 8754 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) | |
| 8755 goto invalid_address; | |
| 8756 | |
| 8757 return (0); | |
| 8758 | |
| 8759 invalid_address: | |
| 8760 return (-1); | |
| 8761 | |
| 8762 } | |
| 8763 | |
| 8764 /* | |
| 8765 * Validate scsi address | |
| 8766 * SCSI target address is translated into SATA cport/pmport and compared | |
| 8767 * with a controller port/device configuration. LUN has to be 0. | |
| 8768 * Returns 0 if a scsi target refers to an attached device, | |
| 8769 * returns 1 if address is valid but device is not attached, | |
| 8770 * returns -1 if bad address or device is of an unsupported type. | |
| 8771 * Upon return sata_device argument is set. | |
| 8772 */ | |
| 8773 static int | |
| 8774 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, | |
| 8775 struct scsi_address *ap, sata_device_t *sata_device) | |
| 8776 { | |
| 8777 int cport, pmport, qual, rval; | |
| 8778 | |
| 8779 rval = -1; /* Invalid address */ | |
| 8780 if (ap->a_lun != 0) | |
| 8781 goto out; | |
| 8782 | |
| 8783 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); | |
| 8784 cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 8785 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); | |
| 8786 | |
| 8787 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) | |
| 8788 goto out; | |
| 8789 | |
| 8790 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == | |
| 8791 0) { | |
| 8792 | |
| 8793 sata_cport_info_t *cportinfo; | |
| 8794 sata_pmult_info_t *pmultinfo; | |
| 8795 sata_drive_info_t *sdinfo = NULL; | |
| 8796 | |
| 8797 rval = 1; /* Valid sata address */ | |
| 8798 | |
| 8799 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 8800 if (qual == SATA_ADDR_DCPORT) { | |
| 8801 if (cportinfo == NULL || | |
| 8802 cportinfo->cport_dev_type == SATA_DTYPE_NONE) | |
| 8803 goto out; | |
| 8804 | |
| 8805 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT || | |
| 8806 (cportinfo->cport_dev_type & | |
| 8807 SATA_VALID_DEV_TYPE) == 0) { | |
| 8808 rval = -1; | |
| 8809 goto out; | |
| 8810 } | |
| 8811 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 8812 | |
| 8813 } else if (qual == SATA_ADDR_DPMPORT) { | |
| 8814 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); | |
| 8815 if (pmultinfo == NULL) { | |
| 8816 rval = -1; | |
| 8817 goto out; | |
| 8818 } | |
| 8819 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == | |
| 8820 NULL || | |
| 8821 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, | |
| 8822 pmport) == SATA_DTYPE_NONE) | |
| 8823 goto out; | |
| 8824 | |
| 8825 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, | |
| 8826 pmport); | |
| 8827 } else { | |
| 8828 rval = -1; | |
| 8829 goto out; | |
| 8830 } | |
| 8831 if ((sdinfo == NULL) || | |
| 8832 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) | |
| 8833 goto out; | |
| 8834 | |
| 8835 sata_device->satadev_type = sdinfo->satadrv_type; | |
| 8836 sata_device->satadev_addr.qual = qual; | |
| 8837 sata_device->satadev_addr.cport = cport; | |
| 8838 sata_device->satadev_addr.pmport = pmport; | |
| 8839 sata_device->satadev_rev = SATA_DEVICE_REV_1; | |
| 8840 return (0); | |
| 8841 } | |
| 8842 out: | |
| 8843 if (rval == 1) { | |
| 8844 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 8845 "sata_validate_scsi_address: no valid target %x lun %x", | |
| 8846 ap->a_target, ap->a_lun); | |
| 8847 } | |
| 8848 return (rval); | |
| 8849 } | |
| 8850 | |
| 8851 /* | |
| 8852 * Find dip corresponding to passed device number | |
| 8853 * | |
| 8854 * Returns NULL if invalid device number is passed or device cannot be found, | |
| 8855 * Returns dip is device is found. | |
| 8856 */ | |
| 8857 static dev_info_t * | |
| 8858 sata_devt_to_devinfo(dev_t dev) | |
| 8859 { | |
| 8860 dev_info_t *dip; | |
| 8861 #ifndef __lock_lint | |
| 8862 struct devnames *dnp; | |
| 8863 major_t major = getmajor(dev); | |
| 8864 int instance = SATA_MINOR2INSTANCE(getminor(dev)); | |
| 8865 | |
| 8866 if (major >= devcnt) | |
| 8867 return (NULL); | |
| 8868 | |
| 8869 dnp = &devnamesp[major]; | |
| 8870 LOCK_DEV_OPS(&(dnp->dn_lock)); | |
| 8871 dip = dnp->dn_head; | |
| 8872 while (dip && (ddi_get_instance(dip) != instance)) { | |
| 8873 dip = ddi_get_next(dip); | |
| 8874 } | |
| 8875 UNLOCK_DEV_OPS(&(dnp->dn_lock)); | |
| 8876 #endif | |
| 8877 | |
| 8878 return (dip); | |
| 8879 } | |
| 8880 | |
| 8881 | |
| 8882 /* | |
| 8883 * Probe device. | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
8884 * This function issues Identify Device command and initializes local |
| 1258 | 8885 * sata_drive_info structure if the device can be identified. |
| 8886 * The device type is determined by examining Identify Device | |
| 8887 * command response. | |
| 8888 * If the sata_hba_inst has linked drive info structure for this | |
| 8889 * device address, the Identify Device data is stored into sata_drive_info | |
| 8890 * structure linked to the port info structure. | |
| 8891 * | |
| 8892 * sata_device has to refer to the valid sata port(s) for HBA described | |
| 8893 * by sata_hba_inst structure. | |
| 8894 * | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8895 * Returns: |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8896 * SATA_SUCCESS if device type was successfully probed and port-linked |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8897 * drive info structure was updated; |
| 1258 | 8898 * SATA_FAILURE if there is no device, or device was not probed |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8899 * successully; |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8900 * SATA_RETRY if device probe can be retried later. |
| 1258 | 8901 * If a device cannot be identified, sata_device's dev_state and dev_type |
| 8902 * fields are set to unknown. | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8903 * There are no retries in this function. Any retries should be managed by |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8904 * the caller. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8905 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8906 |
| 1258 | 8907 |
| 8908 static int | |
| 8909 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) | |
| 8910 { | |
| 8911 sata_drive_info_t *sdinfo; | |
| 8912 sata_drive_info_t new_sdinfo; /* local drive info struct */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8913 int rval; |
| 1258 | 8914 |
| 8915 ASSERT((SATA_CPORT_STATE(sata_hba_inst, | |
| 8916 sata_device->satadev_addr.cport) & | |
| 8917 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); | |
| 8918 | |
| 8919 sata_device->satadev_type = SATA_DTYPE_NONE; | |
| 8920 | |
| 8921 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8922 sata_device->satadev_addr.cport))); | |
| 8923 | |
| 8924 /* Get pointer to port-linked sata device info structure */ | |
| 8925 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 8926 if (sdinfo != NULL) { | |
| 8927 sdinfo->satadrv_state &= | |
| 8928 ~(SATA_STATE_PROBED | SATA_STATE_READY); | |
| 8929 sdinfo->satadrv_state |= SATA_STATE_PROBING; | |
| 8930 } else { | |
| 8931 /* No device to probe */ | |
| 8932 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8933 sata_device->satadev_addr.cport))); | |
| 8934 sata_device->satadev_type = SATA_DTYPE_NONE; | |
| 8935 sata_device->satadev_state = SATA_STATE_UNKNOWN; | |
| 8936 return (SATA_FAILURE); | |
| 8937 } | |
| 8938 /* | |
| 8939 * Need to issue both types of identify device command and | |
| 8940 * determine device type by examining retreived data/status. | |
| 8941 * First, ATA Identify Device. | |
| 8942 */ | |
| 8943 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); | |
| 8944 new_sdinfo.satadrv_addr = sata_device->satadev_addr; | |
| 8945 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8946 sata_device->satadev_addr.cport))); | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8947 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8948 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8949 if (rval == SATA_RETRY) { |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8950 /* We may try to check for ATAPI device */ |
| 1258 | 8951 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { |
| 8952 /* | |
| 8953 * HBA supports ATAPI - try to issue Identify Packet | |
| 8954 * Device command. | |
| 8955 */ | |
| 8956 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8957 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8958 } |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8959 } else if (rval == SATA_FAILURE) |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8960 goto failure; |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
8961 else /* if (rval == SATA_SUCCESS) */ { |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8962 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8963 * Got something responding to ATA Identify Device or to |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8964 * Identify Packet Device cmd. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8965 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8966 sata_device->satadev_type = new_sdinfo.satadrv_type; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
8967 |
| 1258 | 8968 /* save device info, if possible */ |
| 8969 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8970 sata_device->satadev_addr.cport))); | |
| 8971 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 8972 if (sdinfo == NULL) { | |
| 8973 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8974 sata_device->satadev_addr.cport))); | |
| 8975 return (SATA_FAILURE); | |
| 8976 } | |
| 8977 /* | |
| 8978 * Copy drive info into the port-linked drive info structure. | |
| 8979 */ | |
| 8980 *sdinfo = new_sdinfo; | |
| 8981 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; | |
| 8982 sdinfo->satadrv_state |= SATA_STATE_PROBED; | |
| 8983 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) | |
| 8984 SATA_CPORT_DEV_TYPE(sata_hba_inst, | |
| 8985 sata_device->satadev_addr.cport) = | |
| 8986 sdinfo->satadrv_type; | |
| 8987 else /* SATA_ADDR_DPMPORT */ | |
| 8988 SATA_PMPORT_DEV_TYPE(sata_hba_inst, | |
| 8989 sata_device->satadev_addr.cport, | |
| 8990 sata_device->satadev_addr.pmport) = | |
| 8991 sdinfo->satadrv_type; | |
| 8992 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8993 sata_device->satadev_addr.cport))); | |
| 8994 return (SATA_SUCCESS); | |
| 8995 } | |
| 8996 | |
| 8997 failure: | |
| 8998 /* | |
| 8999 * Looks like we cannot determine the device type. | |
| 9000 */ | |
| 9001 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 9002 sata_device->satadev_addr.cport))); | |
| 9003 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 9004 if (sdinfo != NULL) { | |
| 9005 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; | |
| 9006 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 9007 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; | |
| 9008 sdinfo->satadrv_state = SATA_STATE_PROBED; | |
| 9009 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) | |
| 9010 SATA_CPORT_DEV_TYPE(sata_hba_inst, | |
| 9011 sata_device->satadev_addr.cport) = | |
| 9012 SATA_DTYPE_UNKNOWN; | |
| 9013 else { | |
| 9014 /* SATA_ADDR_DPMPORT */ | |
| 9015 if ((SATA_PMULT_INFO(sata_hba_inst, | |
| 9016 sata_device->satadev_addr.cport) != NULL) && | |
| 9017 (SATA_PMPORT_INFO(sata_hba_inst, | |
| 9018 sata_device->satadev_addr.cport, | |
| 9019 sata_device->satadev_addr.pmport) != NULL)) | |
| 9020 SATA_PMPORT_DEV_TYPE(sata_hba_inst, | |
| 9021 sata_device->satadev_addr.cport, | |
| 9022 sata_device->satadev_addr.pmport) = | |
| 9023 SATA_DTYPE_UNKNOWN; | |
| 9024 } | |
| 9025 } | |
| 9026 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 9027 sata_device->satadev_addr.cport))); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9028 return (rval); |
| 1258 | 9029 } |
| 9030 | |
| 9031 | |
| 9032 /* | |
| 9033 * Get pointer to sata_drive_info structure. | |
| 9034 * | |
| 9035 * The sata_device has to contain address (cport, pmport and qualifier) for | |
| 9036 * specified sata_scsi structure. | |
| 9037 * | |
| 9038 * Returns NULL if device address is not valid for this HBA configuration. | |
| 9039 * Otherwise, returns a pointer to sata_drive_info structure. | |
| 9040 * | |
| 9041 * This function should be called with a port mutex held. | |
| 9042 */ | |
| 9043 static sata_drive_info_t * | |
| 9044 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, | |
| 9045 sata_device_t *sata_device) | |
| 9046 { | |
| 9047 uint8_t cport = sata_device->satadev_addr.cport; | |
| 9048 uint8_t pmport = sata_device->satadev_addr.pmport; | |
| 9049 uint8_t qual = sata_device->satadev_addr.qual; | |
| 9050 | |
| 9051 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 9052 return (NULL); | |
| 9053 | |
| 9054 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & | |
| 9055 (SATA_STATE_PROBED | SATA_STATE_READY))) | |
| 9056 /* Port not probed yet */ | |
| 9057 return (NULL); | |
| 9058 | |
| 9059 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) | |
| 9060 return (NULL); | |
| 9061 | |
| 9062 if (qual == SATA_ADDR_DCPORT) { | |
| 9063 /* Request for a device on a controller port */ | |
| 9064 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == | |
| 9065 SATA_DTYPE_PMULT) | |
| 9066 /* Port multiplier attached */ | |
| 9067 return (NULL); | |
| 9068 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); | |
| 9069 } | |
| 9070 if (qual == SATA_ADDR_DPMPORT) { | |
| 9071 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != | |
| 9072 SATA_DTYPE_PMULT) | |
| 9073 return (NULL); | |
| 9074 | |
| 9075 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) | |
| 9076 return (NULL); | |
| 9077 | |
| 9078 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); | |
| 9079 } | |
| 9080 | |
| 9081 /* we should not get here */ | |
| 9082 return (NULL); | |
| 9083 } | |
| 9084 | |
| 9085 | |
| 9086 /* | |
| 9087 * sata_identify_device. | |
| 9088 * Send Identify Device command to SATA HBA driver. | |
| 9089 * If command executes successfully, update sata_drive_info structure pointed | |
| 9090 * to by sdinfo argument, including Identify Device data. | |
| 9091 * If command fails, invalidate data in sata_drive_info. | |
| 9092 * | |
| 9093 * Cannot be called from interrupt level. | |
| 9094 * | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
9095 * Returns: |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9096 * SATA_SUCCESS if the device was identified as a supported device, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9097 * SATA_RETRY if the device was not identified but could be retried, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9098 * SATA_FAILURE if the device was not identified and identify attempt |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9099 * should not be retried. |
| 1258 | 9100 */ |
| 9101 static int | |
| 9102 sata_identify_device(sata_hba_inst_t *sata_hba_inst, | |
| 9103 sata_drive_info_t *sdinfo) | |
| 9104 { | |
| 9105 uint16_t cfg_word; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
9106 int rval; |
| 1258 | 9107 int i; |
| 9108 | |
| 9109 /* fetch device identify data */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
9110 if ((rval = sata_fetch_device_identify_data( |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
9111 sata_hba_inst, sdinfo)) != 0) |
| 1258 | 9112 goto fail_unknown; |
| 9113 | |
| 9114 cfg_word = sdinfo->satadrv_id.ai_config; | |
| 9115 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK && | |
| 9116 (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) { | |
| 9117 /* Change device type to reflect Identify Device data */ | |
| 9118 if (((cfg_word & SATA_ATAPI_TYPE_MASK) == | |
| 9119 SATA_ATAPI_TYPE) && | |
| 9120 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) == | |
| 9121 SATA_ATAPI_CDROM_DEV)) { | |
| 9122 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; | |
| 9123 } else { | |
| 9124 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 9125 } | |
| 9126 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD && | |
| 9127 (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) || | |
| 9128 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) { | |
| 9129 /* Change device type to reflect Identify Device data ! */ | |
| 9130 if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) == | |
| 9131 SATA_ATA_TYPE) { | |
| 9132 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; | |
| 9133 } else { | |
| 9134 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 9135 } | |
| 9136 } | |
| 9137 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { | |
| 9138 if (sdinfo->satadrv_capacity == 0) { | |
| 9139 /* Non-LBA disk. Too bad... */ | |
| 9140 sata_log(sata_hba_inst, CE_WARN, | |
| 9141 "SATA disk device at port %d does not support LBA", | |
| 9142 sdinfo->satadrv_addr.cport); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9143 rval = SATA_FAILURE; |
| 1258 | 9144 goto fail_unknown; |
| 9145 } | |
| 9146 } | |
| 9147 /* Check for Ultra DMA modes 6 through 0 being supported */ | |
| 9148 for (i = 6; i >= 0; --i) { | |
| 9149 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) | |
| 9150 break; | |
| 9151 } | |
| 9152 /* | |
| 9153 * At least UDMA 4 mode has to be supported. If mode 4 or | |
| 9154 * higher are not supported by the device, fail this | |
| 9155 * device. | |
| 9156 */ | |
| 9157 if (i < 4) { | |
| 9158 /* No required Ultra DMA mode supported */ | |
| 9159 sata_log(sata_hba_inst, CE_WARN, | |
| 9160 "SATA disk device at port %d does not support UDMA " | |
| 9161 "mode 4 or higher", sdinfo->satadrv_addr.cport); | |
| 9162 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9163 "mode 4 or higher required, %d supported", i)); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9164 rval = SATA_FAILURE; |
| 1258 | 9165 goto fail_unknown; |
| 9166 } | |
| 9167 | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9168 return (SATA_SUCCESS); |
| 1258 | 9169 |
| 9170 fail_unknown: | |
| 9171 /* Invalidate sata_drive_info ? */ | |
| 9172 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 9173 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
9174 return (rval); |
| 1258 | 9175 } |
| 9176 | |
| 9177 /* | |
| 9178 * Log/display device information | |
| 9179 */ | |
| 9180 static void | |
| 9181 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, | |
| 9182 sata_drive_info_t *sdinfo) | |
| 9183 { | |
| 9184 int valid_version; | |
| 9185 char msg_buf[MAXPATHLEN]; | |
| 9186 | |
| 9187 /* Show HBA path */ | |
| 9188 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); | |
| 9189 | |
| 9190 cmn_err(CE_CONT, "?%s :\n", msg_buf); | |
| 9191 | |
| 9192 if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) { | |
| 9193 (void) sprintf(msg_buf, | |
| 9194 "Unsupported SATA device type (cfg 0x%x) at ", | |
| 9195 sdinfo->satadrv_id.ai_config); | |
| 9196 } else { | |
| 9197 (void) sprintf(msg_buf, "SATA %s device at", | |
| 9198 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 9199 "disk":"CD/DVD (ATAPI)"); | |
| 9200 } | |
| 9201 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) | |
| 9202 cmn_err(CE_CONT, "?\t%s port %d\n", | |
| 9203 msg_buf, sdinfo->satadrv_addr.cport); | |
| 9204 else | |
| 9205 cmn_err(CE_CONT, "?\t%s port %d pmport %d\n", | |
| 9206 msg_buf, sdinfo->satadrv_addr.cport, | |
| 9207 sdinfo->satadrv_addr.pmport); | |
| 9208 | |
| 9209 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, | |
| 9210 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 9211 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); | |
| 9212 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; | |
| 9213 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); | |
| 9214 | |
| 9215 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, | |
| 9216 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 9217 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 9218 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; | |
| 9219 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); | |
| 9220 | |
| 9221 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, | |
| 9222 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 9223 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 9224 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9225 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); |
| 1258 | 9226 |
| 9227 #ifdef SATA_DEBUG | |
| 9228 if (sdinfo->satadrv_id.ai_majorversion != 0 && | |
| 9229 sdinfo->satadrv_id.ai_majorversion != 0xffff) { | |
| 9230 int i; | |
| 9231 for (i = 14; i >= 2; i--) { | |
| 9232 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { | |
| 9233 valid_version = i; | |
| 9234 break; | |
| 9235 } | |
| 9236 } | |
| 9237 cmn_err(CE_CONT, | |
| 9238 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", | |
| 9239 valid_version, | |
| 9240 sdinfo->satadrv_id.ai_majorversion, | |
| 9241 sdinfo->satadrv_id.ai_minorversion); | |
| 9242 } | |
| 9243 #endif | |
| 9244 /* Log some info */ | |
| 9245 cmn_err(CE_CONT, "?\tsupported features:\n"); | |
| 9246 msg_buf[0] = '\0'; | |
| 9247 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) | |
| 9248 (void) strlcat(msg_buf, "48-bit LBA", MAXPATHLEN); | |
| 9249 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) | |
| 9250 (void) strlcat(msg_buf, "28-bit LBA", MAXPATHLEN); | |
| 9251 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) | |
| 9252 (void) strlcat(msg_buf, ", DMA", MAXPATHLEN); | |
| 9253 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) | |
| 9254 (void) strlcat(msg_buf, ", Native Command Queueing", | |
| 9255 MAXPATHLEN); | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
9256 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9257 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9258 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9259 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9260 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9261 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9262 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9263 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); |
| 1258 | 9264 cmn_err(CE_CONT, "?\t %s\n", msg_buf); |
| 9265 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) | |
| 9266 cmn_err(CE_CONT, "?\tSATA1 & SATA2 compatible\n"); | |
| 9267 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) | |
| 9268 cmn_err(CE_CONT, "?\tSATA1 compatible\n"); | |
| 2177 | 9269 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) { |
| 9270 cmn_err(CE_CONT, "?\tQueue depth %d\n", | |
| 4582 | 9271 sdinfo->satadrv_queue_depth); |
| 2177 | 9272 } |
| 1258 | 9273 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9274 if (sdinfo->satadrv_features_support & |
| 4582 | 9275 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9276 (void) sprintf(msg_buf, "\tqueue depth %d\n", |
| 4582 | 9277 sdinfo->satadrv_queue_depth); |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9278 cmn_err(CE_CONT, "?%s", msg_buf); |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9279 } |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9280 |
| 1258 | 9281 #ifdef __i386 |
| 9282 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", | |
| 4582 | 9283 sdinfo->satadrv_capacity); |
| 1258 | 9284 #else |
| 9285 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", | |
| 4582 | 9286 sdinfo->satadrv_capacity); |
| 1258 | 9287 #endif |
| 9288 cmn_err(CE_CONT, "?%s", msg_buf); | |
| 9289 } | |
| 9290 | |
| 9291 | |
| 9292 /* | |
| 9293 * sata_save_drive_settings extracts current setting of the device and stores | |
| 9294 * it for future reference, in case the device setup would need to be restored | |
| 9295 * after the device reset. | |
| 9296 * | |
| 9297 * At the moment only read ahead and write cache settings are saved, if the | |
| 9298 * device supports these features at all. | |
| 9299 */ | |
| 9300 static void | |
| 9301 sata_save_drive_settings(sata_drive_info_t *sdinfo) | |
| 9302 { | |
| 9303 if (!(sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 9304 !(sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 9305 /* None of the features is supported - do nothing */ | |
| 9306 return; | |
| 9307 } | |
| 9308 | |
| 9309 /* Current setting of Read Ahead (and Read Cache) */ | |
| 9310 if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD) | |
| 9311 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; | |
| 9312 else | |
| 9313 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; | |
| 9314 | |
| 9315 /* Current setting of Write Cache */ | |
| 9316 if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE) | |
| 9317 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; | |
| 9318 else | |
| 9319 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; | |
| 9320 } | |
| 9321 | |
| 9322 | |
| 9323 /* | |
| 9324 * sata_check_capacity function determines a disk capacity | |
| 9325 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. | |
| 9326 * | |
| 9327 * NOTE: CHS mode is not supported! If a device does not support LBA, | |
| 9328 * this function is not called. | |
| 9329 * | |
| 9330 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 | |
| 9331 */ | |
| 9332 static uint64_t | |
| 9333 sata_check_capacity(sata_drive_info_t *sdinfo) | |
| 9334 { | |
| 9335 uint64_t capacity = 0; | |
| 9336 int i; | |
| 9337 | |
| 9338 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || | |
| 9339 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) | |
| 9340 /* Capacity valid only for LBA-addressable disk devices */ | |
| 9341 return (0); | |
| 9342 | |
| 9343 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && | |
| 9344 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && | |
| 9345 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { | |
| 9346 /* LBA48 mode supported and enabled */ | |
| 9347 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | | |
| 9348 SATA_DEV_F_LBA28; | |
| 9349 for (i = 3; i >= 0; --i) { | |
| 9350 capacity <<= 16; | |
| 9351 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; | |
| 9352 } | |
| 9353 } else { | |
| 9354 capacity = sdinfo->satadrv_id.ai_addrsec[1]; | |
| 9355 capacity <<= 16; | |
| 9356 capacity += sdinfo->satadrv_id.ai_addrsec[0]; | |
| 9357 if (capacity >= 0x1000000) | |
| 9358 /* LBA28 mode */ | |
| 9359 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; | |
| 9360 } | |
| 9361 return (capacity); | |
| 9362 } | |
| 9363 | |
| 9364 | |
| 9365 /* | |
| 9366 * Allocate consistent buffer for DMA transfer | |
| 9367 * | |
| 9368 * Cannot be called from interrupt level or with mutex held - it may sleep. | |
| 9369 * | |
| 9370 * Returns pointer to allocated buffer structure, or NULL if allocation failed. | |
| 9371 */ | |
| 9372 static struct buf * | |
| 9373 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) | |
| 9374 { | |
| 9375 struct scsi_address ap; | |
| 9376 struct buf *bp; | |
| 9377 ddi_dma_attr_t cur_dma_attr; | |
| 9378 | |
| 9379 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 9380 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; | |
| 9381 ap.a_target = SATA_TO_SCSI_TARGET( | |
| 9382 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, | |
| 9383 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, | |
| 9384 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); | |
| 9385 ap.a_lun = 0; | |
| 9386 | |
| 9387 bp = scsi_alloc_consistent_buf(&ap, NULL, len, | |
| 4582 | 9388 B_READ, SLEEP_FUNC, NULL); |
| 1258 | 9389 |
| 9390 if (bp != NULL) { | |
| 9391 /* Allocate DMA resources for this buffer */ | |
| 9392 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; | |
| 9393 /* | |
| 9394 * We use a local version of the dma_attr, to account | |
| 9395 * for a device addressing limitations. | |
| 9396 * sata_adjust_dma_attr() will handle sdinfo == NULL which | |
| 9397 * will cause dma attributes to be adjusted to a lowest | |
| 9398 * acceptable level. | |
| 9399 */ | |
| 9400 sata_adjust_dma_attr(NULL, | |
| 9401 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); | |
| 9402 | |
| 9403 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, | |
| 9404 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { | |
| 9405 scsi_free_consistent_buf(bp); | |
| 9406 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 9407 bp = NULL; | |
| 9408 } | |
| 9409 } | |
| 9410 return (bp); | |
| 9411 } | |
| 9412 | |
| 9413 /* | |
| 9414 * Release local buffer (consistent buffer for DMA transfer) allocated | |
| 9415 * via sata_alloc_local_buffer(). | |
| 9416 */ | |
| 9417 static void | |
| 9418 sata_free_local_buffer(sata_pkt_txlate_t *spx) | |
| 9419 { | |
| 9420 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 9421 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
| 9422 ASSERT(spx->txlt_dma_cookie_list_len != 0); | |
| 9423 ASSERT(spx->txlt_buf_dma_handle != NULL); | |
| 9424 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); | |
| 9425 | |
| 9426 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; | |
| 9427 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; | |
| 9428 | |
| 9429 /* Free DMA resources */ | |
| 9430 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); | |
| 9431 ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 9432 spx->txlt_buf_dma_handle = 0; | |
| 9433 | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9434 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9435 kmem_free(spx->txlt_dma_cookie_list, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9436 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9437 spx->txlt_dma_cookie_list = NULL; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9438 spx->txlt_dma_cookie_list_len = 0; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9439 } |
| 1258 | 9440 /* Free buffer */ |
| 9441 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); | |
| 9442 } | |
| 9443 | |
| 9444 | |
| 9445 | |
| 9446 | |
| 9447 /* | |
| 9448 * Allocate sata_pkt | |
| 9449 * Pkt structure version and embedded strcutures version are initialized. | |
| 9450 * sata_pkt and sata_pkt_txlate structures are cross-linked. | |
| 9451 * | |
| 9452 * Since this may be called in interrupt context by sata_scsi_init_pkt, | |
| 9453 * callback argument determines if it can sleep or not. | |
| 9454 * Hence, it should not be called from interrupt context. | |
| 9455 * | |
| 9456 * If successful, non-NULL pointer to a sata pkt is returned. | |
| 9457 * Upon failure, NULL pointer is returned. | |
| 9458 */ | |
| 9459 static sata_pkt_t * | |
| 9460 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) | |
| 9461 { | |
| 9462 sata_pkt_t *spkt; | |
| 9463 int kmsflag; | |
| 9464 | |
| 9465 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; | |
| 9466 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); | |
| 9467 if (spkt == NULL) { | |
| 9468 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 9469 "sata_pkt_alloc: failed")); | |
| 9470 return (NULL); | |
| 9471 } | |
| 9472 spkt->satapkt_rev = SATA_PKT_REV; | |
| 9473 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; | |
| 9474 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; | |
| 9475 spkt->satapkt_framework_private = spx; | |
| 9476 spx->txlt_sata_pkt = spkt; | |
| 9477 return (spkt); | |
| 9478 } | |
| 9479 | |
| 9480 /* | |
| 9481 * Free sata pkt allocated via sata_pkt_alloc() | |
| 9482 */ | |
| 9483 static void | |
| 9484 sata_pkt_free(sata_pkt_txlate_t *spx) | |
| 9485 { | |
| 9486 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 9487 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); | |
| 9488 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); | |
| 9489 spx->txlt_sata_pkt = NULL; | |
| 9490 } | |
| 9491 | |
| 9492 | |
| 9493 /* | |
| 9494 * Adjust DMA attributes. | |
| 9495 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary | |
| 9496 * from 8 bits to 16 bits, depending on a command being used. | |
| 9497 * Limiting max block count arbitrarily to 256 for all read/write | |
| 9498 * commands may affects performance, so check both the device and | |
| 9499 * controller capability before adjusting dma attributes. | |
| 9500 * For ATAPI CD/DVD dma granularity has to be adjusted as well, | |
| 9501 * because these devices support block size of 2k rather | |
| 9502 * then 512 bytes. | |
| 9503 */ | |
| 9504 void | |
| 9505 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, | |
| 9506 ddi_dma_attr_t *adj_dma_attr) | |
| 9507 { | |
| 9508 uint32_t count_max; | |
| 9509 | |
| 9510 /* Copy original attributes */ | |
| 9511 *adj_dma_attr = *dma_attr; | |
| 9512 | |
| 9513 /* | |
| 9514 * Things to consider: device addressing capability, | |
| 9515 * "excessive" controller DMA capabilities. | |
| 9516 * If a device is being probed/initialized, there are | |
| 9517 * no device info - use default limits then. | |
| 9518 */ | |
| 9519 if (sdinfo == NULL) { | |
| 9520 count_max = dma_attr->dma_attr_granular * 0x100; | |
| 9521 if (dma_attr->dma_attr_count_max > count_max) | |
| 9522 adj_dma_attr->dma_attr_count_max = count_max; | |
| 9523 if (dma_attr->dma_attr_maxxfer > count_max) | |
| 9524 adj_dma_attr->dma_attr_maxxfer = count_max; | |
| 9525 return; | |
| 9526 } | |
| 9527 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 9528 /* arbitrarily modify controller dma granularity */ | |
| 9529 adj_dma_attr->dma_attr_granular = SATA_ATAPI_SECTOR_SIZE; | |
| 9530 } | |
| 9531 | |
| 9532 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { | |
| 9533 /* | |
| 9534 * 16-bit sector count may be used - we rely on | |
| 9535 * the assumption that only read and write cmds | |
| 9536 * will request more than 256 sectors worth of data | |
| 9537 */ | |
| 9538 count_max = adj_dma_attr->dma_attr_granular * 0x10000; | |
| 9539 } else { | |
| 9540 /* | |
| 9541 * 8-bit sector count will be used - default limits | |
| 9542 * for dma attributes | |
| 9543 */ | |
| 9544 count_max = adj_dma_attr->dma_attr_granular * 0x100; | |
| 9545 } | |
| 9546 | |
| 9547 | |
| 9548 /* | |
| 9549 * Adjust controler dma attributes, if necessary | |
| 9550 */ | |
| 9551 if (dma_attr->dma_attr_count_max > count_max) | |
| 9552 adj_dma_attr->dma_attr_count_max = count_max; | |
| 9553 if (dma_attr->dma_attr_maxxfer > count_max) | |
| 9554 adj_dma_attr->dma_attr_maxxfer = count_max; | |
| 9555 } | |
| 9556 | |
| 9557 | |
| 9558 /* | |
| 9559 * Allocate DMA resources for the buffer | |
| 9560 * This function handles initial DMA resource allocation as well as | |
| 9561 * DMA window shift and may be called repeatedly for the same DMA window | |
| 9562 * until all DMA cookies in the DMA window are processed. | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9563 * To guarantee that there is always a coherent set of cookies to process |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9564 * by SATA HBA driver (observing alignment, device granularity, etc.), |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9565 * the number of slots for DMA cookies is equal to lesser of a number of |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9566 * cookies in a DMA window and a max number of scatter/gather entries. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9567 * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9568 * Returns DDI_SUCCESS upon successful operation. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9569 * Return failure code of a failing command or DDI_FAILURE when |
| 1258 | 9570 * internal cleanup failed. |
| 9571 */ | |
| 9572 static int | |
| 9573 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, | |
| 9574 int (*callback)(caddr_t), caddr_t arg, | |
| 9575 ddi_dma_attr_t *cur_dma_attr) | |
| 9576 { | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9577 int rval; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9578 off_t offset; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9579 size_t size; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9580 int max_sg_len, req_len, i; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9581 uint_t dma_flags; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9582 struct buf *bp; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9583 uint64_t cur_txfer_len; |
| 1258 | 9584 |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9585 |
| 1258 | 9586 ASSERT(spx->txlt_sata_pkt != NULL); |
| 9587 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 9588 ASSERT(bp != NULL); | |
| 9589 | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9590 |
| 1258 | 9591 if (spx->txlt_buf_dma_handle == NULL) { |
| 9592 /* | |
| 9593 * No DMA resources allocated so far - this is a first call | |
| 9594 * for this sata pkt. | |
| 9595 */ | |
| 9596 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), | |
| 9597 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); | |
| 9598 | |
| 9599 if (rval != DDI_SUCCESS) { | |
| 9600 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 9601 "sata_dma_buf_setup: no buf DMA resources %x", | |
| 9602 rval)); | |
| 9603 return (rval); | |
| 9604 } | |
| 9605 | |
| 9606 if (bp->b_flags & B_READ) | |
| 9607 dma_flags = DDI_DMA_READ; | |
| 9608 else | |
| 9609 dma_flags = DDI_DMA_WRITE; | |
| 9610 | |
| 9611 if (flags & PKT_CONSISTENT) | |
| 9612 dma_flags |= DDI_DMA_CONSISTENT; | |
| 9613 | |
| 9614 if (flags & PKT_DMA_PARTIAL) | |
| 9615 dma_flags |= DDI_DMA_PARTIAL; | |
| 9616 | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9617 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9618 * Check buffer alignment and size against dma attributes |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9619 * Consider dma_attr_align only. There may be requests |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9620 * with the size lower then device granularity, but they |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9621 * will not read/write from/to the device, so no adjustment |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9622 * is necessary. The dma_attr_minxfer theoretically should |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9623 * be considered, but no HBA driver is checking it. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9624 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9625 if (IS_P2ALIGNED(bp->b_un.b_addr, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9626 cur_dma_attr->dma_attr_align)) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9627 rval = ddi_dma_buf_bind_handle( |
| 4582 | 9628 spx->txlt_buf_dma_handle, |
| 9629 bp, dma_flags, callback, arg, | |
| 9630 &spx->txlt_dma_cookie, | |
| 9631 &spx->txlt_curwin_num_dma_cookies); | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9632 } else { /* Buffer is not aligned */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9633 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9634 int (*ddicallback)(caddr_t); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9635 size_t bufsz; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9636 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9637 /* Check id sleeping is allowed */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9638 ddicallback = (callback == NULL_FUNC) ? |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9639 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9640 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9641 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, |
| 4582 | 9642 "mis-aligned buffer: addr=0x%p, cnt=%lu", |
| 9643 (void *)bp->b_un.b_addr, bp->b_bcount); | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9644 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9645 if (bp->b_flags & (B_PAGEIO|B_PHYS)) |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9646 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9647 * CPU will need to access data in the buffer |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9648 * (for copying) so map it. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9649 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9650 bp_mapin(bp); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9651 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9652 ASSERT(spx->txlt_tmp_buf == NULL); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9653 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9654 /* Buffer may be padded by ddi_dma_mem_alloc()! */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9655 rval = ddi_dma_mem_alloc( |
| 4582 | 9656 spx->txlt_buf_dma_handle, |
| 9657 bp->b_bcount, | |
| 9658 &sata_acc_attr, | |
| 9659 DDI_DMA_STREAMING, | |
| 9660 ddicallback, NULL, | |
| 9661 &spx->txlt_tmp_buf, | |
| 9662 &bufsz, | |
| 9663 &spx->txlt_tmp_buf_handle); | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9664 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9665 if (rval != DDI_SUCCESS) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9666 /* DMA mapping failed */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9667 (void) ddi_dma_free_handle( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9668 &spx->txlt_buf_dma_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9669 spx->txlt_buf_dma_handle = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9670 #ifdef SATA_DEBUG |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9671 mbuffail_count++; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9672 #endif |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9673 SATADBG1(SATA_DBG_DMA_SETUP, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9674 spx->txlt_sata_hba_inst, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9675 "sata_dma_buf_setup: " |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9676 "buf dma mem alloc failed %x\n", rval); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9677 return (rval); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9678 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9679 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9680 cur_dma_attr->dma_attr_align)); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9681 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9682 #ifdef SATA_DEBUG |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9683 mbuf_count++; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9684 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9685 if (bp->b_bcount != bufsz) |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9686 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9687 * This will require special handling, because |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9688 * DMA cookies will be based on the temporary |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9689 * buffer size, not the original buffer |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9690 * b_bcount, so the residue may have to |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9691 * be counted differently. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9692 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9693 SATADBG2(SATA_DBG_DMA_SETUP, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9694 spx->txlt_sata_hba_inst, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9695 "sata_dma_buf_setup: bp size %x != " |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9696 "bufsz %x\n", bp->b_bcount, bufsz); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9697 #endif |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9698 if (dma_flags & DDI_DMA_WRITE) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9699 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9700 * Write operation - copy data into |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9701 * an aligned temporary buffer. Buffer will be |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9702 * synced for device by ddi_dma_addr_bind_handle |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9703 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9704 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9705 bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9706 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9707 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9708 rval = ddi_dma_addr_bind_handle( |
| 4582 | 9709 spx->txlt_buf_dma_handle, |
| 9710 NULL, | |
| 9711 spx->txlt_tmp_buf, | |
| 9712 bufsz, dma_flags, ddicallback, 0, | |
| 9713 &spx->txlt_dma_cookie, | |
| 9714 &spx->txlt_curwin_num_dma_cookies); | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9715 } |
| 1258 | 9716 |
| 9717 switch (rval) { | |
| 9718 case DDI_DMA_PARTIAL_MAP: | |
| 9719 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 9720 "sata_dma_buf_setup: DMA Partial Map\n", NULL); | |
| 9721 /* | |
| 9722 * Partial DMA mapping. | |
| 9723 * Retrieve number of DMA windows for this request. | |
| 9724 */ | |
| 9725 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, | |
| 9726 &spx->txlt_num_dma_win) != DDI_SUCCESS) { | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9727 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9728 ddi_dma_mem_free( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9729 &spx->txlt_tmp_buf_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9730 spx->txlt_tmp_buf = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9731 } |
| 1258 | 9732 (void) ddi_dma_unbind_handle( |
| 9733 spx->txlt_buf_dma_handle); | |
| 9734 (void) ddi_dma_free_handle( | |
| 9735 &spx->txlt_buf_dma_handle); | |
| 9736 spx->txlt_buf_dma_handle = NULL; | |
| 9737 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 9738 "sata_dma_buf_setup: numwin failed\n")); | |
| 9739 return (DDI_FAILURE); | |
| 9740 } | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9741 SATADBG2(SATA_DBG_DMA_SETUP, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9742 spx->txlt_sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9743 "sata_dma_buf_setup: windows: %d, cookies: %d\n", |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9744 spx->txlt_num_dma_win, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9745 spx->txlt_curwin_num_dma_cookies); |
| 1258 | 9746 spx->txlt_cur_dma_win = 0; |
| 9747 break; | |
| 9748 | |
| 9749 case DDI_DMA_MAPPED: | |
| 9750 /* DMA fully mapped */ | |
| 9751 spx->txlt_num_dma_win = 1; | |
| 9752 spx->txlt_cur_dma_win = 0; | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9753 SATADBG1(SATA_DBG_DMA_SETUP, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9754 spx->txlt_sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9755 "sata_dma_buf_setup: windows: 1 " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9756 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); |
| 1258 | 9757 break; |
| 9758 | |
| 9759 default: | |
| 9760 /* DMA mapping failed */ | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9761 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9762 ddi_dma_mem_free( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9763 &spx->txlt_tmp_buf_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9764 spx->txlt_tmp_buf = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9765 } |
| 1258 | 9766 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); |
| 9767 spx->txlt_buf_dma_handle = NULL; | |
| 9768 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 9769 "sata_dma_buf_setup: buf dma handle binding " | |
| 9770 "failed %x\n", rval)); | |
| 9771 return (rval); | |
| 9772 } | |
| 9773 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 9774 spx->txlt_dma_cookie_list = NULL; | |
| 9775 } else { | |
| 9776 /* | |
| 9777 * DMA setup is reused. Check if we need to process more | |
| 9778 * cookies in current window, or to get next window, if any. | |
| 9779 */ | |
| 9780 | |
| 9781 ASSERT(spx->txlt_curwin_processed_dma_cookies <= | |
| 9782 spx->txlt_curwin_num_dma_cookies); | |
| 9783 | |
| 9784 if (spx->txlt_curwin_processed_dma_cookies == | |
| 9785 spx->txlt_curwin_num_dma_cookies) { | |
| 9786 /* | |
| 9787 * All cookies from current DMA window were processed. | |
| 9788 * Get next DMA window. | |
| 9789 */ | |
| 9790 spx->txlt_cur_dma_win++; | |
| 9791 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { | |
| 9792 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, | |
| 9793 spx->txlt_cur_dma_win, &offset, &size, | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9794 &spx->txlt_dma_cookie, |
| 1258 | 9795 &spx->txlt_curwin_num_dma_cookies); |
| 9796 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 9797 } else { | |
| 9798 /* No more windows! End of request! */ | |
| 9799 /* What to do? - panic for now */ | |
| 9800 ASSERT(spx->txlt_cur_dma_win >= | |
| 9801 spx->txlt_num_dma_win); | |
| 9802 | |
| 9803 spx->txlt_curwin_num_dma_cookies = 0; | |
| 9804 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 9805 spx->txlt_sata_pkt-> | |
| 9806 satapkt_cmd.satacmd_num_dma_cookies = 0; | |
| 9807 return (DDI_SUCCESS); | |
| 9808 } | |
| 9809 } | |
| 9810 } | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9811 /* There better be at least one DMA cookie outstanding */ |
| 1258 | 9812 ASSERT((spx->txlt_curwin_num_dma_cookies - |
| 9813 spx->txlt_curwin_processed_dma_cookies) > 0); | |
| 9814 | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9815 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9816 /* The default cookie slot was used in previous run */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9817 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9818 spx->txlt_dma_cookie_list = NULL; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9819 spx->txlt_dma_cookie_list_len = 0; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9820 } |
| 1258 | 9821 if (spx->txlt_curwin_processed_dma_cookies == 0) { |
| 9822 /* | |
| 9823 * Processing a new DMA window - set-up dma cookies list. | |
| 9824 * We may reuse previously allocated cookie array if it is | |
| 9825 * possible. | |
| 9826 */ | |
| 9827 if (spx->txlt_dma_cookie_list != NULL && | |
| 9828 spx->txlt_dma_cookie_list_len < | |
| 9829 spx->txlt_curwin_num_dma_cookies) { | |
| 9830 /* | |
| 9831 * New DMA window contains more cookies than | |
| 9832 * the previous one. We need larger cookie list - free | |
| 9833 * the old one. | |
| 9834 */ | |
| 9835 (void) kmem_free(spx->txlt_dma_cookie_list, | |
| 9836 spx->txlt_dma_cookie_list_len * | |
| 9837 sizeof (ddi_dma_cookie_t)); | |
| 9838 spx->txlt_dma_cookie_list = NULL; | |
| 9839 spx->txlt_dma_cookie_list_len = 0; | |
| 9840 } | |
| 9841 if (spx->txlt_dma_cookie_list == NULL) { | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9842 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9843 * Calculate lesser of number of cookies in this |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9844 * DMA window and number of s/g entries. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9845 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9846 max_sg_len = cur_dma_attr->dma_attr_sgllen; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9847 req_len = MIN(max_sg_len, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9848 spx->txlt_curwin_num_dma_cookies); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9849 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9850 /* Allocate new dma cookie array if necessary */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9851 if (req_len == 1) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9852 /* Only one cookie - no need for a list */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9853 spx->txlt_dma_cookie_list = |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9854 &spx->txlt_dma_cookie; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9855 spx->txlt_dma_cookie_list_len = 1; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9856 } else { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9857 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9858 * More than one cookie - try to allocate space. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9859 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9860 spx->txlt_dma_cookie_list = kmem_zalloc( |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9861 sizeof (ddi_dma_cookie_t) * req_len, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9862 callback == NULL_FUNC ? KM_NOSLEEP : |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9863 KM_SLEEP); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9864 if (spx->txlt_dma_cookie_list == NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9865 SATADBG1(SATA_DBG_DMA_SETUP, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9866 spx->txlt_sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9867 "sata_dma_buf_setup: cookie list " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9868 "allocation failed\n", NULL); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9869 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9870 * We could not allocate space for |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9871 * neccessary number of dma cookies in |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9872 * this window, so we fail this request. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9873 * Next invocation would try again to |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9874 * allocate space for cookie list. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9875 * Note:Packet residue was not modified. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9876 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9877 return (DDI_DMA_NORESOURCES); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9878 } else { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9879 spx->txlt_dma_cookie_list_len = req_len; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9880 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9881 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9882 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9883 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9884 * Fetch DMA cookies into cookie list in sata_pkt_txlate. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9885 * First cookie was already fetched. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9886 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9887 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9888 cur_txfer_len = |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9889 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9890 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9891 spx->txlt_curwin_processed_dma_cookies++; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9892 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9893 (i < spx->txlt_curwin_num_dma_cookies); i++) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9894 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, |
| 4582 | 9895 &spx->txlt_dma_cookie_list[i]); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9896 cur_txfer_len += |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9897 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9898 spx->txlt_curwin_processed_dma_cookies++; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9899 spx->txlt_sata_pkt-> |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9900 satapkt_cmd.satacmd_num_dma_cookies += 1; |
| 1258 | 9901 } |
| 9902 } else { | |
| 9903 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 9904 "sata_dma_buf_setup: sliding within DMA window, " | |
| 9905 "cur cookie %d, total cookies %d\n", | |
| 9906 spx->txlt_curwin_processed_dma_cookies, | |
| 9907 spx->txlt_curwin_num_dma_cookies); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9908 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9909 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9910 * Not all cookies from the current dma window were used because |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9911 * of s/g limitation. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9912 * There is no need to re-size the list - it was set at |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9913 * optimal size, or only default entry is used (s/g = 1). |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9914 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9915 if (spx->txlt_dma_cookie_list == NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9916 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9917 spx->txlt_dma_cookie_list_len = 1; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9918 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9919 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9920 * Since we are processing remaining cookies in a DMA window, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9921 * there may be less of them than the number of entries in the |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9922 * current dma cookie list. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9923 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9924 req_len = MIN(spx->txlt_dma_cookie_list_len, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9925 (spx->txlt_curwin_num_dma_cookies - |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9926 spx->txlt_curwin_processed_dma_cookies)); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9927 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9928 /* Fetch the next batch of cookies */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9929 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9930 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, |
| 4582 | 9931 &spx->txlt_dma_cookie_list[i]); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9932 cur_txfer_len += |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9933 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9934 spx->txlt_sata_pkt-> |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9935 satapkt_cmd.satacmd_num_dma_cookies++; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9936 spx->txlt_curwin_processed_dma_cookies++; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9937 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9938 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9939 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9940 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9941 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9942 /* Point sata_cmd to the cookie list */ |
| 1258 | 9943 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9944 &spx->txlt_dma_cookie_list[0]; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9945 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9946 /* Remember number of DMA cookies passed in sata packet */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9947 spx->txlt_num_dma_cookies = |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9948 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; |
| 1258 | 9949 |
| 9950 ASSERT(cur_txfer_len != 0); | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9951 if (cur_txfer_len <= bp->b_bcount) |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9952 spx->txlt_total_residue -= cur_txfer_len; |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9953 else { |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9954 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9955 * Temporary DMA buffer has been padded by |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9956 * ddi_dma_mem_alloc()! |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9957 * This requires special handling, because DMA cookies are |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9958 * based on the temporary buffer size, not the b_bcount, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9959 * and we have extra bytes to transfer - but the packet |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9960 * residue has to stay correct because we will copy only |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9961 * the requested number of bytes. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9962 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9963 spx->txlt_total_residue -= bp->b_bcount; |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
9964 } |
| 1258 | 9965 |
| 9966 return (DDI_SUCCESS); | |
| 9967 } | |
| 9968 | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9969 |
| 1258 | 9970 /* |
| 9971 * Fetch Device Identify data. | |
| 9972 * Send DEVICE IDENTIFY command to a device and get the device identify data. | |
| 9973 * The device_info structure has to be set to device type (for selecting proper | |
| 9974 * device identify command). | |
| 9975 * | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
9976 * Returns: |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9977 * SATA_SUCCESS if cmd succeeded |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9978 * SATA_RETRY if cmd was rejected and could be retried, |
|
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
9979 * SATA_FAILURE if cmd failed and should not be retried (port error) |
| 1258 | 9980 * |
| 9981 * Cannot be called in an interrupt context. | |
| 9982 */ | |
| 9983 | |
| 9984 static int | |
| 9985 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, | |
| 9986 sata_drive_info_t *sdinfo) | |
| 9987 { | |
| 9988 struct buf *bp; | |
| 9989 sata_pkt_t *spkt; | |
| 9990 sata_cmd_t *scmd; | |
| 9991 sata_pkt_txlate_t *spx; | |
| 9992 int rval; | |
| 9993 | |
| 9994 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); | |
| 9995 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 9996 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ | |
| 9997 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); | |
| 9998 if (spkt == NULL) { | |
| 9999 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
10000 return (SATA_RETRY); /* may retry later */ |
| 1258 | 10001 } |
| 10002 /* address is needed now */ | |
| 10003 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 10004 | |
| 10005 /* | |
| 10006 * Allocate buffer for Identify Data return data | |
| 10007 */ | |
| 10008 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); | |
| 10009 if (bp == NULL) { | |
| 10010 sata_pkt_free(spx); | |
| 10011 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 10012 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10013 "sata_fetch_device_identify_data: " | |
| 10014 "cannot allocate buffer for ID")); | |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
10015 return (SATA_RETRY); /* may retry later */ |
| 1258 | 10016 } |
| 10017 | |
| 10018 /* Fill sata_pkt */ | |
| 10019 sdinfo->satadrv_state = SATA_STATE_PROBING; | |
| 10020 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 10021 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; | |
| 10022 /* Synchronous mode, no callback */ | |
| 10023 spkt->satapkt_comp = NULL; | |
| 10024 /* Timeout 30s */ | |
| 10025 spkt->satapkt_time = sata_default_pkt_time; | |
| 10026 | |
| 10027 scmd = &spkt->satapkt_cmd; | |
| 10028 scmd->satacmd_bp = bp; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10029 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10030 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; |
| 1258 | 10031 |
| 10032 /* Build Identify Device cmd in the sata_pkt */ | |
| 10033 scmd->satacmd_addr_type = 0; /* N/A */ | |
| 10034 scmd->satacmd_sec_count_lsb = 0; /* N/A */ | |
| 10035 scmd->satacmd_lba_low_lsb = 0; /* N/A */ | |
| 10036 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ | |
| 10037 scmd->satacmd_lba_high_lsb = 0; /* N/A */ | |
| 10038 scmd->satacmd_features_reg = 0; /* N/A */ | |
| 10039 scmd->satacmd_device_reg = 0; /* Always device 0 */ | |
| 10040 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 10041 /* Identify Packet Device cmd */ | |
| 10042 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; | |
| 10043 } else { | |
| 10044 /* Identify Device cmd - mandatory for all other devices */ | |
| 10045 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; | |
| 10046 } | |
| 10047 | |
| 10048 /* Send pkt to SATA HBA driver */ | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10049 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10050 if (rval == SATA_TRAN_ACCEPTED && |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10051 spkt->satapkt_reason == SATA_PKT_COMPLETED) { |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10052 if ((sdinfo->satadrv_id.ai_config & SATA_INCOMPLETE_DATA) == |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10053 SATA_INCOMPLETE_DATA) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10054 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
10055 "SATA disk device at port %d - " |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
10056 "partial Identify Data", |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10057 sdinfo->satadrv_addr.cport)); |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
10058 rval = SATA_RETRY; /* may retry later */ |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
10059 goto fail; |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
10060 } |
| 1258 | 10061 /* Update sata_drive_info */ |
| 10062 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, | |
| 4582 | 10063 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
10064 ASSERT(rval == DDI_SUCCESS); |
| 1258 | 10065 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, |
| 10066 sizeof (sata_id_t)); | |
| 10067 | |
| 10068 sdinfo->satadrv_features_support = 0; | |
| 10069 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { | |
| 10070 /* | |
| 10071 * Retrieve capacity (disks only) and addressing mode | |
| 10072 */ | |
| 10073 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); | |
| 10074 } else { | |
| 10075 /* | |
| 10076 * For ATAPI devices one has to issue Get Capacity cmd | |
| 10077 * (not needed at the moment) | |
| 10078 */ | |
| 10079 sdinfo->satadrv_capacity = 0; | |
| 10080 } | |
| 10081 /* Setup supported features flags */ | |
| 10082 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) | |
| 10083 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; | |
| 10084 | |
| 10085 /* Check for NCQ support */ | |
| 10086 if (sdinfo->satadrv_id.ai_satacap != 0 && | |
| 10087 sdinfo->satadrv_id.ai_satacap != 0xffff) { | |
| 10088 /* SATA compliance */ | |
| 10089 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) | |
| 10090 sdinfo->satadrv_features_support |= | |
| 10091 SATA_DEV_F_NCQ; | |
| 10092 if (sdinfo->satadrv_id.ai_satacap & | |
| 10093 (SATA_1_SPEED | SATA_2_SPEED)) { | |
| 10094 if (sdinfo->satadrv_id.ai_satacap & | |
| 10095 SATA_2_SPEED) | |
| 10096 sdinfo->satadrv_features_support |= | |
| 10097 SATA_DEV_F_SATA2; | |
| 10098 if (sdinfo->satadrv_id.ai_satacap & | |
| 10099 SATA_1_SPEED) | |
| 10100 sdinfo->satadrv_features_support |= | |
| 10101 SATA_DEV_F_SATA1; | |
| 10102 } else { | |
| 10103 sdinfo->satadrv_features_support |= | |
| 10104 SATA_DEV_F_SATA1; | |
| 10105 } | |
| 10106 } | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
10107 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
10108 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
10109 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; |
| 1258 | 10110 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
10111 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
10112 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || |
| 4582 | 10113 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
10114 ++sdinfo->satadrv_queue_depth; |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
10115 rval = SATA_SUCCESS; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10116 } else { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10117 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10118 * Woops, no Identify Data. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10119 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10120 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { |
| 4582 | 10121 rval = SATA_RETRY; /* may retry later */ |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10122 } else if (rval == SATA_TRAN_ACCEPTED) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10123 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10124 spkt->satapkt_reason == SATA_PKT_ABORTED || |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10125 spkt->satapkt_reason == SATA_PKT_TIMEOUT || |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10126 spkt->satapkt_reason == SATA_PKT_RESET) |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
10127 rval = SATA_RETRY; /* may retry later */ |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10128 else |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
10129 rval = SATA_FAILURE; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10130 } else { |
|
4014
360fee62f0eb
6539787 marvell88sx driver needs to support multiple block PIO commands
ls24207
parents:
4013
diff
changeset
|
10131 rval = SATA_FAILURE; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
10132 } |
| 1258 | 10133 } |
| 10134 fail: | |
| 10135 /* Free allocated resources */ | |
| 10136 sata_free_local_buffer(spx); | |
| 10137 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 10138 sata_pkt_free(spx); | |
| 10139 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 10140 | |
| 10141 return (rval); | |
| 10142 } | |
| 10143 | |
| 10144 | |
| 10145 /* | |
| 10146 * SATA spec requires that the device supports at least UDMA 4 mode and | |
| 10147 * UDMA mode is selected. | |
| 10148 * Some devices (bridged devices) may not come-up with default UDMA mode | |
| 10149 * set correctly, so this function is setting it. | |
| 10150 * | |
| 10151 * Returns SATA_SUCCESS if proper UDMA mode is selected. | |
| 10152 * Returns SATA_FAILURE if proper UDMA mode could not be selected. | |
| 10153 */ | |
| 10154 static int | |
| 10155 sata_set_udma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) | |
| 10156 { | |
| 10157 sata_pkt_t *spkt; | |
| 10158 sata_cmd_t *scmd; | |
| 10159 sata_pkt_txlate_t *spx; | |
| 10160 int result = SATA_SUCCESS; | |
| 10161 int i, mode; | |
| 10162 | |
| 10163 ASSERT(sdinfo != NULL); | |
| 10164 ASSERT(sata_hba_inst != NULL); | |
| 10165 | |
| 10166 /* Find highest Ultra DMA mode supported */ | |
| 10167 for (mode = 6; mode >= 0; --mode) { | |
| 10168 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) | |
| 10169 break; | |
| 10170 } | |
| 10171 if (mode < 4) | |
| 10172 return (SATA_FAILURE); | |
| 10173 | |
| 10174 /* Find UDMA mode currently selected */ | |
| 10175 for (i = 6; i >= 0; --i) { | |
| 10176 if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8))) | |
| 10177 break; | |
| 10178 } | |
| 10179 | |
| 10180 if (i < mode) { | |
| 10181 /* Set UDMA mode via SET FEATURES COMMAND */ | |
| 10182 /* Prepare packet for SET FEATURES COMMAND */ | |
| 10183 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); | |
| 10184 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 10185 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ | |
| 10186 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); | |
| 10187 if (spkt == NULL) { | |
| 10188 result = SATA_FAILURE; | |
| 10189 goto failure; | |
| 10190 } | |
| 10191 /* Fill sata_pkt */ | |
| 10192 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 10193 /* Timeout 30s */ | |
| 10194 spkt->satapkt_time = sata_default_pkt_time; | |
| 10195 /* Synchronous mode, no callback, interrupts */ | |
| 10196 spkt->satapkt_op_mode = | |
| 10197 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; | |
| 10198 spkt->satapkt_comp = NULL; | |
| 10199 scmd = &spkt->satapkt_cmd; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10200 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10201 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; |
| 1258 | 10202 scmd->satacmd_addr_type = 0; |
| 10203 scmd->satacmd_device_reg = 0; | |
| 10204 scmd->satacmd_status_reg = 0; | |
| 10205 scmd->satacmd_error_reg = 0; | |
| 10206 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; | |
| 10207 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; | |
| 10208 scmd->satacmd_sec_count_lsb = | |
| 10209 SATAC_TRANSFER_MODE_ULTRA_DMA | mode; | |
| 10210 | |
| 10211 /* Transfer command to HBA */ | |
| 10212 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), | |
| 10213 spkt) != SATA_TRAN_ACCEPTED || | |
| 10214 spkt->satapkt_reason != SATA_PKT_COMPLETED) { | |
| 10215 /* Pkt execution failed */ | |
| 10216 result = SATA_FAILURE; | |
| 10217 } | |
| 10218 failure: | |
| 10219 if (result == SATA_FAILURE) | |
| 10220 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10221 "sata_set_udma_mode: could not set UDMA " | |
| 10222 "mode %", mode)); | |
| 10223 | |
| 10224 /* Free allocated resources */ | |
| 10225 if (spkt != NULL) | |
| 10226 sata_pkt_free(spx); | |
| 10227 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 10228 } | |
| 10229 return (result); | |
| 10230 } | |
| 10231 | |
| 10232 | |
| 10233 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10234 * Set device caching mode. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10235 * One of the following operations should be specified: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10236 * SATAC_SF_ENABLE_READ_AHEAD |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10237 * SATAC_SF_DISABLE_READ_AHEAD |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10238 * SATAC_SF_ENABLE_WRITE_CACHE |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10239 * SATAC_SF_DISABLE_WRITE_CACHE |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10240 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10241 * If operation fails, system log messgage is emitted. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10242 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10243 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10244 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10245 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10246 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10247 int cache_op) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10248 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10249 sata_pkt_t *spkt; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10250 sata_cmd_t *scmd; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10251 sata_pkt_txlate_t *spx; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10252 int rval = SATA_SUCCESS; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10253 char *infop; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10254 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10255 ASSERT(sdinfo != NULL); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10256 ASSERT(sata_hba_inst != NULL); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10257 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10258 cache_op == SATAC_SF_DISABLE_READ_AHEAD || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10259 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10260 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10261 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10262 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10263 /* Prepare packet for SET FEATURES COMMAND */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10264 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10265 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10266 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10267 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10268 if (spkt == NULL) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10269 rval = SATA_FAILURE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10270 goto failure; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10271 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10272 /* Fill sata_pkt */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10273 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10274 /* Timeout 30s */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10275 spkt->satapkt_time = sata_default_pkt_time; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10276 /* Synchronous mode, no callback, interrupts */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10277 spkt->satapkt_op_mode = |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10278 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10279 spkt->satapkt_comp = NULL; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10280 scmd = &spkt->satapkt_cmd; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10281 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10282 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10283 scmd->satacmd_addr_type = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10284 scmd->satacmd_device_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10285 scmd->satacmd_status_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10286 scmd->satacmd_error_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10287 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10288 scmd->satacmd_features_reg = cache_op; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10289 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10290 /* Transfer command to HBA */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10291 if (((*SATA_START_FUNC(sata_hba_inst))( |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10292 SATA_DIP(sata_hba_inst), spkt) != 0) || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10293 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10294 /* Pkt execution failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10295 switch (cache_op) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10296 case SATAC_SF_ENABLE_READ_AHEAD: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10297 infop = "enabling read ahead failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10298 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10299 case SATAC_SF_DISABLE_READ_AHEAD: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10300 infop = "disabling read ahead failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10301 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10302 case SATAC_SF_ENABLE_WRITE_CACHE: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10303 infop = "enabling write cache failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10304 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10305 case SATAC_SF_DISABLE_WRITE_CACHE: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10306 infop = "disabling write cache failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10307 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10308 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10309 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10310 rval = SATA_FAILURE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10311 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10312 failure: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10313 /* Free allocated resources */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10314 if (spkt != NULL) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10315 sata_pkt_free(spx); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10316 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10317 return (rval); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10318 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10319 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10320 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10321 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10322 /* |
| 1258 | 10323 * Update port SCR block |
| 10324 */ | |
| 10325 static void | |
| 10326 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device) | |
| 10327 { | |
| 10328 port_scr->sstatus = device->satadev_scr.sstatus; | |
| 10329 port_scr->serror = device->satadev_scr.serror; | |
| 10330 port_scr->scontrol = device->satadev_scr.scontrol; | |
| 10331 port_scr->sactive = device->satadev_scr.sactive; | |
| 10332 port_scr->snotific = device->satadev_scr.snotific; | |
| 10333 } | |
| 10334 | |
| 10335 /* | |
| 10336 * Update state and copy port ss* values from passed sata_device structure. | |
| 10337 * sata_address is validated - if not valid, nothing is changed in sata_scsi | |
| 10338 * configuration struct. | |
| 10339 * | |
| 10340 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function | |
| 10341 * regardless of the state in device argument. | |
| 10342 * | |
| 10343 * Port mutex should be held while calling this function. | |
| 10344 */ | |
| 10345 static void | |
| 10346 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, | |
| 10347 sata_device_t *sata_device) | |
| 10348 { | |
| 10349 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, | |
| 10350 sata_device->satadev_addr.cport))); | |
| 10351 | |
| 10352 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || | |
| 10353 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { | |
| 10354 | |
| 10355 sata_cport_info_t *cportinfo; | |
| 10356 | |
| 10357 if (SATA_NUM_CPORTS(sata_hba_inst) <= | |
| 10358 sata_device->satadev_addr.cport) | |
| 10359 return; | |
| 10360 | |
| 10361 cportinfo = SATA_CPORT_INFO(sata_hba_inst, | |
| 10362 sata_device->satadev_addr.cport); | |
| 10363 sata_update_port_scr(&cportinfo->cport_scr, sata_device); | |
| 10364 | |
| 10365 /* Preserve SATA_PSTATE_SHUTDOWN flag */ | |
| 10366 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | | |
| 10367 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); | |
| 10368 cportinfo->cport_state |= | |
| 10369 sata_device->satadev_state & SATA_PSTATE_VALID; | |
| 10370 } else { | |
| 10371 sata_pmport_info_t *pmportinfo; | |
| 10372 | |
| 10373 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) || | |
| 10374 (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || | |
| 10375 SATA_NUM_PMPORTS(sata_hba_inst, | |
| 10376 sata_device->satadev_addr.cport) < | |
| 10377 sata_device->satadev_addr.pmport) | |
| 10378 return; | |
| 10379 | |
| 10380 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, | |
| 10381 sata_device->satadev_addr.cport, | |
| 10382 sata_device->satadev_addr.pmport); | |
| 10383 sata_update_port_scr(&pmportinfo->pmport_scr, sata_device); | |
| 10384 | |
| 10385 /* Preserve SATA_PSTATE_SHUTDOWN flag */ | |
| 10386 pmportinfo->pmport_state &= | |
| 10387 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | | |
| 10388 SATA_PSTATE_FAILED); | |
| 10389 pmportinfo->pmport_state |= | |
| 10390 sata_device->satadev_state & SATA_PSTATE_VALID; | |
| 10391 } | |
| 10392 } | |
| 10393 | |
| 10394 | |
| 10395 | |
| 10396 /* | |
| 10397 * Extract SATA port specification from an IOCTL argument. | |
| 10398 * | |
| 10399 * This function return the port the user land send us as is, unless it | |
| 10400 * cannot retrieve port spec, then -1 is returned. | |
| 10401 * | |
| 10402 * Note: Only cport - no port multiplier port. | |
| 10403 */ | |
| 10404 static int32_t | |
| 10405 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) | |
| 10406 { | |
| 10407 int32_t port; | |
| 10408 | |
| 10409 /* Extract port number from nvpair in dca structure */ | |
| 10410 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { | |
| 10411 SATA_LOG_D((sata_hba_inst, CE_NOTE, | |
| 10412 "sata_get_port_num: invalid port spec 0x%x in ioctl", | |
| 10413 port)); | |
| 10414 port = -1; | |
| 10415 } | |
| 10416 | |
| 10417 return (port); | |
| 10418 } | |
| 10419 | |
| 10420 /* | |
| 10421 * Get dev_info_t pointer to the device node pointed to by port argument. | |
| 10422 * NOTE: target argument is a value used in ioctls to identify | |
| 10423 * the AP - it is not a sata_address. | |
| 10424 * It is a combination of cport, pmport and address qualifier, encodded same | |
| 10425 * way as a scsi target number. | |
| 10426 * At this moment it carries only cport number. | |
| 10427 * | |
| 10428 * No PMult hotplug support. | |
| 10429 * | |
| 10430 * Returns dev_info_t pointer if target device was found, NULL otherwise. | |
| 10431 */ | |
| 10432 | |
| 10433 static dev_info_t * | |
| 10434 sata_get_target_dip(dev_info_t *dip, int32_t port) | |
| 10435 { | |
| 10436 dev_info_t *cdip = NULL; | |
| 10437 int target, tgt; | |
| 10438 int ncport; | |
| 10439 int circ; | |
| 10440 | |
| 10441 ncport = port & SATA_CFGA_CPORT_MASK; | |
| 10442 target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT); | |
| 10443 | |
| 10444 ndi_devi_enter(dip, &circ); | |
| 10445 for (cdip = ddi_get_child(dip); cdip != NULL; ) { | |
| 10446 dev_info_t *next = ddi_get_next_sibling(cdip); | |
| 10447 | |
| 10448 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, | |
| 10449 DDI_PROP_DONTPASS, "target", -1); | |
| 10450 if (tgt == -1) { | |
| 10451 /* | |
| 10452 * This is actually an error condition, but not | |
| 10453 * a fatal one. Just continue the search. | |
| 10454 */ | |
| 10455 cdip = next; | |
| 10456 continue; | |
| 10457 } | |
| 10458 | |
| 10459 if (tgt == target) | |
| 10460 break; | |
| 10461 | |
| 10462 cdip = next; | |
| 10463 } | |
| 10464 ndi_devi_exit(dip, circ); | |
| 10465 | |
| 10466 return (cdip); | |
| 10467 } | |
| 10468 | |
| 10469 | |
| 10470 /* | |
| 10471 * sata_cfgadm_state: | |
| 10472 * Use the sata port state and state of the target node to figure out | |
| 10473 * the cfgadm_state. | |
| 10474 * | |
| 10475 * The port argument is a value with encoded cport, | |
| 10476 * pmport and address qualifier, in the same manner as a scsi target number. | |
| 10477 * SCSI_TO_SATA_CPORT macro extracts cport number, | |
| 10478 * SCSI_TO_SATA_PMPORT extracts pmport number and | |
| 10479 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. | |
| 10480 * | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10481 * For now, support is for cports only - no port multiplier device ports. |
| 1258 | 10482 */ |
| 10483 | |
| 10484 static void | |
| 10485 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, | |
| 10486 devctl_ap_state_t *ap_state) | |
| 10487 { | |
| 10488 uint16_t cport; | |
| 10489 int port_state; | |
| 10490 | |
| 10491 /* Cport only */ | |
| 10492 cport = SCSI_TO_SATA_CPORT(port); | |
| 10493 | |
| 10494 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); | |
| 10495 if (port_state & SATA_PSTATE_SHUTDOWN || | |
| 10496 port_state & SATA_PSTATE_FAILED) { | |
| 10497 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; | |
| 10498 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 10499 if (port_state & SATA_PSTATE_FAILED) | |
| 10500 ap_state->ap_condition = AP_COND_FAILED; | |
| 10501 else | |
| 10502 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 10503 | |
| 10504 return; | |
| 10505 } | |
| 10506 | |
| 10507 /* Need to check pmult device port here as well, when supported */ | |
| 10508 | |
| 10509 /* Port is enabled and ready */ | |
| 10510 | |
| 10511 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { | |
| 10512 case SATA_DTYPE_NONE: | |
| 10513 { | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10514 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10515 ap_state->ap_condition = AP_COND_OK; |
| 1258 | 10516 /* No device attached */ |
| 10517 ap_state->ap_rstate = AP_RSTATE_EMPTY; | |
| 10518 break; | |
| 10519 } | |
| 10520 case SATA_DTYPE_UNKNOWN: | |
| 10521 case SATA_DTYPE_ATAPINONCD: | |
| 10522 case SATA_DTYPE_PMULT: /* Until PMult is supported */ | |
| 10523 case SATA_DTYPE_ATADISK: | |
| 10524 case SATA_DTYPE_ATAPICD: | |
| 10525 { | |
| 10526 dev_info_t *tdip = NULL; | |
| 10527 dev_info_t *dip = NULL; | |
| 10528 int circ; | |
| 10529 | |
| 10530 dip = SATA_DIP(sata_hba_inst); | |
| 10531 tdip = sata_get_target_dip(dip, port); | |
| 10532 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 10533 if (tdip != NULL) { | |
| 10534 ndi_devi_enter(dip, &circ); | |
| 10535 mutex_enter(&(DEVI(tdip)->devi_lock)); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10536 if (DEVI_IS_DEVICE_REMOVED(tdip)) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10537 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10538 * There could be the case where previously |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10539 * configured and opened device was removed |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10540 * and unknown device was plugged. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10541 * In such case we want to show a device, and |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10542 * its configured or unconfigured state but |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10543 * indicate unusable condition untill the |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10544 * old target node is released and removed. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10545 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10546 ap_state->ap_condition = AP_COND_UNUSABLE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10547 } else { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10548 ap_state->ap_condition = AP_COND_OK; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10549 } |
| 1258 | 10550 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || |
| 10551 (DEVI_IS_DEVICE_DOWN(tdip))) { | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10552 ap_state->ap_ostate = |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10553 AP_OSTATE_UNCONFIGURED; |
| 1258 | 10554 } else { |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10555 ap_state->ap_ostate = |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10556 AP_OSTATE_CONFIGURED; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10557 } |
| 1258 | 10558 mutex_exit(&(DEVI(tdip)->devi_lock)); |
| 10559 ndi_devi_exit(dip, circ); | |
| 10560 } else { | |
| 10561 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 10562 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 10563 } | |
| 10564 break; | |
| 10565 } | |
| 10566 default: | |
| 10567 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 10568 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 10569 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 10570 /* | |
| 10571 * This is actually internal error condition (non fatal), | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
10572 * because we have already checked all defined device types. |
| 1258 | 10573 */ |
| 10574 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10575 "sata_cfgadm_state: Internal error: " | |
| 10576 "unknown device type")); | |
| 10577 break; | |
| 10578 } | |
| 10579 } | |
| 10580 | |
| 10581 /* | |
| 10582 * Start or terminate the thread, depending on flag arg and current state | |
| 10583 */ | |
| 10584 static void | |
| 10585 sata_event_thread_control(int startstop) | |
| 10586 { | |
| 10587 static int sata_event_thread_terminating = 0; | |
| 10588 static int sata_event_thread_starting = 0; | |
| 10589 int i; | |
| 10590 | |
| 10591 mutex_enter(&sata_event_mutex); | |
| 10592 | |
| 10593 if (startstop == 0 && (sata_event_thread_starting == 1 || | |
| 10594 sata_event_thread_terminating == 1)) { | |
| 10595 mutex_exit(&sata_event_mutex); | |
| 10596 return; | |
| 10597 } | |
| 10598 if (startstop == 1 && sata_event_thread_starting == 1) { | |
| 10599 mutex_exit(&sata_event_mutex); | |
| 10600 return; | |
| 10601 } | |
| 10602 if (startstop == 1 && sata_event_thread_terminating == 1) { | |
| 10603 sata_event_thread_starting = 1; | |
| 10604 /* wait til terminate operation completes */ | |
| 10605 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; | |
| 10606 while (sata_event_thread_terminating == 1) { | |
| 10607 if (i-- <= 0) { | |
| 10608 sata_event_thread_starting = 0; | |
| 10609 mutex_exit(&sata_event_mutex); | |
| 10610 #ifdef SATA_DEBUG | |
| 10611 cmn_err(CE_WARN, "sata_event_thread_control: " | |
| 10612 "timeout waiting for thread to terminate"); | |
| 10613 #endif | |
| 10614 return; | |
| 10615 } | |
| 10616 mutex_exit(&sata_event_mutex); | |
| 10617 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); | |
| 10618 mutex_enter(&sata_event_mutex); | |
| 10619 } | |
| 10620 } | |
| 10621 if (startstop == 1) { | |
| 10622 if (sata_event_thread == NULL) { | |
| 10623 sata_event_thread = thread_create(NULL, 0, | |
| 10624 (void (*)())sata_event_daemon, | |
| 10625 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); | |
| 10626 } | |
| 10627 sata_event_thread_starting = 0; | |
| 10628 mutex_exit(&sata_event_mutex); | |
| 10629 return; | |
| 10630 } | |
| 10631 | |
| 10632 /* | |
| 10633 * If we got here, thread may need to be terminated | |
| 10634 */ | |
| 10635 if (sata_event_thread != NULL) { | |
| 10636 int i; | |
| 10637 /* Signal event thread to go away */ | |
| 10638 sata_event_thread_terminating = 1; | |
| 10639 sata_event_thread_terminate = 1; | |
| 10640 cv_signal(&sata_event_cv); | |
| 10641 /* | |
| 10642 * Wait til daemon terminates. | |
| 10643 */ | |
| 10644 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; | |
| 10645 while (sata_event_thread_terminate == 1) { | |
| 10646 mutex_exit(&sata_event_mutex); | |
| 10647 if (i-- <= 0) { | |
| 10648 /* Daemon did not go away !!! */ | |
| 10649 #ifdef SATA_DEBUG | |
| 10650 cmn_err(CE_WARN, "sata_event_thread_control: " | |
| 10651 "cannot terminate event daemon thread"); | |
| 10652 #endif | |
| 10653 mutex_enter(&sata_event_mutex); | |
| 10654 break; | |
| 10655 } | |
| 10656 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); | |
| 10657 mutex_enter(&sata_event_mutex); | |
| 10658 } | |
| 10659 sata_event_thread_terminating = 0; | |
| 10660 } | |
| 10661 ASSERT(sata_event_thread_terminating == 0); | |
| 10662 ASSERT(sata_event_thread_starting == 0); | |
| 10663 mutex_exit(&sata_event_mutex); | |
| 10664 } | |
| 10665 | |
| 10666 | |
| 10667 /* | |
| 10668 * Log sata message | |
| 10669 * dev pathname msg line preceeds the logged message. | |
| 10670 */ | |
| 10671 | |
| 10672 static void | |
| 10673 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) | |
| 10674 { | |
| 10675 char pathname[128]; | |
| 10676 dev_info_t *dip; | |
| 10677 va_list ap; | |
| 10678 | |
| 10679 mutex_enter(&sata_log_mutex); | |
| 10680 | |
| 10681 va_start(ap, fmt); | |
| 10682 (void) vsprintf(sata_log_buf, fmt, ap); | |
| 10683 va_end(ap); | |
| 10684 | |
| 10685 if (sata_hba_inst != NULL) { | |
| 10686 dip = SATA_DIP(sata_hba_inst); | |
| 10687 (void) ddi_pathname(dip, pathname); | |
| 10688 } else { | |
| 10689 pathname[0] = 0; | |
| 10690 } | |
| 10691 if (level == CE_CONT) { | |
| 10692 if (sata_debug_flags == 0) | |
| 10693 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); | |
| 10694 else | |
| 10695 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); | |
| 10696 } else | |
| 10697 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); | |
| 10698 | |
| 10699 mutex_exit(&sata_log_mutex); | |
| 10700 } | |
| 10701 | |
| 10702 | |
| 10703 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ | |
| 10704 | |
| 10705 /* | |
| 10706 * SATA HBA event notification function. | |
| 10707 * Events reported by SATA HBA drivers per HBA instance relate to a change in | |
| 10708 * a port and/or device state or a controller itself. | |
| 10709 * Events for different addresses/addr types cannot be combined. | |
| 10710 * A warning message is generated for each event type. | |
| 10711 * Events are not processed by this function, so only the | |
| 10712 * event flag(s)is set for an affected entity and the event thread is | |
| 10713 * waken up. Event daemon thread processes all events. | |
| 10714 * | |
| 10715 * NOTE: Since more than one event may be reported at the same time, one | |
| 10716 * cannot determine a sequence of events when opposite event are reported, eg. | |
| 10717 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing | |
| 10718 * is taking precedence over reported events, i.e. may cause ignoring some | |
| 10719 * events. | |
| 10720 */ | |
| 10721 #define SATA_EVENT_MAX_MSG_LENGTH 79 | |
| 10722 | |
| 10723 void | |
| 10724 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) | |
| 10725 { | |
| 10726 sata_hba_inst_t *sata_hba_inst = NULL; | |
| 10727 sata_address_t *saddr; | |
| 10728 sata_drive_info_t *sdinfo; | |
| 10729 sata_port_stats_t *pstats; | |
| 10730 int cport, pmport; | |
| 10731 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; | |
| 10732 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; | |
| 10733 char *lcp; | |
| 10734 static char *err_msg_evnt_1 = | |
| 10735 "sata_hba_event_notify: invalid port event 0x%x "; | |
| 10736 static char *err_msg_evnt_2 = | |
| 10737 "sata_hba_event_notify: invalid device event 0x%x "; | |
| 10738 int linkevent; | |
| 10739 | |
| 10740 /* | |
| 10741 * There is a possibility that an event will be generated on HBA | |
| 10742 * that has not completed attachment or is detaching. | |
| 10743 * HBA driver should prevent this, but just in case it does not, | |
| 10744 * we need to ignore events for such HBA. | |
| 10745 */ | |
| 10746 mutex_enter(&sata_mutex); | |
| 10747 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 10748 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 10749 if (SATA_DIP(sata_hba_inst) == dip) | |
| 10750 if (sata_hba_inst->satahba_attached == 1) | |
| 10751 break; | |
| 10752 } | |
| 10753 mutex_exit(&sata_mutex); | |
| 10754 if (sata_hba_inst == NULL) | |
| 10755 /* HBA not attached */ | |
| 10756 return; | |
| 10757 | |
| 10758 ASSERT(sata_device != NULL); | |
| 10759 | |
| 10760 /* | |
| 10761 * Validate address before - do not proceed with invalid address. | |
| 10762 */ | |
| 10763 saddr = &sata_device->satadev_addr; | |
| 10764 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 10765 return; | |
| 10766 if (saddr->qual == SATA_ADDR_PMPORT || | |
| 10767 saddr->qual == SATA_ADDR_DPMPORT) | |
| 10768 /* Port Multiplier not supported yet */ | |
| 10769 return; | |
| 10770 | |
| 10771 cport = saddr->cport; | |
| 10772 pmport = saddr->pmport; | |
| 10773 | |
| 10774 buf1[0] = buf2[0] = '\0'; | |
| 10775 | |
| 10776 /* | |
| 10777 * Events refer to devices, ports and controllers - each has | |
| 10778 * unique address. Events for different addresses cannot be combined. | |
| 10779 */ | |
| 10780 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { | |
| 10781 | |
| 10782 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 10783 | |
| 10784 /* qualify this event(s) */ | |
| 10785 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { | |
| 10786 /* Invalid event for the device port */ | |
| 10787 (void) sprintf(buf2, err_msg_evnt_1, | |
| 10788 event & SATA_EVNT_PORT_EVENTS); | |
| 10789 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 10790 goto event_info; | |
| 10791 } | |
| 10792 if (saddr->qual == SATA_ADDR_CPORT) { | |
| 10793 /* Controller's device port event */ | |
| 10794 | |
| 10795 (SATA_CPORT_INFO(sata_hba_inst, cport))-> | |
| 10796 cport_event_flags |= | |
| 10797 event & SATA_EVNT_PORT_EVENTS; | |
| 10798 pstats = | |
| 10799 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> | |
| 10800 cport_stats; | |
| 10801 } else { | |
| 10802 /* Port multiplier's device port event */ | |
| 10803 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> | |
| 10804 pmport_event_flags |= | |
| 10805 event & SATA_EVNT_PORT_EVENTS; | |
| 10806 pstats = | |
| 10807 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> | |
| 10808 pmport_stats; | |
| 10809 } | |
| 10810 | |
| 10811 /* | |
| 10812 * Add to statistics and log the message. We have to do it | |
| 10813 * here rather than in the event daemon, because there may be | |
| 10814 * multiple events occuring before they are processed. | |
| 10815 */ | |
| 10816 linkevent = event & | |
| 4582 | 10817 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); |
| 1258 | 10818 if (linkevent) { |
| 10819 if (linkevent == (SATA_EVNT_LINK_LOST | | |
| 10820 SATA_EVNT_LINK_ESTABLISHED)) { | |
| 10821 /* This is likely event combination */ | |
| 10822 (void) strlcat(buf1, "link lost/established, ", | |
| 10823 SATA_EVENT_MAX_MSG_LENGTH); | |
| 10824 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10825 if (pstats->link_lost < 0xffffffffffffffffULL) |
| 1258 | 10826 pstats->link_lost++; |
| 10827 if (pstats->link_established < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10828 0xffffffffffffffffULL) |
| 1258 | 10829 pstats->link_established++; |
| 10830 linkevent = 0; | |
| 10831 } else if (linkevent & SATA_EVNT_LINK_LOST) { | |
| 10832 (void) strlcat(buf1, "link lost, ", | |
| 10833 SATA_EVENT_MAX_MSG_LENGTH); | |
| 10834 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10835 if (pstats->link_lost < 0xffffffffffffffffULL) |
| 1258 | 10836 pstats->link_lost++; |
| 10837 } else { | |
| 10838 (void) strlcat(buf1, "link established, ", | |
| 10839 SATA_EVENT_MAX_MSG_LENGTH); | |
| 10840 if (pstats->link_established < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10841 0xffffffffffffffffULL) |
| 1258 | 10842 pstats->link_established++; |
| 10843 } | |
| 10844 } | |
| 10845 if (event & SATA_EVNT_DEVICE_ATTACHED) { | |
| 10846 (void) strlcat(buf1, "device attached, ", | |
| 10847 SATA_EVENT_MAX_MSG_LENGTH); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10848 if (pstats->device_attached < 0xffffffffffffffffULL) |
| 1258 | 10849 pstats->device_attached++; |
| 10850 } | |
| 10851 if (event & SATA_EVNT_DEVICE_DETACHED) { | |
| 10852 (void) strlcat(buf1, "device detached, ", | |
| 10853 SATA_EVENT_MAX_MSG_LENGTH); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10854 if (pstats->device_detached < 0xffffffffffffffffULL) |
| 1258 | 10855 pstats->device_detached++; |
| 10856 } | |
| 10857 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { | |
| 10858 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 10859 "port %d power level changed", cport); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10860 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) |
| 1258 | 10861 pstats->port_pwr_changed++; |
| 10862 } | |
| 10863 | |
| 10864 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { | |
| 10865 /* There should be no other events for this address */ | |
| 10866 (void) sprintf(buf2, err_msg_evnt_1, | |
| 10867 event & ~SATA_EVNT_PORT_EVENTS); | |
| 10868 } | |
| 10869 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 10870 | |
| 10871 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { | |
| 10872 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 10873 | |
| 10874 /* qualify this event */ | |
| 10875 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { | |
| 10876 /* Invalid event for a device */ | |
| 10877 (void) sprintf(buf2, err_msg_evnt_2, | |
| 10878 event & SATA_EVNT_DEVICE_RESET); | |
| 10879 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 10880 goto event_info; | |
| 10881 } | |
| 10882 /* drive event */ | |
| 10883 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 10884 if (sdinfo != NULL) { | |
| 10885 if (event & SATA_EVNT_DEVICE_RESET) { | |
| 10886 (void) strlcat(buf1, "device reset, ", | |
| 10887 SATA_EVENT_MAX_MSG_LENGTH); | |
| 10888 if (sdinfo->satadrv_stats.drive_reset < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10889 0xffffffffffffffffULL) |
| 1258 | 10890 sdinfo->satadrv_stats.drive_reset++; |
| 10891 sdinfo->satadrv_event_flags |= | |
| 10892 SATA_EVNT_DEVICE_RESET; | |
| 10893 } | |
| 10894 } | |
| 10895 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { | |
| 10896 /* Invalid event for a device */ | |
| 10897 (void) sprintf(buf2, err_msg_evnt_2, | |
| 10898 event & ~SATA_EVNT_DRIVE_EVENTS); | |
| 10899 } | |
| 10900 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 10901 } else { | |
| 10902 if (saddr->qual != SATA_ADDR_NULL) { | |
| 10903 /* Wrong address qualifier */ | |
| 10904 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10905 "sata_hba_event_notify: invalid address 0x%x", | |
| 10906 *(uint32_t *)saddr)); | |
| 10907 return; | |
| 10908 } | |
| 10909 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || | |
| 10910 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { | |
| 10911 /* Invalid event for the controller */ | |
| 10912 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10913 "sata_hba_event_notify: invalid event 0x%x for " | |
| 10914 "controller", | |
| 10915 event & SATA_EVNT_CONTROLLER_EVENTS)); | |
| 10916 return; | |
| 10917 } | |
| 10918 buf1[0] = '\0'; | |
| 10919 /* This may be a frequent and not interesting event */ | |
| 10920 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 10921 "controller power level changed\n", NULL); | |
| 10922 | |
| 10923 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10924 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10925 0xffffffffffffffffULL) |
| 1258 | 10926 sata_hba_inst->satahba_stats.ctrl_pwr_change++; |
| 10927 | |
| 10928 sata_hba_inst->satahba_event_flags |= | |
| 10929 SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 10930 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10931 } | |
| 10932 /* | |
| 10933 * If we got here, there is something to do with this HBA | |
| 10934 * instance. | |
| 10935 */ | |
| 10936 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10937 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 10938 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10939 mutex_enter(&sata_mutex); | |
| 10940 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ | |
| 10941 mutex_exit(&sata_mutex); | |
| 10942 | |
| 10943 /* Tickle event thread */ | |
| 10944 mutex_enter(&sata_event_mutex); | |
| 10945 if (sata_event_thread_active == 0) | |
| 10946 cv_signal(&sata_event_cv); | |
| 10947 mutex_exit(&sata_event_mutex); | |
| 10948 | |
| 10949 event_info: | |
| 10950 if (buf1[0] != '\0') { | |
| 10951 lcp = strrchr(buf1, ','); | |
| 10952 if (lcp != NULL) | |
| 10953 *lcp = '\0'; | |
| 10954 } | |
| 10955 if (saddr->qual == SATA_ADDR_CPORT || | |
| 10956 saddr->qual == SATA_ADDR_DCPORT) { | |
| 10957 if (buf1[0] != '\0') { | |
| 10958 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", | |
| 10959 cport, buf1); | |
| 10960 } | |
| 10961 if (buf2[0] != '\0') { | |
| 10962 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", | |
| 10963 cport, buf2); | |
| 10964 } | |
| 10965 } else if (saddr->qual == SATA_ADDR_PMPORT || | |
| 10966 saddr->qual == SATA_ADDR_DPMPORT) { | |
| 10967 if (buf1[0] != '\0') { | |
| 10968 sata_log(sata_hba_inst, CE_NOTE, | |
| 10969 "port %d pmport %d: %s\n", cport, pmport, buf1); | |
| 10970 } | |
| 10971 if (buf2[0] != '\0') { | |
| 10972 sata_log(sata_hba_inst, CE_NOTE, | |
| 10973 "port %d pmport %d: %s\n", cport, pmport, buf2); | |
| 10974 } | |
| 10975 } | |
| 10976 } | |
| 10977 | |
| 10978 | |
| 10979 /* | |
| 10980 * Event processing thread. | |
| 10981 * Arg is a pointer to the sata_hba_list pointer. | |
| 10982 * It is not really needed, because sata_hba_list is global and static | |
| 10983 */ | |
| 10984 static void | |
| 10985 sata_event_daemon(void *arg) | |
| 10986 { | |
| 10987 #ifndef __lock_lint | |
| 10988 _NOTE(ARGUNUSED(arg)) | |
| 10989 #endif | |
| 10990 sata_hba_inst_t *sata_hba_inst; | |
| 10991 clock_t lbolt; | |
| 10992 | |
| 10993 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 10994 "SATA event daemon started\n", NULL); | |
| 10995 loop: | |
| 10996 /* | |
| 10997 * Process events here. Walk through all registered HBAs | |
| 10998 */ | |
| 10999 mutex_enter(&sata_mutex); | |
| 11000 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 11001 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 11002 ASSERT(sata_hba_inst != NULL); | |
| 11003 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 11004 if (sata_hba_inst->satahba_attached != 1 || | |
| 11005 (sata_hba_inst->satahba_event_flags & | |
| 11006 SATA_EVNT_SKIP) != 0) { | |
| 11007 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11008 continue; | |
| 11009 } | |
| 11010 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { | |
| 11011 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; | |
| 11012 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11013 mutex_exit(&sata_mutex); | |
| 11014 /* Got the controller with pending event */ | |
| 11015 sata_process_controller_events(sata_hba_inst); | |
| 11016 /* | |
| 11017 * Since global mutex was released, there is a | |
| 11018 * possibility that HBA list has changed, so start | |
| 11019 * over from the top. Just processed controller | |
| 11020 * will be passed-over because of the SKIP flag. | |
| 11021 */ | |
| 11022 goto loop; | |
| 11023 } | |
| 11024 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11025 } | |
| 11026 /* Clear SKIP flag in all controllers */ | |
| 11027 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 11028 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 11029 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 11030 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; | |
| 11031 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11032 } | |
| 11033 mutex_exit(&sata_mutex); | |
| 11034 | |
| 11035 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 11036 "SATA EVENT DAEMON suspending itself", NULL); | |
| 11037 | |
| 11038 #ifdef SATA_DEBUG | |
| 11039 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { | |
| 11040 sata_log(sata_hba_inst, CE_WARN, | |
| 11041 "SATA EVENTS PROCESSING DISABLED\n"); | |
| 11042 thread_exit(); /* Daemon will not run again */ | |
| 11043 } | |
| 11044 #endif | |
| 11045 mutex_enter(&sata_event_mutex); | |
| 11046 sata_event_thread_active = 0; | |
| 11047 mutex_exit(&sata_event_mutex); | |
| 11048 /* | |
| 11049 * Go to sleep/suspend itself and wake up either because new event or | |
| 11050 * wait timeout. Exit if there is a termination request (driver | |
| 11051 * unload). | |
| 11052 */ | |
| 11053 do { | |
| 11054 lbolt = ddi_get_lbolt(); | |
| 11055 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); | |
| 11056 mutex_enter(&sata_event_mutex); | |
| 11057 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt); | |
| 11058 | |
| 11059 if (sata_event_thread_active != 0) { | |
| 11060 mutex_exit(&sata_event_mutex); | |
| 11061 continue; | |
| 11062 } | |
| 11063 | |
| 11064 /* Check if it is time to go away */ | |
| 11065 if (sata_event_thread_terminate == 1) { | |
| 11066 /* | |
| 11067 * It is up to the thread setting above flag to make | |
| 11068 * sure that this thread is not killed prematurely. | |
| 11069 */ | |
| 11070 sata_event_thread_terminate = 0; | |
| 11071 sata_event_thread = NULL; | |
| 11072 mutex_exit(&sata_event_mutex); | |
| 11073 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 11074 "SATA_EVENT_DAEMON_TERMINATING", NULL); | |
| 11075 thread_exit(); { _NOTE(NOT_REACHED) } | |
| 11076 } | |
| 11077 mutex_exit(&sata_event_mutex); | |
| 11078 } while (!(sata_event_pending & SATA_EVNT_MAIN)); | |
| 11079 | |
| 11080 mutex_enter(&sata_event_mutex); | |
| 11081 sata_event_thread_active = 1; | |
| 11082 mutex_exit(&sata_event_mutex); | |
| 11083 | |
| 11084 mutex_enter(&sata_mutex); | |
| 11085 sata_event_pending &= ~SATA_EVNT_MAIN; | |
| 11086 mutex_exit(&sata_mutex); | |
| 11087 | |
| 11088 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 11089 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); | |
| 11090 | |
| 11091 goto loop; | |
| 11092 } | |
| 11093 | |
| 11094 /* | |
| 11095 * Specific HBA instance event processing. | |
| 11096 * | |
| 11097 * NOTE: At the moment, device event processing is limited to hard disks | |
| 11098 * only. | |
| 11099 * cports only are supported - no pmports. | |
| 11100 */ | |
| 11101 static void | |
| 11102 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) | |
| 11103 { | |
| 11104 int ncport; | |
| 11105 uint32_t event_flags; | |
| 11106 sata_address_t *saddr; | |
| 11107 | |
| 11108 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, | |
| 11109 "Processing controller %d event(s)", | |
| 11110 ddi_get_instance(SATA_DIP(sata_hba_inst))); | |
| 11111 | |
| 11112 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 11113 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; | |
| 11114 event_flags = sata_hba_inst->satahba_event_flags; | |
| 11115 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11116 /* | |
| 11117 * Process controller power change first | |
| 11118 * HERE | |
| 11119 */ | |
| 11120 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) | |
| 11121 sata_process_cntrl_pwr_level_change(sata_hba_inst); | |
| 11122 | |
| 11123 /* | |
| 11124 * Search through ports/devices to identify affected port/device. | |
| 11125 * We may have to process events for more than one port/device. | |
| 11126 */ | |
| 11127 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 11128 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 11129 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 11130 cport_event_flags; | |
| 11131 /* Check if port was locked by IOCTL processing */ | |
| 11132 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { | |
| 11133 /* | |
| 11134 * We ignore port events because port is busy | |
| 11135 * with AP control processing. Set again | |
| 11136 * controller and main event flag, so that | |
| 11137 * events may be processed by the next daemon | |
| 11138 * run. | |
| 11139 */ | |
| 11140 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 11141 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 11142 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 11143 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11144 mutex_enter(&sata_mutex); | |
| 11145 sata_event_pending |= SATA_EVNT_MAIN; | |
| 11146 mutex_exit(&sata_mutex); | |
| 11147 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, | |
| 11148 "Event processing postponed until " | |
| 11149 "AP control processing completes", | |
| 11150 NULL); | |
| 11151 /* Check other ports */ | |
| 11152 continue; | |
| 11153 } else { | |
| 11154 /* | |
| 11155 * Set BSY flag so that AP control would not | |
| 11156 * interfere with events processing for | |
| 11157 * this port. | |
| 11158 */ | |
| 11159 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 11160 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; | |
| 11161 } | |
| 11162 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 11163 | |
| 11164 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; | |
| 11165 | |
| 11166 if ((event_flags & | |
| 11167 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { | |
| 11168 /* | |
| 11169 * Got port event. | |
| 11170 * We need some hierarchy of event processing as they | |
| 11171 * are affecting each other: | |
| 11172 * 1. port failed | |
| 11173 * 2. device detached/attached | |
| 11174 * 3. link events - link events may trigger device | |
| 11175 * detached or device attached events in some | |
| 11176 * circumstances. | |
| 11177 * 4. port power level changed | |
| 11178 */ | |
| 11179 if (event_flags & SATA_EVNT_PORT_FAILED) { | |
| 11180 sata_process_port_failed_event(sata_hba_inst, | |
| 11181 saddr); | |
| 11182 } | |
| 11183 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { | |
| 11184 sata_process_device_detached(sata_hba_inst, | |
| 11185 saddr); | |
| 11186 } | |
| 11187 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { | |
| 11188 sata_process_device_attached(sata_hba_inst, | |
| 11189 saddr); | |
| 11190 } | |
| 11191 if (event_flags & | |
| 11192 (SATA_EVNT_LINK_ESTABLISHED | | |
| 11193 SATA_EVNT_LINK_LOST)) { | |
| 11194 sata_process_port_link_events(sata_hba_inst, | |
| 11195 saddr); | |
| 11196 } | |
| 11197 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { | |
| 11198 sata_process_port_pwr_change(sata_hba_inst, | |
| 11199 saddr); | |
| 11200 } | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11201 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11202 sata_process_target_node_cleanup( |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11203 sata_hba_inst, saddr); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11204 } |
| 1258 | 11205 } |
| 11206 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != | |
| 11207 SATA_DTYPE_NONE) { | |
| 11208 /* May have device event */ | |
| 11209 sata_process_device_reset(sata_hba_inst, saddr); | |
| 11210 } | |
| 11211 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 11212 /* Release PORT_BUSY flag */ | |
| 11213 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 11214 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; | |
| 11215 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 11216 | |
| 11217 } /* End of loop through the controller SATA ports */ | |
| 11218 } | |
| 11219 | |
| 11220 /* | |
| 11221 * Process HBA power level change reported by HBA driver. | |
| 11222 * Not implemented at this time - event is ignored. | |
| 11223 */ | |
| 11224 static void | |
| 11225 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) | |
| 11226 { | |
| 11227 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11228 "Processing controller power level change", NULL); | |
| 11229 | |
| 11230 /* Ignoring it for now */ | |
| 11231 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 11232 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 11233 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11234 } | |
| 11235 | |
| 11236 /* | |
| 11237 * Process port power level change reported by HBA driver. | |
| 11238 * Not implemented at this time - event is ignored. | |
| 11239 */ | |
| 11240 static void | |
| 11241 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, | |
| 11242 sata_address_t *saddr) | |
| 11243 { | |
| 11244 sata_cport_info_t *cportinfo; | |
| 11245 | |
| 11246 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11247 "Processing port power level change", NULL); | |
| 11248 | |
| 11249 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 11250 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11251 /* Reset event flag */ | |
| 11252 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 11253 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11254 } | |
| 11255 | |
| 11256 /* | |
| 11257 * Process port failure reported by HBA driver. | |
| 11258 * cports support only - no pmports. | |
| 11259 */ | |
| 11260 static void | |
| 11261 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, | |
| 11262 sata_address_t *saddr) | |
| 11263 { | |
| 11264 sata_cport_info_t *cportinfo; | |
| 11265 | |
| 11266 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 11267 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11268 /* Reset event flag first */ | |
| 11269 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; | |
| 11270 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ | |
| 11271 if ((cportinfo->cport_state & | |
| 11272 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { | |
| 11273 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11274 cport_mutex); | |
| 11275 return; | |
| 11276 } | |
| 11277 /* Fail the port */ | |
| 11278 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 11279 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11280 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); |
| 1258 | 11281 } |
| 11282 | |
| 11283 /* | |
| 11284 * Device Reset Event processing. | |
| 11285 * The seqeunce is managed by 3 stage flags: | |
| 11286 * - reset event reported, | |
| 11287 * - reset event being processed, | |
| 11288 * - request to clear device reset state. | |
| 11289 */ | |
| 11290 static void | |
| 11291 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, | |
| 11292 sata_address_t *saddr) | |
| 11293 { | |
| 11294 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ | |
| 11295 sata_drive_info_t *sdinfo; | |
| 11296 sata_cport_info_t *cportinfo; | |
| 11297 sata_device_t sata_device; | |
| 11298 int rval; | |
| 11299 | |
| 11300 /* We only care about host sata cport for now */ | |
| 11301 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 11302 | |
| 11303 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11304 | |
| 11305 /* If the port is in SHUTDOWN or FAILED state, ignore reset event. */ | |
| 11306 if ((cportinfo->cport_state & | |
| 11307 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 11308 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11309 cport_mutex); | |
| 11310 return; | |
| 11311 } | |
| 11312 | |
| 11313 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & | |
| 11314 SATA_VALID_DEV_TYPE) == 0) { | |
| 11315 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11316 cport_mutex); | |
| 11317 return; | |
| 11318 } | |
| 11319 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); | |
| 11320 if (sdinfo == NULL) { | |
| 11321 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11322 cport_mutex); | |
| 11323 return; | |
| 11324 } | |
| 11325 | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11326 if ((sdinfo->satadrv_event_flags & |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11327 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { |
| 1258 | 11328 /* Nothing to do */ |
| 11329 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11330 cport_mutex); | |
| 11331 return; | |
| 11332 } | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11333 #ifdef SATA_DEBUG |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11334 if ((sdinfo->satadrv_event_flags & |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11335 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11336 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { |
| 1258 | 11337 /* Something is weird - new device reset event */ |
| 11338 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11339 "Overlapping device reset events!", NULL); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11340 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11341 #endif |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11342 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11343 "Processing port %d device reset", saddr->cport); |
| 1258 | 11344 |
| 11345 /* Clear event flag */ | |
| 11346 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; | |
| 11347 | |
| 11348 /* It seems that we always need to check the port state first */ | |
| 11349 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 11350 sata_device.satadev_addr = *saddr; | |
| 11351 /* | |
| 11352 * We have to exit mutex, because the HBA probe port function may | |
| 11353 * block on its own mutex. | |
| 11354 */ | |
| 11355 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11356 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 11357 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 11358 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11359 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 11360 if (rval != SATA_SUCCESS) { | |
| 11361 /* Something went wrong? Fail the port */ | |
| 11362 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 11363 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11364 cport_mutex); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11365 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11366 "SATA port %d probing failed", |
| 1258 | 11367 saddr->cport)); |
| 11368 return; | |
| 11369 } | |
| 11370 if ((sata_device.satadev_scr.sstatus & | |
| 11371 SATA_PORT_DEVLINK_UP_MASK) != | |
| 11372 SATA_PORT_DEVLINK_UP || | |
| 11373 sata_device.satadev_type == SATA_DTYPE_NONE) { | |
| 11374 /* | |
| 11375 * No device to process, anymore. Some other event processing | |
| 11376 * would or have already performed port info cleanup. | |
| 11377 * To be safe (HBA may need it), request clearing device | |
| 11378 * reset condition. | |
| 11379 */ | |
| 11380 sdinfo->satadrv_event_flags = 0; | |
| 11381 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 11382 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11383 cport_mutex); | |
| 11384 return; | |
| 11385 } | |
| 11386 | |
| 11387 /* Mark device reset processing as active */ | |
| 11388 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; | |
| 11389 | |
| 11390 old_sdinfo = *sdinfo; /* local copy of the drive info */ | |
| 11391 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11392 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11393 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == |
| 1258 | 11394 SATA_FAILURE) { |
| 11395 /* | |
| 11396 * Restoring drive setting failed. | |
| 11397 * Probe the port first, to check if the port state has changed | |
| 11398 */ | |
| 11399 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 11400 sata_device.satadev_addr = *saddr; | |
| 11401 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 11402 /* probe port */ | |
| 11403 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 11404 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 11405 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11406 cport_mutex); | |
| 11407 if (rval == SATA_SUCCESS && | |
| 11408 (sata_device.satadev_state & | |
| 11409 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && | |
| 11410 (sata_device.satadev_scr.sstatus & | |
| 11411 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && | |
| 11412 (sata_device.satadev_type & SATA_DTYPE_ATADISK) != 0) { | |
| 11413 /* | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11414 * We may retry this a bit later - in-process reset |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11415 * condition is already set. |
| 1258 | 11416 */ |
| 11417 if ((cportinfo->cport_dev_type & | |
| 11418 SATA_VALID_DEV_TYPE) != 0 && | |
| 11419 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 11420 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 11421 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 11422 saddr->cport)->cport_mutex); | |
| 11423 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 11424 sata_hba_inst->satahba_event_flags |= | |
| 11425 SATA_EVNT_MAIN; | |
| 11426 mutex_exit(&sata_hba_inst->satahba_mutex); | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
11427 mutex_enter(&sata_mutex); |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
11428 sata_event_pending |= SATA_EVNT_MAIN; |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
11429 mutex_exit(&sata_mutex); |
| 1258 | 11430 return; |
| 11431 } | |
| 11432 } else { | |
| 11433 /* | |
| 11434 * No point of retrying - some other event processing | |
| 11435 * would or already did port info cleanup. | |
| 11436 * To be safe (HBA may need it), | |
| 11437 * request clearing device reset condition. | |
| 11438 */ | |
| 11439 sdinfo->satadrv_event_flags = 0; | |
| 11440 sdinfo->satadrv_event_flags |= | |
| 11441 SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 11442 } | |
| 11443 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11444 cport_mutex); | |
| 11445 return; | |
| 11446 } | |
| 11447 | |
| 11448 /* | |
| 11449 * Raise the flag indicating that the next sata command could | |
| 11450 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device | |
| 11451 * reset is reported. | |
| 11452 */ | |
| 11453 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11454 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 && | |
| 11455 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 11456 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 11457 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; | |
| 11458 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 11459 } | |
| 11460 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11461 } | |
| 11462 | |
| 11463 | |
| 11464 /* | |
| 11465 * Port Link Events processing. | |
| 11466 * Every link established event may involve device reset (due to | |
| 11467 * COMRESET signal, equivalent of the hard reset) so arbitrarily | |
| 11468 * set device reset event for an attached device (if any). | |
| 11469 * If the port is in SHUTDOWN or FAILED state, ignore link events. | |
| 11470 * | |
| 11471 * The link established event processing varies, depending on the state | |
| 11472 * of the target node, HBA hotplugging capabilities, state of the port. | |
| 11473 * If the link is not active, the link established event is ignored. | |
| 11474 * If HBA cannot detect device attachment and there is no target node, | |
| 11475 * the link established event triggers device attach event processing. | |
| 11476 * Else, link established event triggers device reset event processing. | |
| 11477 * | |
| 11478 * The link lost event processing varies, depending on a HBA hotplugging | |
| 11479 * capability and the state of the port (link active or not active). | |
| 11480 * If the link is active, the lost link event is ignored. | |
| 11481 * If HBA cannot detect device removal, the lost link event triggers | |
| 11482 * device detached event processing after link lost timeout. | |
| 11483 * Else, the event is ignored. | |
| 11484 * | |
| 11485 * NOTE: Only cports are processed for now, i.e. no port multiplier ports | |
| 11486 */ | |
| 11487 static void | |
| 11488 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, | |
| 11489 sata_address_t *saddr) | |
| 11490 { | |
| 11491 sata_device_t sata_device; | |
| 11492 sata_cport_info_t *cportinfo; | |
| 11493 sata_drive_info_t *sdinfo; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11494 uint32_t event_flags; |
| 1258 | 11495 int rval; |
| 11496 | |
| 11497 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11498 "Processing port %d link event(s)", saddr->cport); | |
| 11499 | |
| 11500 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 11501 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11502 event_flags = cportinfo->cport_event_flags; | |
| 11503 | |
| 11504 /* Reset event flags first */ | |
| 11505 cportinfo->cport_event_flags &= | |
| 11506 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); | |
| 11507 | |
| 11508 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ | |
| 11509 if ((cportinfo->cport_state & | |
| 11510 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 11511 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11512 cport_mutex); | |
| 11513 return; | |
| 11514 } | |
| 11515 | |
| 11516 /* | |
| 11517 * For the sanity sake get current port state. | |
| 11518 * Set device address only. Other sata_device fields should be | |
| 11519 * set by HBA driver. | |
| 11520 */ | |
| 11521 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 11522 sata_device.satadev_addr = *saddr; | |
| 11523 /* | |
| 11524 * We have to exit mutex, because the HBA probe port function may | |
| 11525 * block on its own mutex. | |
| 11526 */ | |
| 11527 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11528 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 11529 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 11530 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11531 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 11532 if (rval != SATA_SUCCESS) { | |
| 11533 /* Something went wrong? Fail the port */ | |
| 11534 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 11535 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11536 cport_mutex); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11537 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11538 "SATA port %d probing failed", |
| 1258 | 11539 saddr->cport)); |
| 11540 /* | |
| 11541 * We may want to release device info structure, but | |
| 11542 * it is not necessary. | |
| 11543 */ | |
| 11544 return; | |
| 11545 } else { | |
| 11546 /* port probed successfully */ | |
| 11547 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; | |
| 11548 } | |
| 11549 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { | |
| 11550 | |
| 11551 if ((sata_device.satadev_scr.sstatus & | |
| 11552 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { | |
| 11553 /* Ignore event */ | |
| 11554 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11555 "Ignoring port %d link established event - " | |
| 11556 "link down", | |
| 11557 saddr->cport); | |
| 11558 goto linklost; | |
| 11559 } | |
| 11560 | |
| 11561 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11562 "Processing port %d link established event", | |
| 11563 saddr->cport); | |
| 11564 | |
| 11565 /* | |
| 11566 * For the sanity sake check if a device is attached - check | |
| 11567 * return state of a port probing. | |
| 11568 */ | |
| 11569 if (sata_device.satadev_type != SATA_DTYPE_NONE && | |
| 11570 sata_device.satadev_type != SATA_DTYPE_PMULT) { | |
| 11571 /* | |
| 11572 * HBA port probe indicated that there is a device | |
| 11573 * attached. Check if the framework had device info | |
| 11574 * structure attached for this device. | |
| 11575 */ | |
| 11576 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 11577 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != | |
| 11578 NULL); | |
| 11579 | |
| 11580 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 11581 if ((sdinfo->satadrv_type & | |
| 11582 SATA_VALID_DEV_TYPE) != 0) { | |
| 11583 /* | |
| 11584 * Dev info structure is present. | |
| 11585 * If dev_type is set to known type in | |
| 11586 * the framework's drive info struct | |
| 11587 * then the device existed before and | |
| 11588 * the link was probably lost | |
| 11589 * momentarily - in such case | |
| 11590 * we may want to check device | |
| 11591 * identity. | |
| 11592 * Identity check is not supported now. | |
| 11593 * | |
| 11594 * Link established event | |
| 11595 * triggers device reset event. | |
| 11596 */ | |
| 11597 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 11598 satadrv_event_flags |= | |
| 11599 SATA_EVNT_DEVICE_RESET; | |
| 11600 } | |
| 11601 } else if (cportinfo->cport_dev_type == | |
| 11602 SATA_DTYPE_NONE) { | |
| 11603 /* | |
| 11604 * We got new device attached! If HBA does not | |
| 11605 * generate device attached events, trigger it | |
| 11606 * here. | |
| 11607 */ | |
| 11608 if (!(SATA_FEATURES(sata_hba_inst) & | |
| 11609 SATA_CTLF_HOTPLUG)) { | |
| 11610 cportinfo->cport_event_flags |= | |
| 11611 SATA_EVNT_DEVICE_ATTACHED; | |
| 11612 } | |
| 11613 } | |
| 11614 /* Reset link lost timeout */ | |
| 11615 cportinfo->cport_link_lost_time = 0; | |
| 11616 } | |
| 11617 } | |
| 11618 linklost: | |
| 11619 if (event_flags & SATA_EVNT_LINK_LOST) { | |
| 11620 if ((sata_device.satadev_scr.sstatus & | |
| 11621 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { | |
| 11622 /* Ignore event */ | |
| 11623 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11624 "Ignoring port %d link lost event - link is up", | |
| 11625 saddr->cport); | |
| 11626 goto done; | |
| 11627 } | |
| 11628 #ifdef SATA_DEBUG | |
| 11629 if (cportinfo->cport_link_lost_time == 0) { | |
| 11630 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11631 "Processing port %d link lost event", | |
| 11632 saddr->cport); | |
| 11633 } | |
| 11634 #endif | |
| 11635 /* | |
| 11636 * When HBA cannot generate device attached/detached events, | |
| 11637 * we need to track link lost time and eventually generate | |
| 11638 * device detach event. | |
| 11639 */ | |
| 11640 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { | |
| 11641 /* We are tracking link lost time */ | |
| 11642 if (cportinfo->cport_link_lost_time == 0) { | |
| 11643 /* save current time (lbolt value) */ | |
| 11644 cportinfo->cport_link_lost_time = | |
| 11645 ddi_get_lbolt(); | |
| 11646 /* just keep link lost event */ | |
| 11647 cportinfo->cport_event_flags |= | |
| 11648 SATA_EVNT_LINK_LOST; | |
| 11649 } else { | |
| 11650 clock_t cur_time = ddi_get_lbolt(); | |
| 11651 if ((cur_time - | |
| 11652 cportinfo->cport_link_lost_time) >= | |
| 11653 drv_usectohz( | |
| 11654 SATA_EVNT_LINK_LOST_TIMEOUT)) { | |
| 11655 /* trigger device detach event */ | |
| 11656 cportinfo->cport_event_flags |= | |
| 11657 SATA_EVNT_DEVICE_DETACHED; | |
| 11658 cportinfo->cport_link_lost_time = 0; | |
| 11659 SATADBG1(SATA_DBG_EVENTS, | |
| 11660 sata_hba_inst, | |
| 11661 "Triggering port %d " | |
| 11662 "device detached event", | |
| 11663 saddr->cport); | |
| 11664 } else { | |
| 11665 /* keep link lost event */ | |
| 11666 cportinfo->cport_event_flags |= | |
| 11667 SATA_EVNT_LINK_LOST; | |
| 11668 } | |
| 11669 } | |
| 11670 } | |
| 11671 /* | |
| 11672 * We could change port state to disable/delay access to | |
| 11673 * the attached device until the link is recovered. | |
| 11674 */ | |
| 11675 } | |
| 11676 done: | |
| 11677 event_flags = cportinfo->cport_event_flags; | |
| 11678 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11679 if (event_flags != 0) { | |
| 11680 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 11681 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 11682 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 11683 mutex_enter(&sata_mutex); | |
| 11684 sata_event_pending |= SATA_EVNT_MAIN; | |
| 11685 mutex_exit(&sata_mutex); | |
| 11686 } | |
| 11687 } | |
| 11688 | |
| 11689 /* | |
| 11690 * Device Detached Event processing. | |
| 11691 * Port is probed to find if a device is really gone. If so, | |
| 11692 * the device info structure is detached from the SATA port info structure | |
| 11693 * and released. | |
| 11694 * Port status is updated. | |
| 11695 * | |
| 11696 * NOTE: Process cports event only, no port multiplier ports. | |
| 11697 */ | |
| 11698 static void | |
| 11699 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, | |
| 11700 sata_address_t *saddr) | |
| 11701 { | |
| 11702 sata_cport_info_t *cportinfo; | |
| 11703 sata_drive_info_t *sdevinfo; | |
| 11704 sata_device_t sata_device; | |
| 11705 dev_info_t *tdip; | |
| 11706 int rval; | |
| 11707 | |
| 11708 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11709 "Processing port %d device detached", saddr->cport); | |
| 11710 | |
| 11711 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 11712 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11713 /* Clear event flag */ | |
| 11714 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; | |
| 11715 | |
| 11716 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ | |
| 11717 if ((cportinfo->cport_state & | |
| 11718 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 11719 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11720 cport_mutex); | |
| 11721 return; | |
| 11722 } | |
| 11723 /* For sanity, re-probe the port */ | |
| 11724 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 11725 sata_device.satadev_addr = *saddr; | |
| 11726 | |
| 11727 /* | |
| 11728 * We have to exit mutex, because the HBA probe port function may | |
| 11729 * block on its own mutex. | |
| 11730 */ | |
| 11731 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11732 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 11733 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 11734 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11735 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 11736 if (rval != SATA_SUCCESS) { | |
| 11737 /* Something went wrong? Fail the port */ | |
| 11738 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 11739 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11740 cport_mutex); | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11741 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11742 "SATA port %d probing failed", |
| 1258 | 11743 saddr->cport)); |
| 11744 /* | |
| 11745 * We may want to release device info structure, but | |
| 11746 * it is not necessary. | |
| 11747 */ | |
| 11748 return; | |
| 11749 } else { | |
| 11750 /* port probed successfully */ | |
| 11751 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; | |
| 11752 } | |
| 11753 /* | |
| 11754 * Check if a device is still attached. For sanity, check also | |
| 11755 * link status - if no link, there is no device. | |
| 11756 */ | |
| 11757 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == | |
| 11758 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != | |
| 11759 SATA_DTYPE_NONE) { | |
| 11760 /* | |
| 11761 * Device is still attached - ignore detach event. | |
| 11762 */ | |
| 11763 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 11764 cport_mutex); | |
| 11765 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11766 "Ignoring detach - device still attached to port %d", | |
| 11767 sata_device.satadev_addr.cport); | |
| 11768 return; | |
| 11769 } | |
| 11770 /* | |
| 11771 * We need to detach and release device info structure here | |
| 11772 */ | |
| 11773 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 11774 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 11775 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 11776 (void) kmem_free((void *)sdevinfo, | |
| 11777 sizeof (sata_drive_info_t)); | |
| 11778 } | |
| 11779 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 11780 /* | |
| 11781 * Device cannot be reached anymore, even if the target node may be | |
| 11782 * still present. | |
| 11783 */ | |
| 11784 | |
| 11785 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11786 sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d", | |
| 11787 sata_device.satadev_addr.cport); | |
| 11788 | |
| 11789 /* | |
| 11790 * Try to offline a device and remove target node if it still exists | |
| 11791 */ | |
| 11792 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); | |
| 11793 if (tdip != NULL) { | |
| 11794 /* | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11795 * Target node exists. Unconfigure device then remove |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11796 * the target node (one ndi operation). |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11797 */ |
| 1258 | 11798 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { |
| 11799 /* | |
| 11800 * PROBLEM - no device, but target node remained | |
| 11801 * This happens when the file was open or node was | |
| 11802 * waiting for resources. | |
| 11803 */ | |
| 11804 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 11805 "sata_process_device_detached: " | |
| 11806 "Failed to remove target node for " | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11807 "detached SATA device.")); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11808 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11809 * Set target node state to DEVI_DEVICE_REMOVED. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11810 * But re-check first that the node still exists. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11811 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11812 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11813 saddr->cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11814 if (tdip != NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11815 sata_set_device_removed(tdip); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11816 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11817 * Instruct event daemon to retry the |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11818 * cleanup later. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11819 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11820 sata_set_target_node_cleanup(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11821 saddr->cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11822 } |
| 1258 | 11823 } |
| 11824 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11825 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11826 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11827 * with the hint: SE_HINT_REMOVE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11828 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11829 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); |
| 1258 | 11830 } |
| 11831 | |
| 11832 | |
| 11833 /* | |
| 11834 * Device Attached Event processing. | |
| 11835 * Port state is checked to verify that a device is really attached. If so, | |
| 11836 * the device info structure is created and attached to the SATA port info | |
| 11837 * structure. | |
| 11838 * | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11839 * If attached device cannot be identified or set-up, the retry for the |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11840 * attach processing is set-up. Subsequent daemon run would try again to |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11841 * identify the device, until the time limit is reached |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11842 * (SATA_DEV_IDENTIFY_TIMEOUT). |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11843 * |
| 1258 | 11844 * This function cannot be called in interrupt context (it may sleep). |
| 11845 * | |
| 11846 * NOTE: Process cports event only, no port multiplier ports. | |
| 11847 */ | |
| 11848 static void | |
| 11849 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, | |
| 11850 sata_address_t *saddr) | |
| 11851 { | |
| 11852 sata_cport_info_t *cportinfo; | |
| 11853 sata_drive_info_t *sdevinfo; | |
| 11854 sata_device_t sata_device; | |
| 11855 dev_info_t *tdip; | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11856 uint32_t event_flags; |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11857 int rval; |
| 1258 | 11858 |
| 11859 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 11860 "Processing port %d device attached", saddr->cport); | |
| 11861 | |
| 11862 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 11863 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11864 | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11865 /* Clear attach event flag first */ |
| 1258 | 11866 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11867 |
| 1258 | 11868 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ |
| 11869 if ((cportinfo->cport_state & | |
| 11870 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11871 cportinfo->cport_dev_attach_time = 0; |
| 1258 | 11872 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> |
| 11873 cport_mutex); | |
| 11874 return; | |
| 11875 } | |
| 11876 | |
| 11877 /* | |
| 11878 * If the sata_drive_info structure is found attached to the port info, | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11879 * despite the fact the device was removed and now it is re-attached, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11880 * the old drive info structure was not removed. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11881 * Arbitrarily release device info structure. |
| 1258 | 11882 */ |
| 11883 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 11884 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 11885 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 11886 (void) kmem_free((void *)sdevinfo, | |
| 11887 sizeof (sata_drive_info_t)); | |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11888 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11889 "Arbitrarily detaching old device info.", NULL); |
| 1258 | 11890 } |
| 11891 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11892 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11893 /* For sanity, re-probe the port */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11894 sata_device.satadev_rev = SATA_DEVICE_REV; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11895 sata_device.satadev_addr = *saddr; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11896 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11897 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11898 * We have to exit mutex, because the HBA probe port function may |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11899 * block on its own mutex. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11900 */ |
| 1258 | 11901 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11902 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11903 (SATA_DIP(sata_hba_inst), &sata_device); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11904 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11905 sata_update_port_info(sata_hba_inst, &sata_device); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11906 if (rval != SATA_SUCCESS) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11907 /* Something went wrong? Fail the port */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11908 cportinfo->cport_state = SATA_PSTATE_FAILED; |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11909 cportinfo->cport_dev_attach_time = 0; |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11910 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11911 cport_mutex); |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11912 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11913 "SATA port %d probing failed", |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11914 saddr->cport)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11915 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11916 } else { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11917 /* port probed successfully */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11918 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11919 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11920 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11921 * Check if a device is still attached. For sanity, check also |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11922 * link status - if no link, there is no device. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11923 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11924 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11925 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11926 SATA_DTYPE_NONE) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11927 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11928 * No device - ignore attach event. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11929 */ |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11930 cportinfo->cport_dev_attach_time = 0; |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11931 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11932 cport_mutex); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11933 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11934 "Ignoring attach - no device connected to port %d", |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11935 sata_device.satadev_addr.cport); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11936 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11937 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11938 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11939 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11940 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11941 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11942 * with the hint: SE_HINT_INSERT |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11943 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11944 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11945 |
| 1258 | 11946 /* |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11947 * Port reprobing will take care of the creation of the device |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11948 * info structure and determination of the device type. |
| 1258 | 11949 */ |
| 11950 sata_device.satadev_addr = *saddr; | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11951 (void) sata_reprobe_port(sata_hba_inst, &sata_device, |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11952 SATA_DEV_IDENTIFY_NORETRY); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11953 |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11954 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11955 cport_mutex); |
| 1258 | 11956 if ((cportinfo->cport_state & SATA_STATE_READY) && |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11957 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11958 /* Some device is attached to the port */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11959 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11960 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11961 * A device was not successfully attached. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11962 * Track retry time for device identification. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11963 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11964 if (cportinfo->cport_dev_attach_time != 0) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11965 clock_t cur_time = ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11966 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11967 * If the retry time limit was not exceeded, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11968 * reinstate attach event. |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11969 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11970 if ((cur_time - |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11971 cportinfo->cport_dev_attach_time) < |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11972 drv_usectohz( |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11973 SATA_DEV_IDENTIFY_TIMEOUT)) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11974 /* OK, restore attach event */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11975 cportinfo->cport_event_flags |= |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11976 SATA_EVNT_DEVICE_ATTACHED; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11977 } else { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11978 /* Timeout - cannot identify device */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11979 cportinfo->cport_dev_attach_time = 0; |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11980 sata_log(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11981 CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11982 "Cannot identify SATA device " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11983 "at port %d - device will not be " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11984 "attached.", |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11985 saddr->cport); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11986 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11987 } else { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11988 /* |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11989 * Start tracking time for device |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11990 * identification. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
11991 * Save current time (lbolt value). |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11992 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11993 cportinfo->cport_dev_attach_time = |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11994 ddi_get_lbolt(); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11995 /* Restore attach event */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11996 cportinfo->cport_event_flags |= |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11997 SATA_EVNT_DEVICE_ATTACHED; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11998 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
11999 } else { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12000 /* |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12001 * If device was successfully attached, an explicit |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12002 * 'configure' command will be needed to configure it. |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12003 * Log the message indicating that a device |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12004 * was attached. |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12005 */ |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12006 cportinfo->cport_dev_attach_time = 0; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12007 sata_log(sata_hba_inst, CE_WARN, |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12008 "SATA device detected at port %d", saddr->cport); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12009 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12010 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12011 sata_drive_info_t new_sdinfo; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12012 |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12013 /* Log device info data */ |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12014 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12015 cportinfo)); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12016 sata_show_drive_info(sata_hba_inst, |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12017 &new_sdinfo); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12018 } |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12019 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12020 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12021 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12022 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12023 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12024 * Make sure that there is no target node for that |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12025 * device. If so, release it. It should not happen, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12026 * unless we had problem removing the node when |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12027 * device was detached. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12028 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12029 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12030 saddr->cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12031 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12032 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12033 if (tdip != NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12034 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12035 #ifdef SATA_DEBUG |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12036 if ((cportinfo->cport_event_flags & |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12037 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12038 sata_log(sata_hba_inst, CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12039 "sata_process_device_attached: " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12040 "old device target node exists!"); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12041 #endif |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12042 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12043 * target node exists - try to unconfigure |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12044 * device and remove the node. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12045 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12046 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12047 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12048 rval = ndi_devi_offline(tdip, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12049 NDI_DEVI_REMOVE); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12050 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12051 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12052 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12053 if (rval == NDI_SUCCESS) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12054 cportinfo->cport_event_flags &= |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12055 ~SATA_EVNT_TARGET_NODE_CLEANUP; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12056 cportinfo->cport_tgtnode_clean = B_TRUE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12057 } else { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12058 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12059 * PROBLEM - the target node remained |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12060 * and it belongs to a previously |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12061 * attached device. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12062 * This happens when the file was open |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12063 * or the node was waiting for |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12064 * resources at the time the |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12065 * associated device was removed. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12066 * Instruct event daemon to retry the |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12067 * cleanup later. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12068 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12069 sata_log(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12070 CE_WARN, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12071 "Application(s) accessing " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12072 "previously attached SATA " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12073 "device have to release " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12074 "it before newly inserted " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12075 "device can be made accessible.", |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12076 saddr->cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12077 cportinfo->cport_event_flags |= |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12078 SATA_EVNT_TARGET_NODE_CLEANUP; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12079 cportinfo->cport_tgtnode_clean = |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12080 B_FALSE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12081 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12082 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12083 |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12084 } |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12085 } else { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12086 cportinfo->cport_dev_attach_time = 0; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12087 } |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12088 |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12089 event_flags = cportinfo->cport_event_flags; |
| 1258 | 12090 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); |
|
2960
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12091 if (event_flags != 0) { |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12092 mutex_enter(&sata_hba_inst->satahba_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12093 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12094 mutex_exit(&sata_hba_inst->satahba_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12095 mutex_enter(&sata_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12096 sata_event_pending |= SATA_EVNT_MAIN; |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12097 mutex_exit(&sata_mutex); |
|
0a0e45155fbd
6469980 sata module should retry identify device up to 60 sec after the device is hotplugged
pawelw
parents:
2734
diff
changeset
|
12098 } |
| 1258 | 12099 } |
| 12100 | |
| 12101 | |
| 12102 /* | |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12103 * Device Target Node Cleanup Event processing. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12104 * If the target node associated with a sata port device is in |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12105 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12106 * If the target node cannot be removed, the event flag is left intact, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12107 * so that event daemon may re-run this function later. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12108 * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12109 * This function cannot be called in interrupt context (it may sleep). |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12110 * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12111 * NOTE: Processes cport events only, not port multiplier ports. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12112 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12113 static void |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12114 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12115 sata_address_t *saddr) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12116 { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12117 sata_cport_info_t *cportinfo; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12118 dev_info_t *tdip; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12119 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12120 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12121 "Processing port %d device target node cleanup", saddr->cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12122 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12123 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12124 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12125 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12126 * Check if there is target node for that device and it is in the |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12127 * DEVI_DEVICE_REMOVED state. If so, release it. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12128 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12129 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12130 if (tdip != NULL) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12131 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12132 * target node exists - check if it is target node of |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12133 * a removed device. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12134 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12135 if (sata_check_device_removed(tdip) == B_TRUE) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12136 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12137 "sata_process_target_node_cleanup: " |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12138 "old device target node exists!", NULL); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12139 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12140 * Unconfigure and remove the target node |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12141 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12142 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12143 NDI_SUCCESS) { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12144 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12145 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12146 cportinfo->cport_event_flags &= |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12147 ~SATA_EVNT_TARGET_NODE_CLEANUP; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12148 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12149 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12150 return; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12151 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12152 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12153 * Event daemon will retry the cleanup later. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12154 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12155 mutex_enter(&sata_hba_inst->satahba_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12156 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12157 mutex_exit(&sata_hba_inst->satahba_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12158 mutex_enter(&sata_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12159 sata_event_pending |= SATA_EVNT_MAIN; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12160 mutex_exit(&sata_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12161 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12162 } else { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12163 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12164 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12165 cportinfo->cport_event_flags &= |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12166 ~SATA_EVNT_TARGET_NODE_CLEANUP; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12167 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12168 saddr->cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12169 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12170 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12171 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12172 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12173 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
12174 /* |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12175 * sata_set_drive_features function compares current device features setting |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12176 * with the saved device features settings and, if there is a difference, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12177 * it restores device features setting to the previously saved state. |
| 1258 | 12178 * Device Identify data has to be current. |
| 12179 * At the moment only read ahead and write cache settings are considered. | |
| 12180 * | |
| 12181 * This function cannot be called in the interrupt context (it may sleep). | |
| 12182 * | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12183 * The input argument sdinfo should point to the drive info structure |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12184 * to be updated after features are set. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12185 * |
| 1258 | 12186 * Returns TRUE if successful or there was nothing to do. |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12187 * Returns FALSE if device features could not be set . |
| 1258 | 12188 * |
| 12189 * Note: This function may fail the port, making it inaccessible. | |
| 12190 * Explicit port disconnect/connect or physical device | |
| 12191 * detach/attach is required to re-evaluate it's state afterwards | |
| 12192 */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12193 |
| 1258 | 12194 static int |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12195 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12196 sata_drive_info_t *sdinfo, int restore) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12197 { |
| 1258 | 12198 int rval = SATA_SUCCESS; |
| 12199 sata_drive_info_t new_sdinfo; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12200 char *finfo = "sata_set_drive_features: cannot"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12201 char *finfox; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12202 int cache_op; |
| 1258 | 12203 |
| 12204 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); | |
| 12205 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; | |
| 12206 new_sdinfo.satadrv_type = sdinfo->satadrv_type; | |
| 12207 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { | |
| 12208 /* | |
| 12209 * Cannot get device identification - retry later | |
| 12210 */ | |
| 12211 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12212 "%s fetch device identify data\n", finfo)); |
| 1258 | 12213 return (SATA_FAILURE); |
| 12214 } | |
| 12215 /* Arbitrarily set UDMA mode */ | |
| 12216 if (sata_set_udma_mode(sata_hba_inst, &new_sdinfo) != SATA_SUCCESS) { | |
| 12217 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12218 "%s set UDMA mode\n", finfo)); |
| 1258 | 12219 return (SATA_FAILURE); |
| 12220 } | |
| 12221 | |
| 12222 if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 12223 !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 12224 /* None of the features is supported - do nothing */ | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12225 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12226 "settable features not supported\n", NULL); |
| 1258 | 12227 return (SATA_SUCCESS); |
| 12228 } | |
| 12229 | |
| 12230 if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && | |
| 12231 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && | |
| 12232 ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && | |
| 12233 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { | |
| 12234 /* Nothing to do */ | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12235 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12236 "no device features to set\n", NULL); |
| 1258 | 12237 return (SATA_SUCCESS); |
| 12238 } | |
| 12239 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12240 finfox = (restore != 0) ? " restore device features" : |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12241 " initialize device features\n"; |
| 1258 | 12242 |
| 12243 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && | |
| 12244 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) { | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12245 if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) { |
| 1258 | 12246 /* Enable read ahead / read cache */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12247 cache_op = SATAC_SF_ENABLE_READ_AHEAD; |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12248 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12249 "enabling read cache\n", NULL); |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12250 } else { |
| 1258 | 12251 /* Disable read ahead / read cache */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12252 cache_op = SATAC_SF_DISABLE_READ_AHEAD; |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12253 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12254 "disabling read cache\n", NULL); |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12255 } |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12256 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12257 /* Try to set read cache mode */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12258 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12259 cache_op) != SATA_SUCCESS) { |
| 1258 | 12260 /* Pkt execution failed */ |
| 12261 rval = SATA_FAILURE; | |
| 12262 } | |
| 12263 } | |
| 12264 | |
| 12265 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && | |
| 12266 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { | |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12267 if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) { |
| 1258 | 12268 /* Enable write cache */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12269 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12270 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12271 "enabling write cache\n", NULL); |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12272 } else { |
| 1258 | 12273 /* Disable write cache */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12274 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; |
|
2734
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12275 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12276 "disabling write cache\n", NULL); |
|
1a2f23099c2a
6428449 sata disks have read cache disabled after being hot-plugged
pawelw
parents:
2593
diff
changeset
|
12277 } |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12278 /* Try to set write cache mode */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12279 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12280 cache_op) != SATA_SUCCESS) { |
| 1258 | 12281 /* Pkt execution failed */ |
| 12282 rval = SATA_FAILURE; | |
| 12283 } | |
| 12284 } | |
| 12285 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12286 if (rval == SATA_FAILURE) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12287 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12288 "%s %s", finfo, finfox)); |
| 1258 | 12289 |
| 12290 /* | |
| 12291 * We need to fetch Device Identify data again | |
| 12292 */ | |
| 12293 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { | |
| 12294 /* | |
| 12295 * Cannot get device identification - retry later | |
| 12296 */ | |
| 12297 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
12298 "%s cannot re-fetch device identify data\n")); |
| 1258 | 12299 rval = SATA_FAILURE; |
| 12300 } | |
| 12301 /* Copy device sata info. */ | |
| 12302 sdinfo->satadrv_id = new_sdinfo.satadrv_id; | |
| 12303 | |
| 12304 return (rval); | |
| 12305 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12306 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12307 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12308 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12309 * |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12310 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12311 * unable to determine. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12312 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12313 * Cannot be called in an interrupt context. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12314 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12315 * Called by sata_build_lsense_page_2f() |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12316 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12317 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12318 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12319 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12320 sata_drive_info_t *sdinfo) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12321 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12322 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12323 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12324 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12325 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12326 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12327 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12328 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12329 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12330 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12331 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12332 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12333 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12334 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12335 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12336 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12337 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12338 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12339 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12340 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12341 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12342 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12343 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12344 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12345 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12346 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12347 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12348 scmd->satacmd_flags.sata_special_regs = B_TRUE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12349 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12350 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12351 /* Set up which registers need to be returned */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12352 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12353 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12354 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12355 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12356 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12357 scmd->satacmd_sec_count_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12358 scmd->satacmd_lba_low_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12359 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12360 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12361 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12362 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12363 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12364 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12365 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12366 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12367 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12368 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12369 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12370 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12371 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12372 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12373 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12374 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12375 * Whoops, no SMART RETURN STATUS |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12376 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12377 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12378 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12379 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12380 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12381 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12382 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12383 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12384 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12385 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12386 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12387 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12388 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12389 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12390 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12391 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12392 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12393 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12394 rval = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12395 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12396 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12397 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12398 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12399 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12400 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12401 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12402 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12403 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12404 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12405 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12406 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12407 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12408 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12409 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12410 * Returns 0 if succeeded, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12411 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12412 * Cannot be called in an interrupt context. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12413 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12414 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12415 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12416 sata_fetch_smart_data( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12417 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12418 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12419 struct smart_data *smart_data) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12420 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12421 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12422 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12423 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12424 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12425 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12426 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12427 ASSERT(sizeof (struct smart_data) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12428 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12429 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12430 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12431 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12432 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12433 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12434 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12435 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12436 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12437 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12438 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12439 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12440 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12441 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12442 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12443 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12444 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12445 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12446 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12447 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12448 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12449 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12450 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12451 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12452 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12453 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12454 * Allocate buffer for SMART data |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12455 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12456 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12457 sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12458 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12459 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12460 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12461 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12462 "sata_fetch_smart_data: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12463 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12464 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12465 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12466 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12467 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12468 /* Build SMART_READ_DATA cmd in the sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12469 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12470 scmd->satacmd_sec_count_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12471 scmd->satacmd_lba_low_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12472 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12473 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12474 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12475 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12476 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12477 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12478 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12479 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12480 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12481 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12482 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12483 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12484 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12485 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12486 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12487 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12488 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12489 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12490 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12491 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12492 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12493 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12494 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
| 4582 | 12495 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
12496 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12497 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12498 sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12499 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12500 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12501 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12502 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12503 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12504 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12505 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12506 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12507 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12508 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12509 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12510 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12511 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12512 * Used by LOG SENSE page 0x10 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12513 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12514 * return 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12515 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12516 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12517 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12518 sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12519 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12520 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12521 struct smart_ext_selftest_log *ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12522 uint16_t block_num) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12523 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12524 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12525 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12526 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12527 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12528 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12529 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12530 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12531 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12532 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12533 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12534 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12535 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12536 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12537 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12538 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12539 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12540 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12541 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12542 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12543 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12544 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12545 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12546 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12547 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12548 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12549 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12550 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12551 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12552 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12553 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12554 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12555 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12556 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12557 * Allocate buffer for SMART extended self-test log |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12558 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12559 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12560 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12561 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12562 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12563 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12564 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12565 "sata_ext_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12566 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12567 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12568 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12569 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12570 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12571 scmd->satacmd_addr_type = ATA_ADDR_LBA48; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12572 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12573 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12574 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12575 scmd->satacmd_lba_low_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12576 scmd->satacmd_lba_mid_lsb = block_num & 0xff; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12577 scmd->satacmd_lba_mid_msb = block_num >> 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12578 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12579 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12580 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12581 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12582 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12583 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12584 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12585 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12586 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12587 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12588 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12589 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12590 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12591 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12592 * Whoops, no SMART selftest log info available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12593 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12594 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12595 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12596 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12597 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12598 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12599 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12600 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
| 4582 | 12601 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
12602 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12603 bcopy(scmd->satacmd_bp->b_un.b_addr, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12604 (uint8_t *)ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12605 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12606 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12607 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12608 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12609 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12610 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12611 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12612 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12613 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12614 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12615 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12616 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12617 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12618 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12619 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12620 * Returns 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12621 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12622 * SMART self-test log data is returned in buffer pointed to by selftest_log |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12623 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12624 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12625 sata_smart_selftest_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12626 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12627 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12628 struct smart_selftest_log *selftest_log) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12629 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12630 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12631 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12632 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12633 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12634 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12635 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12636 ASSERT(sizeof (struct smart_selftest_log) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12637 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12638 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12639 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12640 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12641 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12642 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12643 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12644 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12645 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12646 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12647 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12648 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12649 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12650 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12651 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12652 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12653 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12654 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12655 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12656 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12657 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12658 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12659 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12660 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12661 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12662 /* |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12663 * Allocate buffer for SMART SELFTEST LOG |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12664 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12665 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12666 sizeof (struct smart_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12667 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12668 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12669 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12670 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12671 "sata_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12672 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12673 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12674 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12675 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12676 /* Build SMART_READ_LOG cmd in the sata_pkt */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12677 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12678 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12679 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12680 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12681 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12682 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12683 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12684 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12685 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12686 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12687 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12688 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12689 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12690 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12691 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12692 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12693 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12694 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12695 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12696 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12697 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12698 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12699 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12700 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12701 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12702 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
| 4582 | 12703 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
12704 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12705 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12706 sizeof (struct smart_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12707 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12708 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12709 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12710 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12711 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12712 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12713 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12714 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12715 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12716 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12717 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12718 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12719 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12720 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12721 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12722 * Returns 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12723 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12724 * SMART READ LOG data is returned in buffer pointed to by smart_log |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12725 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12726 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12727 sata_smart_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12728 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12729 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12730 uint8_t *smart_log, /* where the data should be returned */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12731 uint8_t which_log, /* which log should be returned */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12732 uint8_t log_size) /* # of 512 bytes in log */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12733 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12734 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12735 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12736 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12737 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12738 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12739 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12740 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12741 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12742 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12743 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12744 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12745 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12746 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12747 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12748 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12749 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12750 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12751 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12752 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12753 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12754 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12755 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12756 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12757 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12758 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12759 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12760 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12761 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12762 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12763 * Allocate buffer for SMART READ LOG |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12764 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12765 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12766 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12767 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12768 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12769 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12770 "sata_smart_read_log: " "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12771 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12772 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12773 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12774 /* Build SMART_READ_LOG cmd in the sata_pkt */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12775 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12776 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12777 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12778 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12779 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12780 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12781 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12782 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12783 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12784 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12785 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12786 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12787 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12788 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12789 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12790 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12791 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12792 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12793 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12794 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12795 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12796 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12797 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12798 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12799 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12800 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12801 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12802 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12803 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
| 4582 | 12804 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
12805 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12806 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12807 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12808 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12809 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12810 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12811 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12812 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12813 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12814 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12815 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12816 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12817 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12818 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12819 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12820 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12821 * Used by LOG SENSE page 0x10 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12822 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12823 * return 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12824 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12825 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12826 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12827 sata_read_log_ext_directory( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12828 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12829 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12830 struct read_log_ext_directory *logdir) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12831 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12832 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12833 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12834 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12835 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12836 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12837 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12838 ASSERT(sizeof (struct read_log_ext_directory) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12839 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12840 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12841 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12842 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12843 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12844 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12845 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12846 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12847 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12848 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12849 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12850 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12851 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12852 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12853 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12854 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12855 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12856 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12857 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12858 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12859 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12860 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12861 /* |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12862 * Allocate buffer for SMART READ LOG EXTENDED command |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12863 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12864 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12865 sizeof (struct read_log_ext_directory)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12866 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12867 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12868 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12869 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12870 "sata_read_log_ext_directory: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12871 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12872 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12873 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12874 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
12875 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12876 scmd->satacmd_addr_type = ATA_ADDR_LBA48; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12877 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12878 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12879 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12880 scmd->satacmd_lba_low_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12881 scmd->satacmd_lba_mid_lsb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12882 scmd->satacmd_lba_mid_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12883 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12884 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12885 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12886 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12887 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12888 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12889 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12890 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12891 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12892 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12893 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12894 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12895 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12896 * Whoops, no SMART selftest log info available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12897 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12898 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12899 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12900 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12901 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
12902 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12903 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
| 4582 | 12904 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
12905 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12906 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12907 sizeof (struct read_log_ext_directory)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12908 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12909 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12910 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12911 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12912 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12913 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12914 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12915 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12916 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12917 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12918 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12919 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
12920 |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12921 static void |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12922 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12923 int hint) |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12924 { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12925 char ap[MAXPATHLEN]; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12926 nvlist_t *ev_attr_list = NULL; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12927 int err; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12928 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12929 /* Allocate and build sysevent attribute list */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12930 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12931 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12932 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12933 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12934 "cannot allocate memory for sysevent attributes\n")); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12935 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12936 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12937 /* Add hint attribute */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12938 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12939 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12940 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12941 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12942 "failed to add DR_HINT attr for sysevent")); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12943 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12944 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12945 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12946 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12947 * Add AP attribute. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12948 * Get controller pathname and convert it into AP pathname by adding |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12949 * a target number. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12950 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12951 (void) snprintf(ap, MAXPATHLEN, "/devices"); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12952 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12953 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12954 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12955 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12956 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12957 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12958 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12959 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12960 "failed to add DR_AP_ID attr for sysevent")); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12961 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12962 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12963 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12964 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12965 /* Generate/log sysevent */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12966 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12967 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12968 if (err != DDI_SUCCESS) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12969 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12970 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12971 "cannot log sysevent, err code %x\n", err)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12972 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12973 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12974 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
12975 } |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12976 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12977 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12978 * sata_xlate_errors() is used to translate (S)ATA error |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12979 * information to SCSI information returned in the SCSI |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12980 * packet. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12981 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12982 static void |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12983 sata_xlate_errors(sata_pkt_txlate_t *spx) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12984 { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12985 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12986 struct scsi_extended_sense *sense; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12987 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12988 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12989 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12990 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12991 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12992 switch (spx->txlt_sata_pkt->satapkt_reason) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12993 case SATA_PKT_PORT_ERROR: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12994 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12995 * We have no device data. Assume no data transfered. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12996 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12997 sense->es_key = KEY_HARDWARE_ERROR; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12998 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
12999 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13000 case SATA_PKT_DEV_ERROR: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13001 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13002 SATA_STATUS_ERR) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13003 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13004 * determine dev error reason from error |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13005 * reg content |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13006 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13007 sata_decode_device_error(spx, sense); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13008 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13009 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13010 /* No extended sense key - no info available */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13011 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13012 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13013 case SATA_PKT_TIMEOUT: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13014 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13015 * scsipkt->pkt_reason = CMD_TIMEOUT; This causes problems. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13016 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13017 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13018 /* No extended sense key */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13019 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13020 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13021 case SATA_PKT_ABORTED: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13022 scsipkt->pkt_reason = CMD_ABORTED; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13023 /* No extended sense key */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13024 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13025 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13026 case SATA_PKT_RESET: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13027 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13028 * pkt aborted either by an explicit reset request from |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13029 * a host, or due to error recovery |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13030 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13031 scsipkt->pkt_reason = CMD_RESET; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13032 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13033 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13034 default: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13035 scsipkt->pkt_reason = CMD_TRAN_ERR; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13036 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13037 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
13038 } |
|
3935
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13039 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13040 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13041 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13042 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13043 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13044 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13045 static void |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13046 sata_set_device_removed(dev_info_t *tdip) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13047 { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13048 int circ; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13049 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13050 ASSERT(tdip != NULL); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13051 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13052 ndi_devi_enter(tdip, &circ); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13053 mutex_enter(&DEVI(tdip)->devi_lock); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13054 DEVI_SET_DEVICE_REMOVED(tdip); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13055 mutex_exit(&DEVI(tdip)->devi_lock); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13056 ndi_devi_exit(tdip, circ); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13057 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13058 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13059 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13060 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13061 * Set internal event instructing event daemon to try |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13062 * to perform the target node cleanup. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13063 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13064 static void |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13065 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, int cport) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13066 { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13067 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13068 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, cport) |= |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13069 SATA_EVNT_TARGET_NODE_CLEANUP; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13070 SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean = B_FALSE; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13071 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13072 mutex_enter(&sata_hba_inst->satahba_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13073 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13074 mutex_exit(&sata_hba_inst->satahba_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13075 mutex_enter(&sata_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13076 sata_event_pending |= SATA_EVNT_MAIN; |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13077 mutex_exit(&sata_mutex); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13078 } |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13079 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13080 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13081 /* |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13082 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13083 * i.e. check if the target node state indicates that it belongs to a removed |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13084 * device. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13085 * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13086 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13087 * B_FALSE otherwise. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13088 * |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13089 * NOTE: No port multiplier support. |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13090 */ |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13091 static boolean_t |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13092 sata_check_device_removed(dev_info_t *tdip) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13093 { |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13094 ASSERT(tdip != NULL); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13095 |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13096 if (DEVI_IS_DEVICE_REMOVED(tdip)) |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13097 return (B_TRUE); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13098 else |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13099 return (B_FALSE); |
|
0767d871beb3
6502757 sata: deadlock possible when device reset occurs during cfgadm operations
pawelw
parents:
3821
diff
changeset
|
13100 } |