Mercurial > illumos > illumos-gate
annotate usr/src/uts/common/io/sata/impl/sata.c @ 2553:624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
6460173 sata module is not warlock clean
| author | ls24207 |
|---|---|
| date | Tue, 15 Aug 2006 15:13:46 -0700 |
| parents | 2a06303a9684 |
| children | 79c4a3cba4f1 |
| 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 /* | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
23 * Copyright 2006 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 *); | |
| 113 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *); | |
| 114 static void sata_make_device_nodes(dev_info_t *, sata_hba_inst_t *); | |
| 115 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, | |
| 116 sata_address_t *); | |
| 117 static int sata_validate_scsi_address(sata_hba_inst_t *, | |
| 118 struct scsi_address *, sata_device_t *); | |
| 119 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); | |
| 120 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); | |
| 121 static void sata_pkt_free(sata_pkt_txlate_t *); | |
| 122 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), | |
| 123 caddr_t, ddi_dma_attr_t *); | |
| 124 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); | |
| 125 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, | |
| 126 sata_device_t *); | |
| 127 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); | |
| 128 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); | |
| 129 static void sata_free_local_buffer(sata_pkt_txlate_t *); | |
| 130 static uint64_t sata_check_capacity(sata_drive_info_t *); | |
| 131 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, | |
| 132 ddi_dma_attr_t *); | |
| 133 static int sata_fetch_device_identify_data(sata_hba_inst_t *, | |
| 134 sata_drive_info_t *); | |
| 135 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); | |
| 136 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); | |
| 137 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
|
138 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
|
139 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
|
140 sata_drive_info_t *, int flag); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
141 static int sata_init_write_cache_mode(sata_hba_inst_t *, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
142 sata_drive_info_t *sdinfo); |
|
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 *); | |
| 158 | |
| 159 /* Local functions for ioctl */ | |
| 160 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); | |
| 161 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, | |
| 162 devctl_ap_state_t *); | |
| 163 static dev_info_t *sata_get_target_dip(dev_info_t *, int32_t); | |
| 164 static dev_info_t *sata_devt_to_devinfo(dev_t); | |
| 165 | |
| 166 /* Local translation functions */ | |
| 167 static int sata_txlt_inquiry(sata_pkt_txlate_t *); | |
| 168 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); | |
| 169 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); | |
| 170 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); | |
| 171 static int sata_txlt_request_sense(sata_pkt_txlate_t *); | |
| 172 static int sata_txlt_read(sata_pkt_txlate_t *); | |
| 173 static int sata_txlt_write(sata_pkt_txlate_t *); | |
| 174 static int sata_txlt_atapi(sata_pkt_txlate_t *); | |
| 175 static int sata_txlt_log_sense(sata_pkt_txlate_t *); | |
| 176 static int sata_txlt_log_select(sata_pkt_txlate_t *); | |
| 177 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); | |
| 178 static int sata_txlt_mode_select(sata_pkt_txlate_t *); | |
| 179 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); | |
| 180 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); | |
| 181 | |
| 182 static int sata_hba_start(sata_pkt_txlate_t *, int *); | |
| 183 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); | |
| 184 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); | |
| 185 static void sata_txlt_rw_completion(sata_pkt_t *); | |
| 186 static void sata_txlt_atapi_completion(sata_pkt_t *); | |
| 187 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); | |
| 188 | |
| 189 static struct scsi_extended_sense *sata_immediate_error_response( | |
| 190 sata_pkt_txlate_t *, int); | |
| 191 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); | |
| 192 | |
| 193 /* Local functions */ | |
| 194 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, | |
| 195 uint8_t *); | |
| 196 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); | |
| 197 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); | |
| 198 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); | |
| 199 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); | |
| 200 static int sata_mode_select_page_8(sata_pkt_txlate_t *, | |
| 201 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
|
202 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
|
203 struct mode_info_excpt_page *, int, int *, int *, int *); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
204 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
|
205 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
|
206 sata_hba_inst_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
207 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
|
208 sata_hba_inst_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
209 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
|
210 sata_hba_inst_t *); |
| 1258 | 211 static void sata_save_drive_settings(sata_drive_info_t *); |
| 212 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); | |
| 213 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
214 static int sata_fetch_smart_return_status(sata_hba_inst_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
215 sata_drive_info_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
216 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
217 struct smart_data *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
218 static int sata_smart_selftest_log(sata_hba_inst_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
219 sata_drive_info_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
220 struct smart_selftest_log *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
221 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
222 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
|
223 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
|
224 uint8_t *, uint8_t, uint8_t); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
225 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
|
226 struct read_log_ext_directory *); |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
227 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
|
228 static void sata_xlate_errors(sata_pkt_txlate_t *); |
| 1258 | 229 |
| 230 /* | |
| 231 * SATA Framework will ignore SATA HBA driver cb_ops structure and | |
| 232 * register following one with SCSA framework. | |
| 233 * Open & close are provided, so scsi framework will not use its own | |
| 234 */ | |
| 235 static struct cb_ops sata_cb_ops = { | |
| 236 sata_hba_open, /* open */ | |
| 237 sata_hba_close, /* close */ | |
| 238 nodev, /* strategy */ | |
| 239 nodev, /* print */ | |
| 240 nodev, /* dump */ | |
| 241 nodev, /* read */ | |
| 242 nodev, /* write */ | |
| 243 sata_hba_ioctl, /* ioctl */ | |
| 244 nodev, /* devmap */ | |
| 245 nodev, /* mmap */ | |
| 246 nodev, /* segmap */ | |
| 247 nochpoll, /* chpoll */ | |
| 248 ddi_prop_op, /* cb_prop_op */ | |
| 249 0, /* streamtab */ | |
| 250 D_NEW | D_MP, /* cb_flag */ | |
| 251 CB_REV, /* rev */ | |
| 252 nodev, /* aread */ | |
| 253 nodev /* awrite */ | |
| 254 }; | |
| 255 | |
| 256 | |
| 257 extern struct mod_ops mod_miscops; | |
| 258 extern uchar_t scsi_cdb_size[]; | |
| 259 | |
| 260 static struct modlmisc modlmisc = { | |
| 261 &mod_miscops, /* Type of module */ | |
| 262 "Generic SATA Driver v%I%" /* module name */ | |
| 263 }; | |
| 264 | |
| 265 | |
| 266 static struct modlinkage modlinkage = { | |
| 267 MODREV_1, | |
| 268 (void *)&modlmisc, | |
| 269 NULL | |
| 270 }; | |
| 271 | |
| 272 /* | |
| 273 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, | |
| 274 * i.e. when scsi_pkt has not timeout specified. | |
| 275 */ | |
| 276 static int sata_default_pkt_time = 60; /* 60 seconds */ | |
| 277 | |
| 278 /* | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
279 * Intermediate buffer device access attributes - they are required, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
280 * but not necessarily used. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
281 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
282 static ddi_device_acc_attr_t sata_acc_attr = { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
283 DDI_DEVICE_ATTR_V0, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
284 DDI_STRUCTURE_LE_ACC, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
285 DDI_STRICTORDER_ACC |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
286 }; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
287 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
288 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
289 /* |
| 1258 | 290 * Mutexes protecting structures in multithreaded operations. |
| 291 * Because events are relatively rare, a single global mutex protecting | |
| 292 * data structures should be sufficient. To increase performance, add | |
| 293 * separate mutex per each sata port and use global mutex only to protect | |
| 294 * common data structures. | |
| 295 */ | |
| 296 static kmutex_t sata_mutex; /* protects sata_hba_list */ | |
| 297 static kmutex_t sata_log_mutex; /* protects log */ | |
| 298 | |
| 299 static char sata_log_buf[256]; | |
| 300 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
301 /* Default write cache setting */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
302 int sata_write_cache = 1; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
303 |
| 1258 | 304 /* |
| 305 * Linked list of HBA instances | |
| 306 */ | |
| 307 static sata_hba_inst_t *sata_hba_list = NULL; | |
| 308 static sata_hba_inst_t *sata_hba_list_tail = NULL; | |
| 309 /* | |
| 310 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran | |
| 311 * structure and in sata soft state. | |
| 312 */ | |
| 313 | |
| 314 /* | |
| 315 * Event daemon related variables | |
| 316 */ | |
| 317 static kmutex_t sata_event_mutex; | |
| 318 static kcondvar_t sata_event_cv; | |
| 319 static kthread_t *sata_event_thread = NULL; | |
| 320 static int sata_event_thread_terminate = 0; | |
| 321 static int sata_event_pending = 0; | |
| 322 static int sata_event_thread_active = 0; | |
| 323 extern pri_t minclsyspri; | |
| 324 | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
325 /* |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
326 * NCQ specific data |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
327 */ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
328 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
|
329 SATA_CMD_REV, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
330 NULL, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
331 { |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
332 SATA_DIR_READ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
333 }, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
334 ATA_ADDR_LBA48, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
335 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
336 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
337 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
338 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
339 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
340 1, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
341 READ_LOG_EXT_NCQ_ERROR_RECOVERY, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
342 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
343 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
344 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
345 SATAC_READ_LOG_EXT, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
346 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
347 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
348 0, |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
349 }; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
350 |
| 1258 | 351 /* Warlock directives */ |
| 352 | |
| 353 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) | |
| 354 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) | |
| 355 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) | |
| 356 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) | |
| 357 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) | |
| 358 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) | |
| 359 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) | |
| 360 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) | |
| 361 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) | |
| 362 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) | |
| 363 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) | |
| 364 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) | |
| 365 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ | |
| 366 sata_hba_inst::satahba_scsi_tran)) | |
| 367 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) | |
| 368 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) | |
| 369 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) | |
| 370 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) | |
| 371 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, | |
| 372 sata_hba_inst::satahba_event_flags)) | |
| 373 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 374 sata_cport_info::cport_devp)) | |
| 375 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) | |
| 376 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) | |
| 377 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 378 sata_cport_info::cport_dev_type)) | |
| 379 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) | |
| 380 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 381 sata_cport_info::cport_state)) | |
| 382 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) | |
| 383 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) | |
| 384 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) | |
| 385 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) | |
| 386 _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
|
387 #ifdef SATA_DEBUG |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
388 _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
|
389 _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
|
390 #endif |
| 1258 | 391 |
| 392 /* End of warlock directives */ | |
| 393 | |
| 394 /* ************** loadable module configuration functions ************** */ | |
| 395 | |
| 396 int | |
| 397 _init() | |
| 398 { | |
| 399 int rval; | |
| 400 | |
| 401 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 402 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 403 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 404 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); | |
| 405 if ((rval = mod_install(&modlinkage)) != 0) { | |
| 406 #ifdef SATA_DEBUG | |
| 407 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); | |
| 408 #endif | |
| 409 mutex_destroy(&sata_log_mutex); | |
| 410 cv_destroy(&sata_event_cv); | |
| 411 mutex_destroy(&sata_event_mutex); | |
| 412 mutex_destroy(&sata_mutex); | |
| 413 } | |
| 414 return (rval); | |
| 415 } | |
| 416 | |
| 417 int | |
| 418 _fini() | |
| 419 { | |
| 420 int rval; | |
| 421 | |
| 422 if ((rval = mod_remove(&modlinkage)) != 0) | |
| 423 return (rval); | |
| 424 | |
| 425 mutex_destroy(&sata_log_mutex); | |
| 426 cv_destroy(&sata_event_cv); | |
| 427 mutex_destroy(&sata_event_mutex); | |
| 428 mutex_destroy(&sata_mutex); | |
| 429 return (rval); | |
| 430 } | |
| 431 | |
| 432 int | |
| 433 _info(struct modinfo *modinfop) | |
| 434 { | |
| 435 return (mod_info(&modlinkage, modinfop)); | |
| 436 } | |
| 437 | |
| 438 | |
| 439 | |
| 440 /* ********************* SATA HBA entry points ********************* */ | |
| 441 | |
| 442 | |
| 443 /* | |
| 444 * Called by SATA HBA from _init(). | |
| 445 * Registers HBA driver instance/sata framework pair with scsi framework, by | |
| 446 * calling scsi_hba_init(). | |
| 447 * | |
| 448 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used | |
| 449 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver | |
| 450 * cb_ops pointer in SATA HBA driver dev_ops structure. | |
| 451 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. | |
| 452 * | |
| 453 * Return status of the scsi_hba_init() is returned to a calling SATA HBA | |
| 454 * driver. | |
| 455 */ | |
| 456 int | |
| 457 sata_hba_init(struct modlinkage *modlp) | |
| 458 { | |
| 459 int rval; | |
| 460 struct dev_ops *hba_ops; | |
| 461 | |
| 462 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 463 "sata_hba_init: name %s \n", | |
| 464 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); | |
| 465 /* | |
| 466 * Fill-up cb_ops and dev_ops when necessary | |
| 467 */ | |
| 468 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; | |
| 469 /* | |
| 470 * Provide pointer to SATA dev_ops | |
| 471 */ | |
| 472 hba_ops->devo_cb_ops = &sata_cb_ops; | |
| 473 | |
| 474 /* | |
| 475 * Register SATA HBA with SCSI framework | |
| 476 */ | |
| 477 if ((rval = scsi_hba_init(modlp)) != 0) { | |
| 478 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 479 "sata_hba_init: scsi hba init failed\n", NULL); | |
| 480 return (rval); | |
| 481 } | |
| 482 | |
| 483 return (0); | |
| 484 } | |
| 485 | |
| 486 | |
| 487 /* HBA attach stages */ | |
| 488 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 | |
| 489 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 | |
| 490 #define HBA_ATTACH_STAGE_SETUP 4 | |
| 491 #define HBA_ATTACH_STAGE_LINKED 8 | |
| 492 | |
| 493 | |
| 494 /* | |
| 495 * | |
| 496 * Called from SATA HBA driver's attach routine to attach an instance of | |
| 497 * the HBA. | |
| 498 * | |
| 499 * For DDI_ATTACH command: | |
| 500 * sata_hba_inst structure is allocated here and initialized with pointers to | |
| 501 * SATA framework implementation of required scsi tran functions. | |
| 502 * The scsi_tran's tran_hba_private field is used by SATA Framework to point | |
| 503 * to the soft structure (sata_hba_inst) allocated by SATA framework for | |
| 504 * SATA HBA instance related data. | |
| 505 * The scsi_tran's tran_hba_private field is used by SATA framework to | |
| 506 * store a pointer to per-HBA-instance of sata_hba_inst structure. | |
| 507 * The sata_hba_inst structure is cross-linked to scsi tran structure. | |
| 508 * Among other info, a pointer to sata_hba_tran structure is stored in | |
| 509 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are | |
| 510 * linked together into the list, pointed to by sata_hba_list. | |
| 511 * On the first HBA instance attach the sata event thread is initialized. | |
| 512 * Attachment points are created for all SATA ports of the HBA being attached. | |
| 513 * All HBA instance's SATA ports are probed and type of plugged devices is | |
| 514 * determined. For each device of a supported type, a target node is created. | |
| 515 * | |
| 516 * DDI_SUCCESS is returned when attachment process is successful, | |
| 517 * DDI_FAILURE is returned otherwise. | |
| 518 * | |
| 519 * For DDI_RESUME command: | |
| 520 * Not implemented at this time (postponed until phase 2 of the development). | |
| 521 */ | |
| 522 int | |
| 523 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, | |
| 524 ddi_attach_cmd_t cmd) | |
| 525 { | |
| 526 sata_hba_inst_t *sata_hba_inst; | |
| 527 scsi_hba_tran_t *scsi_tran = NULL; | |
| 528 int hba_attach_state = 0; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
529 char taskq_name[MAXPATHLEN]; |
| 1258 | 530 |
| 531 SATADBG3(SATA_DBG_HBA_IF, NULL, | |
| 532 "sata_hba_attach: node %s (%s%d)\n", | |
| 533 ddi_node_name(dip), ddi_driver_name(dip), | |
| 534 ddi_get_instance(dip)); | |
| 535 | |
| 536 if (cmd == DDI_RESUME) { | |
| 537 /* | |
| 538 * Postponed until phase 2 of the development | |
| 539 */ | |
| 540 return (DDI_FAILURE); | |
| 541 } | |
| 542 | |
| 543 if (cmd != DDI_ATTACH) { | |
| 544 return (DDI_FAILURE); | |
| 545 } | |
| 546 | |
| 547 /* cmd == DDI_ATTACH */ | |
| 548 | |
| 549 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { | |
| 550 SATA_LOG_D((NULL, CE_WARN, | |
| 551 "sata_hba_attach: invalid sata_hba_tran")); | |
| 552 return (DDI_FAILURE); | |
| 553 } | |
| 554 /* | |
| 555 * Allocate and initialize SCSI tran structure. | |
| 556 * SATA copy of tran_bus_config is provided to create port nodes. | |
| 557 */ | |
| 558 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); | |
| 559 if (scsi_tran == NULL) | |
| 560 return (DDI_FAILURE); | |
| 561 /* | |
| 562 * Allocate soft structure for SATA HBA instance. | |
| 563 * There is a separate softstate for each HBA instance. | |
| 564 */ | |
| 565 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); | |
| 566 ASSERT(sata_hba_inst != NULL); /* this should not fail */ | |
| 567 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 568 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; | |
| 569 | |
| 570 /* | |
| 571 * scsi_trans's tran_hba_private is used by SATA Framework to point to | |
| 572 * soft structure allocated by SATA framework for | |
| 573 * SATA HBA instance related data. | |
| 574 */ | |
| 575 scsi_tran->tran_hba_private = sata_hba_inst; | |
| 576 scsi_tran->tran_tgt_private = NULL; | |
| 577 | |
| 578 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; | |
| 579 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; | |
| 580 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; | |
| 581 | |
| 582 scsi_tran->tran_start = sata_scsi_start; | |
| 583 scsi_tran->tran_reset = sata_scsi_reset; | |
| 584 scsi_tran->tran_abort = sata_scsi_abort; | |
| 585 scsi_tran->tran_getcap = sata_scsi_getcap; | |
| 586 scsi_tran->tran_setcap = sata_scsi_setcap; | |
| 587 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; | |
| 588 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; | |
| 589 | |
| 590 scsi_tran->tran_dmafree = sata_scsi_dmafree; | |
| 591 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; | |
| 592 | |
| 593 scsi_tran->tran_reset_notify = NULL; | |
| 594 scsi_tran->tran_get_bus_addr = NULL; | |
| 595 scsi_tran->tran_quiesce = NULL; | |
| 596 scsi_tran->tran_unquiesce = NULL; | |
| 597 scsi_tran->tran_bus_reset = NULL; | |
| 598 | |
| 599 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, | |
| 600 scsi_tran, 0) != DDI_SUCCESS) { | |
| 601 #ifdef SATA_DEBUG | |
| 602 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", | |
| 603 ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 604 #endif | |
| 605 goto fail; | |
| 606 } | |
| 607 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; | |
| 608 | |
| 609 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { | |
| 610 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, | |
| 611 "sata", 1) != DDI_PROP_SUCCESS) { | |
| 612 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " | |
| 613 "failed to create hba sata prop")); | |
| 614 goto fail; | |
| 615 } | |
| 616 } | |
| 617 | |
| 618 /* | |
| 619 * Save pointers in hba instance soft state. | |
| 620 */ | |
| 621 sata_hba_inst->satahba_scsi_tran = scsi_tran; | |
| 622 sata_hba_inst->satahba_tran = sata_tran; | |
| 623 sata_hba_inst->satahba_dip = dip; | |
| 624 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
625 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
626 * 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
|
627 * 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
|
628 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
629 taskq_name[0] = '\0'; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
630 (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
|
631 sizeof (taskq_name)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
632 (void) snprintf(taskq_name + strlen(taskq_name), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
633 sizeof (taskq_name) - strlen(taskq_name), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
634 "-%d", DEVI(dip)->devi_instance); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
635 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
|
636 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
|
637 TASKQ_DYNAMIC); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
638 |
| 1258 | 639 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; |
| 640 | |
| 641 /* | |
| 642 * Create events thread if not created yet. | |
| 643 */ | |
| 644 sata_event_thread_control(1); | |
| 645 | |
| 646 /* | |
| 647 * Link this hba instance into the list. | |
| 648 */ | |
| 649 mutex_enter(&sata_mutex); | |
| 650 | |
| 651 | |
| 652 sata_hba_inst->satahba_next = NULL; | |
| 653 sata_hba_inst->satahba_prev = sata_hba_list_tail; | |
| 654 if (sata_hba_list == NULL) { | |
| 655 sata_hba_list = sata_hba_inst; | |
| 656 } | |
| 657 if (sata_hba_list_tail != NULL) { | |
| 658 sata_hba_list_tail->satahba_next = sata_hba_inst; | |
| 659 } | |
| 660 sata_hba_list_tail = sata_hba_inst; | |
| 661 mutex_exit(&sata_mutex); | |
| 662 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; | |
| 663 | |
| 664 /* | |
| 665 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl | |
| 666 * SATA HBA driver should not use its own open/close entry points. | |
| 667 * | |
| 668 * Make sure that instance number doesn't overflow | |
| 669 * when forming minor numbers. | |
| 670 */ | |
| 671 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); | |
| 672 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, | |
| 673 INST2DEVCTL(ddi_get_instance(dip)), | |
| 674 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { | |
| 675 #ifdef SATA_DEBUG | |
| 676 cmn_err(CE_WARN, "sata_hba_attach: " | |
| 677 "cannot create devctl minor node"); | |
| 678 #endif | |
| 679 goto fail; | |
| 680 } | |
| 681 | |
| 682 | |
| 683 /* | |
| 684 * Set-up kstats here, if necessary. | |
| 685 * (postponed until phase 2 of the development). | |
| 686 */ | |
| 687 | |
| 688 | |
| 689 /* | |
| 690 * Probe controller ports. This operation will describe a current | |
| 691 * controller/port/multipliers/device configuration and will create | |
| 692 * attachment points. | |
| 693 * We may end-up with just a controller with no devices attached. | |
| 694 */ | |
| 695 sata_probe_ports(sata_hba_inst); | |
| 696 | |
| 697 /* | |
| 698 * Create child nodes for all possible target devices currently | |
| 699 * attached to controller's ports and port multiplier device ports. | |
| 700 */ | |
| 701 sata_make_device_nodes(sata_tran->sata_tran_hba_dip, sata_hba_inst); | |
| 702 | |
| 703 sata_hba_inst->satahba_attached = 1; | |
| 704 return (DDI_SUCCESS); | |
| 705 | |
| 706 fail: | |
| 707 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { | |
| 708 (void) sata_remove_hba_instance(dip); | |
| 709 if (sata_hba_list == NULL) | |
| 710 sata_event_thread_control(0); | |
| 711 } | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
712 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
713 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { |
| 1258 | 714 (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
|
715 taskq_destroy(sata_hba_inst->satahba_taskq); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
716 } |
| 1258 | 717 |
| 718 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) | |
| 719 (void) scsi_hba_detach(dip); | |
| 720 | |
| 721 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { | |
| 722 mutex_destroy(&sata_hba_inst->satahba_mutex); | |
| 723 kmem_free((void *)sata_hba_inst, | |
| 724 sizeof (struct sata_hba_inst)); | |
| 725 scsi_hba_tran_free(scsi_tran); | |
| 726 } | |
| 727 | |
| 728 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", | |
| 729 ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 730 | |
| 731 return (DDI_FAILURE); | |
| 732 } | |
| 733 | |
| 734 | |
| 735 /* | |
| 736 * Called by SATA HBA from to detach an instance of the driver. | |
| 737 * | |
| 738 * For DDI_DETACH command: | |
| 739 * Free local structures allocated for SATA HBA instance during | |
| 740 * sata_hba_attach processing. | |
| 741 * | |
| 742 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. | |
| 743 * | |
| 744 * For DDI_SUSPEND command: | |
| 745 * Not implemented at this time (postponed until phase 2 of the development) | |
| 746 * Returnd DDI_SUCCESS. | |
| 747 * | |
| 748 * When the last HBA instance is detached, the event daemon is terminated. | |
| 749 * | |
| 750 * NOTE: cport support only, no port multiplier support. | |
| 751 */ | |
| 752 int | |
| 753 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) | |
| 754 { | |
| 755 dev_info_t *tdip; | |
| 756 sata_hba_inst_t *sata_hba_inst; | |
| 757 scsi_hba_tran_t *scsi_hba_tran; | |
| 758 sata_cport_info_t *cportinfo; | |
| 759 sata_drive_info_t *sdinfo; | |
| 760 int ncport; | |
| 761 | |
| 762 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", | |
| 763 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 764 | |
| 765 switch (cmd) { | |
| 766 case DDI_DETACH: | |
| 767 | |
| 768 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 769 return (DDI_FAILURE); | |
| 770 | |
| 771 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 772 if (sata_hba_inst == NULL) | |
| 773 return (DDI_FAILURE); | |
| 774 | |
| 775 if (scsi_hba_detach(dip) == DDI_FAILURE) { | |
| 776 sata_hba_inst->satahba_attached = 1; | |
| 777 return (DDI_FAILURE); | |
| 778 } | |
| 779 | |
| 780 /* | |
| 781 * Free all target nodes - at this point | |
| 782 * devices should be at least offlined | |
| 783 * otherwise scsi_hba_detach() should not be called. | |
| 784 */ | |
| 785 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 786 ncport++) { | |
| 787 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 788 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 789 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 790 if (sdinfo != NULL) { | |
| 791 tdip = sata_get_target_dip(dip, | |
| 792 ncport); | |
| 793 if (tdip != NULL) { | |
| 794 if (ndi_devi_offline(tdip, | |
| 795 NDI_DEVI_REMOVE) != | |
| 796 NDI_SUCCESS) { | |
| 797 SATA_LOG_D(( | |
| 798 sata_hba_inst, | |
| 799 CE_WARN, | |
| 800 "sata_hba_detach: " | |
| 801 "Target node not " | |
| 802 "removed !")); | |
| 803 return (DDI_FAILURE); | |
| 804 } | |
| 805 } | |
| 806 } | |
| 807 } | |
| 808 } | |
| 809 /* | |
| 810 * Disable sata event daemon processing for this HBA | |
| 811 */ | |
| 812 sata_hba_inst->satahba_attached = 0; | |
| 813 | |
| 814 /* | |
| 815 * Remove event daemon thread, if it is last HBA instance. | |
| 816 */ | |
| 817 | |
| 818 mutex_enter(&sata_mutex); | |
| 819 if (sata_hba_list->satahba_next == NULL) { | |
| 820 mutex_exit(&sata_mutex); | |
| 821 sata_event_thread_control(0); | |
| 822 mutex_enter(&sata_mutex); | |
| 823 } | |
| 824 mutex_exit(&sata_mutex); | |
| 825 | |
| 826 /* Remove this HBA instance from the HBA list */ | |
| 827 sata_remove_hba_instance(dip); | |
| 828 | |
| 829 /* | |
| 830 * At this point there should be no target nodes attached. | |
| 831 * Detach and destroy device and port info structures. | |
| 832 */ | |
| 833 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 834 ncport++) { | |
| 835 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 836 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 837 sdinfo = | |
| 838 cportinfo->cport_devp.cport_sata_drive; | |
| 839 if (sdinfo != NULL) { | |
| 840 /* Release device structure */ | |
| 841 kmem_free(sdinfo, | |
| 842 sizeof (sata_drive_info_t)); | |
| 843 } | |
| 844 /* Release cport info */ | |
| 845 mutex_destroy(&cportinfo->cport_mutex); | |
| 846 kmem_free(cportinfo, | |
| 847 sizeof (sata_cport_info_t)); | |
| 848 } | |
| 849 } | |
| 850 | |
| 851 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); | |
| 852 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
853 (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
|
854 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
855 taskq_destroy(sata_hba_inst->satahba_taskq); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
856 |
| 1258 | 857 mutex_destroy(&sata_hba_inst->satahba_mutex); |
| 858 kmem_free((void *)sata_hba_inst, | |
| 859 sizeof (struct sata_hba_inst)); | |
| 860 | |
| 861 return (DDI_SUCCESS); | |
| 862 | |
| 863 case DDI_SUSPEND: | |
| 864 /* | |
| 865 * Postponed until phase 2 | |
| 866 */ | |
| 867 return (DDI_FAILURE); | |
| 868 | |
| 869 default: | |
| 870 return (DDI_FAILURE); | |
| 871 } | |
| 872 } | |
| 873 | |
| 874 | |
| 875 /* | |
| 876 * Called by an HBA drive from _fini() routine. | |
| 877 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. | |
| 878 */ | |
| 879 void | |
| 880 sata_hba_fini(struct modlinkage *modlp) | |
| 881 { | |
| 882 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 883 "sata_hba_fini: name %s\n", | |
| 884 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); | |
| 885 | |
| 886 scsi_hba_fini(modlp); | |
| 887 } | |
| 888 | |
| 889 | |
| 890 /* | |
| 891 * Default open and close routine for sata_hba framework. | |
| 892 * | |
| 893 */ | |
| 894 /* | |
| 895 * Open devctl node. | |
| 896 * | |
| 897 * Returns: | |
| 898 * 0 if node was open successfully, error code otherwise. | |
| 899 * | |
| 900 * | |
| 901 */ | |
| 902 | |
| 903 static int | |
| 904 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) | |
| 905 { | |
| 906 #ifndef __lock_lint | |
| 907 _NOTE(ARGUNUSED(credp)) | |
| 908 #endif | |
| 909 int rv = 0; | |
| 910 dev_info_t *dip; | |
| 911 scsi_hba_tran_t *scsi_hba_tran; | |
| 912 sata_hba_inst_t *sata_hba_inst; | |
| 913 | |
| 914 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); | |
| 915 | |
| 916 if (otyp != OTYP_CHR) | |
| 917 return (EINVAL); | |
| 918 | |
| 919 dip = sata_devt_to_devinfo(*devp); | |
| 920 if (dip == NULL) | |
| 921 return (ENXIO); | |
| 922 | |
| 923 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 924 return (ENXIO); | |
| 925 | |
| 926 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 927 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) | |
| 928 return (ENXIO); | |
| 929 | |
| 930 mutex_enter(&sata_mutex); | |
| 931 if (flags & FEXCL) { | |
| 932 if (sata_hba_inst->satahba_open_flag != 0) { | |
| 933 rv = EBUSY; | |
| 934 } else { | |
| 935 sata_hba_inst->satahba_open_flag = | |
| 936 SATA_DEVCTL_EXOPENED; | |
| 937 } | |
| 938 } else { | |
| 939 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { | |
| 940 rv = EBUSY; | |
| 941 } else { | |
| 942 sata_hba_inst->satahba_open_flag = | |
| 943 SATA_DEVCTL_SOPENED; | |
| 944 } | |
| 945 } | |
| 946 mutex_exit(&sata_mutex); | |
| 947 | |
| 948 return (rv); | |
| 949 } | |
| 950 | |
| 951 | |
| 952 /* | |
| 953 * Close devctl node. | |
| 954 * Returns: | |
| 955 * 0 if node was closed successfully, error code otherwise. | |
| 956 * | |
| 957 */ | |
| 958 | |
| 959 static int | |
| 960 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) | |
| 961 { | |
| 962 #ifndef __lock_lint | |
| 963 _NOTE(ARGUNUSED(credp)) | |
| 964 _NOTE(ARGUNUSED(flag)) | |
| 965 #endif | |
| 966 dev_info_t *dip; | |
| 967 scsi_hba_tran_t *scsi_hba_tran; | |
| 968 sata_hba_inst_t *sata_hba_inst; | |
| 969 | |
| 970 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); | |
| 971 | |
| 972 if (otyp != OTYP_CHR) | |
| 973 return (EINVAL); | |
| 974 | |
| 975 dip = sata_devt_to_devinfo(dev); | |
| 976 if (dip == NULL) | |
| 977 return (ENXIO); | |
| 978 | |
| 979 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 980 return (ENXIO); | |
| 981 | |
| 982 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 983 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) | |
| 984 return (ENXIO); | |
| 985 | |
| 986 mutex_enter(&sata_mutex); | |
| 987 sata_hba_inst->satahba_open_flag = 0; | |
| 988 mutex_exit(&sata_mutex); | |
| 989 return (0); | |
| 990 } | |
| 991 | |
| 992 | |
| 993 | |
| 994 /* | |
| 995 * Standard IOCTL commands for SATA hotplugging. | |
| 996 * Implemented DEVCTL_AP commands: | |
| 997 * DEVCTL_AP_CONNECT | |
| 998 * DEVCTL_AP_DISCONNECT | |
| 999 * DEVCTL_AP_CONFIGURE | |
| 1000 * DEVCTL_UNCONFIGURE | |
| 1001 * DEVCTL_AP_CONTROL | |
| 1002 * | |
| 1003 * Commands passed to default ndi ioctl handler: | |
| 1004 * DEVCTL_DEVICE_GETSTATE | |
| 1005 * DEVCTL_DEVICE_ONLINE | |
| 1006 * DEVCTL_DEVICE_OFFLINE | |
| 1007 * DEVCTL_DEVICE_REMOVE | |
| 1008 * DEVCTL_DEVICE_INSERT | |
| 1009 * DEVCTL_BUS_GETSTATE | |
| 1010 * | |
| 1011 * All other cmds are passed to HBA if it provide ioctl handler, or failed | |
| 1012 * if not. | |
| 1013 * | |
| 1014 * Returns: | |
| 1015 * 0 if successful, | |
| 1016 * error code if operation failed. | |
| 1017 * | |
| 1018 * NOTE: Port Multiplier is not supported. | |
| 1019 * | |
| 1020 */ | |
| 1021 | |
| 1022 static int | |
| 1023 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, | |
| 1024 int *rvalp) | |
| 1025 { | |
| 1026 #ifndef __lock_lint | |
| 1027 _NOTE(ARGUNUSED(credp)) | |
| 1028 _NOTE(ARGUNUSED(rvalp)) | |
| 1029 #endif | |
| 1030 int rv = 0; | |
| 1031 int32_t comp_port = -1; | |
| 1032 dev_info_t *dip, *tdip; | |
| 1033 devctl_ap_state_t ap_state; | |
| 1034 struct devctl_iocdata *dcp = NULL; | |
| 1035 scsi_hba_tran_t *scsi_hba_tran; | |
| 1036 sata_hba_inst_t *sata_hba_inst; | |
| 1037 sata_device_t sata_device; | |
| 1038 sata_drive_info_t *sdinfo; | |
| 1039 sata_cport_info_t *cportinfo; | |
| 1040 int cport, pmport, qual; | |
| 1041 int rval = SATA_SUCCESS; | |
| 1042 | |
| 1043 dip = sata_devt_to_devinfo(dev); | |
| 1044 if (dip == NULL) | |
| 1045 return (ENXIO); | |
| 1046 | |
| 1047 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 1048 return (ENXIO); | |
| 1049 | |
| 1050 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 1051 if (sata_hba_inst == NULL) | |
| 1052 return (ENXIO); | |
| 1053 | |
| 1054 if (sata_hba_inst->satahba_tran == NULL) | |
| 1055 return (ENXIO); | |
| 1056 | |
| 1057 switch (cmd) { | |
| 1058 | |
| 1059 case DEVCTL_DEVICE_GETSTATE: | |
| 1060 case DEVCTL_DEVICE_ONLINE: | |
| 1061 case DEVCTL_DEVICE_OFFLINE: | |
| 1062 case DEVCTL_DEVICE_REMOVE: | |
| 1063 case DEVCTL_BUS_GETSTATE: | |
| 1064 /* | |
| 1065 * There may be more cases that we want to pass to default | |
| 1066 * handler rather then fail them. | |
| 1067 */ | |
| 1068 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); | |
| 1069 } | |
| 1070 | |
| 1071 /* read devctl ioctl data */ | |
| 1072 if (cmd != DEVCTL_AP_CONTROL) { | |
| 1073 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) | |
| 1074 return (EFAULT); | |
| 1075 | |
| 1076 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == | |
| 1077 -1) { | |
| 1078 if (dcp) | |
| 1079 ndi_dc_freehdl(dcp); | |
| 1080 return (EINVAL); | |
| 1081 } | |
| 1082 | |
| 1083 cport = SCSI_TO_SATA_CPORT(comp_port); | |
| 1084 pmport = SCSI_TO_SATA_PMPORT(comp_port); | |
| 1085 /* Only cport is considered now, i.e. SATA_ADDR_CPORT */ | |
| 1086 qual = SATA_ADDR_CPORT; | |
| 1087 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, | |
| 1088 qual) != 0) { | |
| 1089 ndi_dc_freehdl(dcp); | |
| 1090 return (EINVAL); | |
| 1091 } | |
| 1092 | |
| 1093 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 1094 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1095 cport_mutex); | |
| 1096 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { | |
| 1097 /* | |
| 1098 * Cannot process ioctl request now. Come back later. | |
| 1099 */ | |
| 1100 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1101 cport_mutex); | |
| 1102 ndi_dc_freehdl(dcp); | |
| 1103 return (EBUSY); | |
| 1104 } | |
| 1105 /* Block event processing for this port */ | |
| 1106 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; | |
| 1107 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1108 | |
| 1109 sata_device.satadev_addr.cport = cport; | |
| 1110 sata_device.satadev_addr.pmport = pmport; | |
| 1111 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1112 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 1113 } | |
| 1114 | |
| 1115 switch (cmd) { | |
| 1116 | |
| 1117 case DEVCTL_AP_DISCONNECT: | |
| 1118 /* | |
| 1119 * Normally, cfgadm sata plugin will try to offline | |
| 1120 * (unconfigure) device before this request. Nevertheless, | |
| 1121 * if a device is still configured, we need to | |
| 1122 * attempt to offline and unconfigure device first, and we will | |
| 1123 * deactivate the port regardless of the unconfigure | |
| 1124 * operation results. | |
| 1125 * | |
| 1126 * DEVCTL_AP_DISCONNECT invokes | |
| 1127 * sata_hba_inst->satahba_tran-> | |
| 1128 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). | |
| 1129 * If successful, the device structure (if any) attached | |
| 1130 * to a port is removed and state of the port marked | |
| 1131 * appropriately. | |
| 1132 * Failure of the port_deactivate may keep port in | |
| 1133 * the active state, or may fail the port. | |
| 1134 */ | |
| 1135 | |
| 1136 /* Check the current state of the port */ | |
| 1137 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 1138 SATA_SUCCESS) { | |
| 1139 rv = EIO; | |
| 1140 break; | |
| 1141 } | |
| 1142 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1143 cport_mutex); | |
| 1144 if (cportinfo->cport_state & | |
| 1145 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) { | |
| 1146 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1147 cport_mutex); | |
| 1148 rv = EIO; | |
| 1149 break; | |
| 1150 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1151 /* Sanity check */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1152 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
|
1153 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
1154 cport_mutex); |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1155 /* No physical port deactivation supported. */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1156 break; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1157 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1158 |
| 1258 | 1159 /* |
| 1160 * set port's dev_state to not ready - this will disable | |
| 1161 * an access to an attached device. | |
| 1162 */ | |
| 1163 cportinfo->cport_state &= ~SATA_STATE_READY; | |
| 1164 | |
| 1165 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1166 sdinfo = cportinfo->cport_devp.cport_sata_drive; | |
| 1167 ASSERT(sdinfo != NULL); | |
| 1168 if ((sdinfo->satadrv_type & | |
| 1169 (SATA_VALID_DEV_TYPE))) { | |
| 1170 /* | |
| 1171 * If a target node exists, try to offline | |
| 1172 * a device and remove target node. | |
| 1173 */ | |
| 1174 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1175 cport)->cport_mutex); | |
| 1176 tdip = sata_get_target_dip(dip, comp_port); | |
| 1177 if (tdip != NULL) { | |
| 1178 /* target node exist */ | |
| 1179 if (ndi_devi_offline(tdip, | |
| 1180 NDI_DEVI_REMOVE) != NDI_SUCCESS) { | |
| 1181 /* | |
| 1182 * Problem | |
| 1183 * A target node remained | |
| 1184 * attached. This happens when | |
| 1185 * the file was open or a node | |
| 1186 * was waiting for resources. | |
| 1187 * Cannot do anything about it. | |
| 1188 */ | |
| 1189 SATA_LOG_D((sata_hba_inst, | |
| 1190 CE_WARN, | |
| 1191 "sata_hba_ioctl: " | |
| 1192 "disconnect: cannot " | |
| 1193 "remove target node!!!")); | |
| 1194 } | |
| 1195 } | |
| 1196 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1197 cport)->cport_mutex); | |
| 1198 /* | |
| 1199 * Remove and release sata_drive_info | |
| 1200 * structure. | |
| 1201 */ | |
| 1202 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != | |
| 1203 NULL) { | |
| 1204 SATA_CPORTINFO_DRV_INFO(cportinfo) = | |
| 1205 NULL; | |
| 1206 (void) kmem_free((void *)sdinfo, | |
| 1207 sizeof (sata_drive_info_t)); | |
| 1208 cportinfo->cport_dev_type = | |
| 1209 SATA_DTYPE_NONE; | |
| 1210 } | |
| 1211 } | |
| 1212 /* | |
| 1213 * 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
|
1214 * Put PMult handling code here, when PMult is |
| 1258 | 1215 * supported. |
| 1216 */ | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1217 |
| 1258 | 1218 } |
| 1219 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1220 /* Just ask HBA driver to deactivate port */ | |
| 1221 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1222 | |
| 1223 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) | |
| 1224 (dip, &sata_device); | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1225 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1226 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1227 * 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
|
1228 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1229 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1230 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1231 &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
|
1232 |
| 1258 | 1233 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1234 cport_mutex); | |
| 1235 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1236 | |
| 1237 if (rval != SATA_SUCCESS) { | |
| 1238 /* | |
| 1239 * Port deactivation failure - do not | |
| 1240 * change port state unless the state | |
| 1241 * returned by HBA indicates a port failure. | |
| 1242 */ | |
| 1243 if (sata_device.satadev_state & SATA_PSTATE_FAILED) | |
| 1244 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 1245 rv = EIO; | |
| 1246 } else { | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1247 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1248 * 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
|
1249 * 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
|
1250 * the port is activated again. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1251 */ |
| 1258 | 1252 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; |
| 1253 } | |
| 1254 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1255 break; | |
| 1256 | |
| 1257 case DEVCTL_AP_UNCONFIGURE: | |
| 1258 | |
| 1259 /* | |
| 1260 * The unconfigure operation uses generic nexus operation to | |
| 1261 * offline a device. It leaves a target device node attached. | |
| 1262 * and obviously sata_drive_info attached as well, because | |
| 1263 * from the hardware point of view nothing has changed. | |
| 1264 */ | |
| 1265 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { | |
| 1266 | |
| 1267 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != | |
| 1268 NDI_SUCCESS) { | |
| 1269 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1270 "sata_hba_ioctl: unconfigure: " | |
| 1271 "failed to unconfigure " | |
| 1272 "device at cport %d", cport)); | |
| 1273 rv = EIO; | |
| 1274 } | |
| 1275 /* | |
| 1276 * The target node devi_state should be marked with | |
| 1277 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). | |
| 1278 * This would be the indication for cfgadm that | |
| 1279 * the AP node occupant state is 'unconfigured'. | |
| 1280 */ | |
| 1281 | |
| 1282 } else { | |
| 1283 /* | |
| 1284 * This would indicate a failure on the part of cfgadm | |
| 1285 * to detect correct state of the node prior to this | |
| 1286 * call - one cannot unconfigure non-existing device. | |
| 1287 */ | |
| 1288 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1289 "sata_hba_ioctl: unconfigure: " | |
| 1290 "attempt to unconfigure non-existing device " | |
| 1291 "at cport %d", cport)); | |
| 1292 rv = ENXIO; | |
| 1293 } | |
| 1294 | |
| 1295 break; | |
| 1296 | |
| 1297 case DEVCTL_AP_CONNECT: | |
| 1298 { | |
| 1299 /* | |
| 1300 * The sata cfgadm pluging will invoke this operation only if | |
| 1301 * port was found in the disconnect state (failed state | |
| 1302 * is also treated as the disconnected state). | |
| 1303 * DEVCTL_AP_CONNECT would invoke | |
| 1304 * sata_hba_inst->satahba_tran-> | |
| 1305 * sata_tran_hotplug_ops->sata_tran_port_activate(). | |
| 1306 * If successful and a device is found attached to the port, | |
| 1307 * the initialization sequence is executed to attach | |
| 1308 * a device structure to a port structure. The device is not | |
| 1309 * set in configured state (system-wise) by this operation. | |
| 1310 * The state of the port and a device would be set | |
| 1311 * appropriately. | |
| 1312 * | |
| 1313 * Note, that activating the port may generate link events, | |
| 1314 * so is is important that following processing and the | |
| 1315 * event processing does not interfere with each other! | |
| 1316 * | |
| 1317 * This operation may remove port failed state and will | |
| 1318 * try to make port active and in good standing. | |
| 1319 */ | |
| 1320 | |
| 1321 /* We only care about host sata cport for now */ | |
| 1322 | |
| 1323 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { | |
| 1324 /* Just let HBA driver to activate port */ | |
| 1325 | |
| 1326 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 1327 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1328 /* | |
| 1329 * Port activation failure. | |
| 1330 */ | |
| 1331 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1332 cport)->cport_mutex); | |
| 1333 sata_update_port_info(sata_hba_inst, | |
| 1334 &sata_device); | |
| 1335 if (sata_device.satadev_state & | |
| 1336 SATA_PSTATE_FAILED) { | |
| 1337 cportinfo->cport_state = | |
| 1338 SATA_PSTATE_FAILED; | |
| 1339 } | |
| 1340 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1341 cport)->cport_mutex); | |
| 1342 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1343 "sata_hba_ioctl: connect: " | |
| 1344 "failed to activate SATA cport %d", | |
| 1345 cport)); | |
| 1346 rv = EIO; | |
| 1347 break; | |
| 1348 } | |
| 1349 } | |
| 1350 /* Virgin port state - will be updated by the port re-probe. */ | |
| 1351 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1352 cport)->cport_mutex); | |
| 1353 cportinfo->cport_state = 0; | |
| 1354 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1355 cport)->cport_mutex); | |
| 1356 | |
| 1357 if (sata_reprobe_port(sata_hba_inst, &sata_device) == | |
| 1358 SATA_FAILURE) | |
| 1359 rv = EIO; | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1360 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1361 * 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
|
1362 * without the hint |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1363 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1364 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1365 &sata_device.satadev_addr, SE_NO_HINT); |
| 1258 | 1366 /* |
| 1367 * If there is a device attached to the port, emit | |
| 1368 * a message. | |
| 1369 */ | |
| 1370 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1371 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
|
1372 "SATA device detected at port %d", cport); |
| 1258 | 1373 } |
| 1374 break; | |
| 1375 } | |
| 1376 | |
| 1377 case DEVCTL_AP_CONFIGURE: | |
| 1378 { | |
| 1379 boolean_t target = TRUE; | |
| 1380 | |
| 1381 /* | |
| 1382 * A port may be in an active or shutdown state. | |
| 1383 * If port is in a failed state, operation is aborted - one | |
| 1384 * has to use explicit connect or port activate request | |
| 1385 * to try to get a port into non-failed mode. | |
| 1386 * | |
| 1387 * If a port is in a shutdown state, arbitrarily invoke | |
| 1388 * sata_tran_port_activate() prior to any other operation. | |
| 1389 * | |
| 1390 * Verify that port state is READY and there is a device | |
| 1391 * of a supported type attached to this port. | |
| 1392 * If target node exists, a device was most likely offlined. | |
| 1393 * If target node does not exist, create a target node an | |
| 1394 * attempt to online it. | |
| 1395 * * | |
| 1396 * NO PMult or devices beyond PMult are supported yet. | |
| 1397 */ | |
| 1398 | |
| 1399 /* We only care about host controller's sata cport for now. */ | |
| 1400 if (cportinfo->cport_state & SATA_PSTATE_FAILED) { | |
| 1401 rv = ENXIO; | |
| 1402 break; | |
| 1403 } | |
| 1404 /* Check the current state of the port */ | |
| 1405 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1406 | |
| 1407 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 1408 (dip, &sata_device); | |
| 1409 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1410 cport_mutex); | |
| 1411 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1412 if (rval != SATA_SUCCESS || | |
| 1413 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { | |
| 1414 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 1415 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1416 cport_mutex); | |
| 1417 rv = EIO; | |
| 1418 break; | |
| 1419 } | |
| 1420 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
|
1421 target = FALSE; |
| 1258 | 1422 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1423 cport_mutex); | |
| 1424 | |
| 1425 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { | |
| 1426 /* Just let HBA driver to activate port */ | |
| 1427 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 1428 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1429 /* | |
| 1430 * Port activation failure - do not | |
| 1431 * change port state unless the state | |
| 1432 * returned by HBA indicates a port | |
| 1433 * failure. | |
| 1434 */ | |
| 1435 mutex_enter(&SATA_CPORT_INFO( | |
| 1436 sata_hba_inst, cport)->cport_mutex); | |
| 1437 sata_update_port_info(sata_hba_inst, | |
| 1438 &sata_device); | |
| 1439 if (sata_device.satadev_state & | |
| 1440 SATA_PSTATE_FAILED) { | |
| 1441 cportinfo->cport_state = | |
| 1442 SATA_PSTATE_FAILED; | |
| 1443 } | |
| 1444 mutex_exit(&SATA_CPORT_INFO( | |
| 1445 sata_hba_inst, cport)->cport_mutex); | |
| 1446 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1447 "sata_hba_ioctl: configure: " | |
| 1448 "failed to activate SATA cport %d", | |
| 1449 cport)); | |
| 1450 rv = EIO; | |
| 1451 break; | |
| 1452 } | |
| 1453 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1454 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1455 * 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
|
1456 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1457 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1458 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1459 &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
|
1460 |
| 1258 | 1461 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1462 cport_mutex); | |
| 1463 /* Virgin port state */ | |
| 1464 cportinfo->cport_state = 0; | |
| 1465 } | |
| 1466 /* | |
| 1467 * Always reprobe port, to get current device info. | |
| 1468 */ | |
| 1469 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1470 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 1471 SATA_SUCCESS) { | |
| 1472 rv = EIO; | |
| 1473 break; | |
| 1474 } | |
| 1475 if (target == FALSE && | |
| 1476 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1477 /* | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1478 * 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
|
1479 * to active one with device attached. |
| 1258 | 1480 */ |
| 1481 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
|
1482 "SATA device detected at port %d", |
| 1258 | 1483 cport); |
| 1484 } | |
| 1485 | |
| 1486 /* | |
| 1487 * This is where real configure starts. | |
| 1488 * Change following check for PMult support. | |
| 1489 */ | |
| 1490 if (!(sata_device.satadev_type & SATA_VALID_DEV_TYPE)) { | |
| 1491 /* No device to configure */ | |
| 1492 rv = ENXIO; /* No device to configure */ | |
| 1493 break; | |
| 1494 } | |
| 1495 | |
| 1496 /* | |
| 1497 * Here we may have a device in reset condition, | |
| 1498 * but because we are just configuring it, there is | |
| 1499 * no need to process the reset other than just | |
| 1500 * to clear device reset condition in the HBA driver. | |
| 1501 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will | |
| 1502 * cause a first command sent the HBA driver with the request | |
| 1503 * to clear device reset condition. | |
| 1504 */ | |
| 1505 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1506 cport_mutex); | |
| 1507 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 1508 if (sdinfo == NULL) { | |
| 1509 rv = ENXIO; | |
| 1510 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1511 cport_mutex); | |
| 1512 break; | |
| 1513 } | |
| 1514 if (sdinfo->satadrv_event_flags & | |
| 1515 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) | |
| 1516 sdinfo->satadrv_event_flags = 0; | |
| 1517 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 1518 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1519 | |
| 1520 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { | |
| 1521 /* target node still exists */ | |
| 1522 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { | |
| 1523 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1524 "sata_hba_ioctl: configure: " | |
| 1525 "onlining device at cport %d failed", | |
| 1526 cport)); | |
| 1527 rv = EIO; | |
| 1528 break; | |
| 1529 } | |
| 1530 } else { | |
| 1531 /* | |
| 1532 * No target node - need to create a new target node. | |
| 1533 */ | |
| 1534 tdip = sata_create_target_node(dip, sata_hba_inst, | |
| 1535 &sata_device.satadev_addr); | |
| 1536 if (tdip == NULL) { | |
| 1537 /* configure failed */ | |
| 1538 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1539 "sata_hba_ioctl: configure: " | |
| 1540 "configuring device at cport %d " | |
| 1541 "failed", cport)); | |
| 1542 rv = EIO; | |
| 1543 break; | |
| 1544 } | |
| 1545 } | |
| 1546 | |
| 1547 break; | |
| 1548 } | |
| 1549 | |
| 1550 case DEVCTL_AP_GETSTATE: | |
| 1551 | |
| 1552 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); | |
| 1553 | |
| 1554 ap_state.ap_last_change = (time_t)-1; | |
| 1555 ap_state.ap_error_code = 0; | |
| 1556 ap_state.ap_in_transition = 0; | |
| 1557 | |
| 1558 /* Copy the return AP-state information to the user space */ | |
| 1559 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { | |
| 1560 rv = EFAULT; | |
| 1561 } | |
| 1562 break; | |
| 1563 | |
| 1564 case DEVCTL_AP_CONTROL: | |
| 1565 { | |
| 1566 /* | |
| 1567 * Generic devctl for hardware specific functionality | |
| 1568 */ | |
| 1569 sata_ioctl_data_t ioc; | |
| 1570 | |
| 1571 ASSERT(dcp == NULL); | |
| 1572 | |
| 1573 /* Copy in user ioctl data first */ | |
| 1574 #ifdef _MULTI_DATAMODEL | |
| 1575 if (ddi_model_convert_from(mode & FMODELS) == | |
| 1576 DDI_MODEL_ILP32) { | |
| 1577 | |
| 1578 sata_ioctl_data_32_t ioc32; | |
| 1579 | |
| 1580 if (ddi_copyin((void *)arg, (void *)&ioc32, | |
| 1581 sizeof (ioc32), mode) != 0) { | |
| 1582 rv = EFAULT; | |
| 1583 break; | |
| 1584 } | |
| 1585 ioc.cmd = (uint_t)ioc32.cmd; | |
| 1586 ioc.port = (uint_t)ioc32.port; | |
| 1587 ioc.get_size = (uint_t)ioc32.get_size; | |
| 1588 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; | |
| 1589 ioc.bufsiz = (uint_t)ioc32.bufsiz; | |
| 1590 ioc.misc_arg = (uint_t)ioc32.misc_arg; | |
| 1591 } else | |
| 1592 #endif /* _MULTI_DATAMODEL */ | |
| 1593 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), | |
| 1594 mode) != 0) { | |
| 1595 return (EFAULT); | |
| 1596 } | |
| 1597 | |
| 1598 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 1599 "sata_hba_ioctl: DEVCTL_AP_CONTROL " | |
| 1600 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); | |
| 1601 | |
| 1602 /* | |
| 1603 * To avoid BE/LE and 32/64 issues, a get_size always returns | |
| 1604 * a 32-bit number. | |
| 1605 */ | |
| 1606 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { | |
| 1607 return (EINVAL); | |
| 1608 } | |
| 1609 /* validate address */ | |
| 1610 cport = SCSI_TO_SATA_CPORT(ioc.port); | |
| 1611 pmport = SCSI_TO_SATA_PMPORT(ioc.port); | |
| 1612 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); | |
| 1613 | |
| 1614 /* Override address qualifier - handle cport only for now */ | |
| 1615 qual = SATA_ADDR_CPORT; | |
| 1616 | |
| 1617 if (sata_validate_sata_address(sata_hba_inst, cport, | |
| 1618 pmport, qual) != 0) | |
| 1619 return (EINVAL); | |
| 1620 | |
| 1621 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 1622 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1623 cport_mutex); | |
| 1624 /* Is the port locked by event processing daemon ? */ | |
| 1625 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { | |
| 1626 /* | |
| 1627 * Cannot process ioctl request now. Come back later | |
| 1628 */ | |
| 1629 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1630 cport_mutex); | |
| 1631 return (EBUSY); | |
| 1632 } | |
| 1633 /* Block event processing for this port */ | |
| 1634 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; | |
| 1635 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1636 | |
| 1637 | |
| 1638 sata_device.satadev_addr.cport = cport; | |
| 1639 sata_device.satadev_addr.pmport = pmport; | |
| 1640 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 1641 | |
| 1642 switch (ioc.cmd) { | |
| 1643 | |
| 1644 case SATA_CFGA_RESET_PORT: | |
| 1645 /* | |
| 1646 * There is no protection here for configured | |
| 1647 * device. | |
| 1648 */ | |
| 1649 | |
| 1650 /* Sanity check */ | |
| 1651 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1652 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1653 "sata_hba_ioctl: " | |
| 1654 "sata_hba_tran missing required " | |
| 1655 "function sata_tran_reset_dport")); | |
| 1656 rv = EINVAL; | |
| 1657 break; | |
| 1658 } | |
| 1659 | |
| 1660 /* handle cport only for now */ | |
| 1661 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1662 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1663 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1664 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1665 "sata_hba_ioctl: reset port: " | |
| 1666 "failed cport %d pmport %d", | |
| 1667 cport, pmport)); | |
| 1668 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1669 cport)->cport_mutex); | |
| 1670 sata_update_port_info(sata_hba_inst, | |
| 1671 &sata_device); | |
| 1672 SATA_CPORT_STATE(sata_hba_inst, cport) = | |
| 1673 SATA_PSTATE_FAILED; | |
| 1674 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1675 cport)->cport_mutex); | |
| 1676 rv = EIO; | |
| 1677 } | |
| 1678 /* | |
| 1679 * Since the port was reset, it should be probed and | |
| 1680 * attached device reinitialized. At this point the | |
| 1681 * port state is unknown - it's state is HBA-specific. | |
| 1682 * Re-probe port to get its state. | |
| 1683 */ | |
| 1684 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 1685 SATA_SUCCESS) { | |
| 1686 rv = EIO; | |
| 1687 break; | |
| 1688 } | |
| 1689 break; | |
| 1690 | |
| 1691 case SATA_CFGA_RESET_DEVICE: | |
| 1692 /* | |
| 1693 * There is no protection here for configured | |
| 1694 * device. | |
| 1695 */ | |
| 1696 | |
| 1697 /* Sanity check */ | |
| 1698 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1699 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1700 "sata_hba_ioctl: " | |
| 1701 "sata_hba_tran missing required " | |
| 1702 "function sata_tran_reset_dport")); | |
| 1703 rv = EINVAL; | |
| 1704 break; | |
| 1705 } | |
| 1706 | |
| 1707 /* handle only device attached to cports, for now */ | |
| 1708 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1709 | |
| 1710 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1711 cport_mutex); | |
| 1712 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 1713 &sata_device); | |
| 1714 if (sdinfo == NULL) { | |
| 1715 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1716 cport)->cport_mutex); | |
| 1717 rv = EINVAL; | |
| 1718 break; | |
| 1719 } | |
| 1720 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1721 cport_mutex); | |
| 1722 | |
| 1723 /* only handle cport for now */ | |
| 1724 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1725 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1726 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1727 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1728 "sata_hba_ioctl: reset device: failed " | |
| 1729 "cport %d pmport %d", cport, pmport)); | |
| 1730 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1731 cport)->cport_mutex); | |
| 1732 sata_update_port_info(sata_hba_inst, | |
| 1733 &sata_device); | |
| 1734 /* | |
| 1735 * Device info structure remains | |
| 1736 * attached. Another device reset or | |
| 1737 * port disconnect/connect and re-probing is | |
| 1738 * needed to change it's state | |
| 1739 */ | |
| 1740 sdinfo->satadrv_state &= ~SATA_STATE_READY; | |
| 1741 sdinfo->satadrv_state |= | |
| 1742 SATA_DSTATE_FAILED; | |
| 1743 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1744 cport)->cport_mutex); | |
| 1745 rv = EIO; | |
| 1746 } | |
| 1747 /* | |
| 1748 * Since the device was reset, we expect reset event | |
| 1749 * to be reported and processed. | |
| 1750 */ | |
| 1751 break; | |
| 1752 | |
| 1753 case SATA_CFGA_RESET_ALL: | |
| 1754 { | |
| 1755 int tcport; | |
| 1756 | |
| 1757 /* | |
| 1758 * There is no protection here for configured | |
| 1759 * devices. | |
| 1760 */ | |
| 1761 /* Sanity check */ | |
| 1762 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1763 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1764 "sata_hba_ioctl: " | |
| 1765 "sata_hba_tran missing required " | |
| 1766 "function sata_tran_reset_dport")); | |
| 1767 rv = EINVAL; | |
| 1768 break; | |
| 1769 } | |
| 1770 | |
| 1771 /* | |
| 1772 * Need to lock all ports, not just one. | |
| 1773 * If any port is locked by event processing, fail | |
| 1774 * the whole operation. | |
| 1775 * One port is already locked, but for simplicity | |
| 1776 * lock it again. | |
| 1777 */ | |
| 1778 for (tcport = 0; | |
| 1779 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1780 tcport++) { | |
| 1781 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1782 tcport)->cport_mutex); | |
| 1783 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> | |
| 1784 cport_event_flags) & | |
| 1785 SATA_EVNT_LOCK_PORT_BUSY) != 0) { | |
| 1786 rv = EBUSY; | |
| 1787 mutex_exit( | |
| 1788 &SATA_CPORT_INFO(sata_hba_inst, | |
| 1789 tcport)->cport_mutex); | |
| 1790 break; | |
| 1791 } else { | |
| 1792 SATA_CPORT_INFO(sata_hba_inst, | |
| 1793 tcport)->cport_event_flags |= | |
| 1794 SATA_APCTL_LOCK_PORT_BUSY; | |
| 1795 } | |
| 1796 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1797 tcport)->cport_mutex); | |
| 1798 } | |
| 1799 | |
| 1800 if (rv == 0) { | |
| 1801 /* | |
| 1802 * All cports successfully locked. | |
| 1803 * Reset main SATA controller only for now - | |
| 1804 * no PMult. | |
| 1805 */ | |
| 1806 sata_device.satadev_addr.qual = | |
| 1807 SATA_ADDR_CNTRL; | |
| 1808 | |
| 1809 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1810 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1811 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1812 "sata_hba_ioctl: reset controller " | |
| 1813 "failed")); | |
| 1814 rv = EIO; | |
| 1815 } | |
| 1816 | |
| 1817 /* | |
| 1818 * Since ports were reset, they should be | |
| 1819 * re-probed and attached devices | |
| 1820 * reinitialized. | |
| 1821 * At this point port states are unknown, | |
| 1822 * Re-probe ports to get their state - | |
| 1823 * cports only for now. | |
| 1824 */ | |
| 1825 for (tcport = 0; | |
| 1826 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1827 tcport++) { | |
| 1828 sata_device.satadev_addr.cport = | |
| 1829 tcport; | |
| 1830 sata_device.satadev_addr.qual = | |
| 1831 SATA_ADDR_CPORT; | |
| 1832 | |
| 1833 if (sata_reprobe_port(sata_hba_inst, | |
| 1834 &sata_device) != SATA_SUCCESS) | |
| 1835 rv = EIO; | |
| 1836 | |
| 1837 } | |
| 1838 } | |
| 1839 /* | |
| 1840 * Unlock all ports | |
| 1841 */ | |
| 1842 for (tcport = 0; | |
| 1843 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1844 tcport++) { | |
| 1845 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1846 tcport)->cport_mutex); | |
| 1847 SATA_CPORT_INFO(sata_hba_inst, tcport)-> | |
| 1848 cport_event_flags &= | |
| 1849 ~SATA_APCTL_LOCK_PORT_BUSY; | |
| 1850 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1851 tcport)->cport_mutex); | |
| 1852 } | |
| 1853 | |
| 1854 /* | |
| 1855 * This operation returns EFAULT if either reset | |
| 1856 * controller failed or a re-probbing of any ports | |
| 1857 * failed. | |
| 1858 * We return here, because common return is for | |
| 1859 * a single cport operation. | |
| 1860 */ | |
| 1861 return (rv); | |
| 1862 } | |
| 1863 | |
| 1864 case SATA_CFGA_PORT_DEACTIVATE: | |
| 1865 /* Sanity check */ | |
| 1866 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { | |
| 1867 rv = ENOTSUP; | |
| 1868 break; | |
| 1869 } | |
| 1870 /* | |
| 1871 * Arbitrarily unconfigure attached device, if any. | |
| 1872 * Even if the unconfigure fails, proceed with the | |
| 1873 * port deactivation. | |
| 1874 */ | |
| 1875 | |
| 1876 /* Handle only device attached to cports, for now */ | |
| 1877 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1878 | |
| 1879 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1880 cport_mutex); | |
| 1881 cportinfo->cport_state &= ~SATA_STATE_READY; | |
| 1882 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1883 /* | |
| 1884 * Handle only device attached to cports, | |
| 1885 * for now | |
| 1886 */ | |
| 1887 sata_device.satadev_addr.qual = | |
| 1888 SATA_ADDR_DCPORT; | |
| 1889 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 1890 &sata_device); | |
| 1891 if (sdinfo != NULL && | |
| 1892 (sdinfo->satadrv_type & | |
| 1893 SATA_VALID_DEV_TYPE)) { | |
| 1894 /* | |
| 1895 * If a target node exists, try to | |
| 1896 * offline a device and remove target | |
| 1897 * node. | |
| 1898 */ | |
| 1899 mutex_exit(&SATA_CPORT_INFO( | |
| 1900 sata_hba_inst, cport)->cport_mutex); | |
| 1901 tdip = sata_get_target_dip(dip, cport); | |
| 1902 if (tdip != NULL) { | |
| 1903 /* target node exist */ | |
| 1904 SATADBG1(SATA_DBG_IOCTL_IF, | |
| 1905 sata_hba_inst, | |
| 1906 "sata_hba_ioctl: " | |
| 1907 "port deactivate: " | |
| 1908 "target node exists.", | |
| 1909 NULL); | |
| 1910 | |
| 1911 if (ndi_devi_offline(tdip, | |
| 1912 NDI_UNCONFIG) != | |
| 1913 NDI_SUCCESS) { | |
| 1914 SATA_LOG_D(( | |
| 1915 sata_hba_inst, | |
| 1916 CE_WARN, | |
| 1917 "sata_hba_ioctl:" | |
| 1918 "port deactivate: " | |
| 1919 "failed to " | |
| 1920 "unconfigure " | |
| 1921 "device at cport " | |
| 1922 "%d", cport)); | |
| 1923 } | |
| 1924 if (ndi_devi_offline(tdip, | |
| 1925 NDI_DEVI_REMOVE) != | |
| 1926 NDI_SUCCESS) { | |
| 1927 /* | |
| 1928 * Problem; | |
| 1929 * target node remained | |
| 1930 * attached. | |
| 1931 * Too bad... | |
| 1932 */ | |
| 1933 SATA_LOG_D(( | |
| 1934 sata_hba_inst, | |
| 1935 CE_WARN, | |
| 1936 "sata_hba_ioctl: " | |
| 1937 "port deactivate: " | |
| 1938 "failed to " | |
| 1939 "unconfigure " | |
| 1940 "device at " | |
| 1941 "cport %d", | |
| 1942 cport)); | |
| 1943 } | |
| 1944 } | |
| 1945 mutex_enter(&SATA_CPORT_INFO( | |
| 1946 sata_hba_inst, cport)->cport_mutex); | |
| 1947 /* | |
| 1948 * In any case, | |
| 1949 * remove and release sata_drive_info | |
| 1950 * structure. | |
| 1951 * (cport attached device ony, for now) | |
| 1952 */ | |
| 1953 SATA_CPORTINFO_DRV_INFO(cportinfo) = | |
| 1954 NULL; | |
| 1955 (void) kmem_free((void *)sdinfo, | |
| 1956 sizeof (sata_drive_info_t)); | |
| 1957 cportinfo->cport_dev_type = | |
| 1958 SATA_DTYPE_NONE; | |
| 1959 } | |
| 1960 /* | |
| 1961 * Note: PMult info requires different | |
| 1962 * handling. This comment is a placeholder for | |
| 1963 * a code handling PMult, to be implemented | |
| 1964 * in phase 2. | |
| 1965 */ | |
| 1966 } | |
| 1967 cportinfo->cport_state &= ~(SATA_STATE_PROBED | | |
| 1968 SATA_STATE_PROBING); | |
| 1969 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1970 cport_mutex); | |
| 1971 /* handle cport only for now */ | |
| 1972 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1973 /* Just let HBA driver to deactivate port */ | |
| 1974 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) | |
| 1975 (dip, &sata_device); | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1976 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1977 * Generate sysevent - |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1978 * 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
|
1979 * without the hint |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1980 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1981 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1982 &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
|
1983 |
| 1258 | 1984 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1985 cport_mutex); | |
| 1986 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1987 if (rval != SATA_SUCCESS) { | |
| 1988 /* | |
| 1989 * Port deactivation failure - do not | |
| 1990 * change port state unless the state | |
| 1991 * returned by HBA indicates a port failure. | |
| 1992 */ | |
| 1993 if (sata_device.satadev_state & | |
| 1994 SATA_PSTATE_FAILED) { | |
| 1995 SATA_CPORT_STATE(sata_hba_inst, | |
| 1996 cport) = SATA_PSTATE_FAILED; | |
| 1997 } | |
| 1998 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1999 "sata_hba_ioctl: port deactivate: " | |
| 2000 "cannot deactivate SATA cport %d", | |
| 2001 cport)); | |
| 2002 rv = EIO; | |
| 2003 } else { | |
| 2004 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; | |
| 2005 } | |
| 2006 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2007 cport_mutex); | |
| 2008 | |
| 2009 break; | |
| 2010 | |
| 2011 case SATA_CFGA_PORT_ACTIVATE: | |
| 2012 { | |
| 2013 boolean_t dev_existed = TRUE; | |
| 2014 | |
| 2015 /* Sanity check */ | |
| 2016 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { | |
| 2017 rv = ENOTSUP; | |
| 2018 break; | |
| 2019 } | |
| 2020 /* handle cport only for now */ | |
| 2021 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || | |
| 2022 cportinfo->cport_dev_type == SATA_DTYPE_NONE) | |
| 2023 dev_existed = FALSE; | |
| 2024 | |
| 2025 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 2026 /* Just let HBA driver to activate port */ | |
| 2027 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 2028 (dip, &sata_device) != SATA_SUCCESS) { | |
| 2029 /* | |
| 2030 * Port activation failure - do not | |
| 2031 * change port state unless the state | |
| 2032 * returned by HBA indicates a port failure. | |
| 2033 */ | |
| 2034 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2035 cport)->cport_mutex); | |
| 2036 sata_update_port_info(sata_hba_inst, | |
| 2037 &sata_device); | |
| 2038 if (sata_device.satadev_state & | |
| 2039 SATA_PSTATE_FAILED) { | |
| 2040 SATA_CPORT_STATE(sata_hba_inst, | |
| 2041 cport) = SATA_PSTATE_FAILED; | |
| 2042 } | |
| 2043 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2044 cport)->cport_mutex); | |
| 2045 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2046 "sata_hba_ioctl: port activate: " | |
| 2047 "cannot activate SATA cport %d", | |
| 2048 cport)); | |
| 2049 rv = EIO; | |
| 2050 break; | |
| 2051 } | |
| 2052 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2053 cport_mutex); | |
| 2054 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; | |
| 2055 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2056 cport_mutex); | |
| 2057 | |
| 2058 /* | |
| 2059 * Re-probe port to find its current state and | |
| 2060 * possibly attached device. | |
| 2061 * Port re-probing may change the cportinfo device | |
| 2062 * type if device is found attached. | |
| 2063 * If port probing failed, the device type would be | |
| 2064 * set to SATA_DTYPE_NONE. | |
| 2065 */ | |
| 2066 (void) sata_reprobe_port(sata_hba_inst, &sata_device); | |
| 2067 | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2068 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2069 * Generate sysevent - |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2070 * 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
|
2071 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2072 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2073 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2074 &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
|
2075 |
| 1258 | 2076 if (dev_existed == FALSE && |
| 2077 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 2078 /* | |
| 2079 * That's the transition from "inactive" port | |
| 2080 * state or active port without a device | |
| 2081 * attached to the active port state with | |
| 2082 * a device attached. | |
| 2083 */ | |
| 2084 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
|
2085 "SATA device detected at port %d", cport); |
| 1258 | 2086 } |
| 2087 | |
| 2088 break; | |
| 2089 } | |
| 2090 | |
| 2091 case SATA_CFGA_PORT_SELF_TEST: | |
| 2092 | |
| 2093 /* Sanity check */ | |
| 2094 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) { | |
| 2095 rv = ENOTSUP; | |
| 2096 break; | |
| 2097 } | |
| 2098 /* | |
| 2099 * There is no protection here for a configured | |
| 2100 * device attached to this port. | |
| 2101 */ | |
| 2102 | |
| 2103 /* only handle cport for now */ | |
| 2104 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 2105 | |
| 2106 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) | |
| 2107 (dip, &sata_device) != SATA_SUCCESS) { | |
| 2108 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2109 "sata_hba_ioctl: port selftest: " | |
| 2110 "failed cport %d pmport %d", | |
| 2111 cport, pmport)); | |
| 2112 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2113 cport)->cport_mutex); | |
| 2114 sata_update_port_info(sata_hba_inst, | |
| 2115 &sata_device); | |
| 2116 SATA_CPORT_STATE(sata_hba_inst, cport) = | |
| 2117 SATA_PSTATE_FAILED; | |
| 2118 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2119 cport)->cport_mutex); | |
| 2120 rv = EIO; | |
| 2121 break; | |
| 2122 } | |
| 2123 /* | |
| 2124 * Since the port was reset, it should be probed and | |
| 2125 * attached device reinitialized. At this point the | |
| 2126 * port state is unknown - it's state is HBA-specific. | |
| 2127 * Force port re-probing to get it into a known state. | |
| 2128 */ | |
| 2129 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 2130 SATA_SUCCESS) { | |
| 2131 rv = EIO; | |
| 2132 break; | |
| 2133 } | |
| 2134 break; | |
| 2135 | |
| 2136 case SATA_CFGA_GET_DEVICE_PATH: | |
| 2137 { | |
| 2138 char path[MAXPATHLEN]; | |
| 2139 uint32_t size; | |
| 2140 | |
| 2141 (void) strcpy(path, "/devices"); | |
| 2142 if ((tdip = sata_get_target_dip(dip, ioc.port)) == | |
| 2143 NULL) { | |
| 2144 | |
| 2145 /* | |
| 2146 * No such device. | |
| 2147 * If this is a request for a size, do not | |
| 2148 * return EINVAL for non-exisiting target, | |
| 2149 * because cfgadm will indicate a meaningless | |
| 2150 * ioctl failure. | |
| 2151 * If this is a real request for a path, | |
| 2152 * indicate invalid argument. | |
| 2153 */ | |
| 2154 if (!ioc.get_size) { | |
| 2155 rv = EINVAL; | |
| 2156 break; | |
| 2157 } | |
| 2158 } else { | |
| 2159 (void) ddi_pathname(tdip, path + strlen(path)); | |
| 2160 } | |
| 2161 size = strlen(path) + 1; | |
| 2162 | |
| 2163 if (ioc.get_size) { | |
| 2164 if (ddi_copyout((void *)&size, | |
| 2165 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2166 rv = EFAULT; | |
| 2167 } | |
| 2168 } else { | |
| 2169 if (ioc.bufsiz != size) { | |
| 2170 rv = EINVAL; | |
| 2171 } else if (ddi_copyout((void *)&path, | |
| 2172 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2173 rv = EFAULT; | |
| 2174 } | |
| 2175 } | |
| 2176 break; | |
| 2177 } | |
| 2178 | |
| 2179 case SATA_CFGA_GET_AP_TYPE: | |
| 2180 { | |
| 2181 uint32_t type_len; | |
| 2182 const char *ap_type; | |
| 2183 | |
| 2184 /* cport only, no port multiplier support */ | |
| 2185 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { | |
| 2186 case SATA_DTYPE_NONE: | |
| 2187 ap_type = "port"; | |
| 2188 break; | |
| 2189 | |
| 2190 case SATA_DTYPE_ATADISK: | |
| 2191 ap_type = "disk"; | |
| 2192 break; | |
| 2193 | |
| 2194 case SATA_DTYPE_ATAPICD: | |
| 2195 ap_type = "cd/dvd"; | |
| 2196 break; | |
| 2197 | |
| 2198 case SATA_DTYPE_PMULT: | |
| 2199 ap_type = "pmult"; | |
| 2200 break; | |
| 2201 | |
| 2202 case SATA_DTYPE_UNKNOWN: | |
| 2203 ap_type = "unknown"; | |
| 2204 break; | |
| 2205 | |
| 2206 default: | |
| 2207 ap_type = "unsupported"; | |
| 2208 break; | |
| 2209 | |
| 2210 } /* end of dev_type switch */ | |
| 2211 | |
| 2212 type_len = strlen(ap_type) + 1; | |
| 2213 | |
| 2214 if (ioc.get_size) { | |
| 2215 if (ddi_copyout((void *)&type_len, | |
| 2216 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2217 rv = EFAULT; | |
| 2218 break; | |
| 2219 } | |
| 2220 } else { | |
| 2221 if (ioc.bufsiz != type_len) { | |
| 2222 rv = EINVAL; | |
| 2223 break; | |
| 2224 } | |
| 2225 if (ddi_copyout((void *)ap_type, ioc.buf, | |
| 2226 ioc.bufsiz, mode) != 0) { | |
| 2227 rv = EFAULT; | |
| 2228 break; | |
| 2229 } | |
| 2230 } | |
| 2231 | |
| 2232 break; | |
| 2233 } | |
| 2234 | |
| 2235 case SATA_CFGA_GET_MODEL_INFO: | |
| 2236 { | |
| 2237 uint32_t info_len; | |
| 2238 char ap_info[sizeof (sdinfo->satadrv_id.ai_model) + 1]; | |
| 2239 | |
| 2240 /* | |
| 2241 * This operation should return to cfgadm the | |
| 2242 * device model information string | |
| 2243 */ | |
| 2244 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2245 cport_mutex); | |
| 2246 /* only handle device connected to cport for now */ | |
| 2247 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2248 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2249 &sata_device); | |
| 2250 if (sdinfo == NULL) { | |
| 2251 rv = EINVAL; | |
| 2252 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2253 cport)->cport_mutex); | |
| 2254 break; | |
| 2255 } | |
| 2256 bcopy(sdinfo->satadrv_id.ai_model, ap_info, | |
| 2257 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 2258 swab(ap_info, ap_info, | |
| 2259 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 2260 ap_info[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; | |
| 2261 | |
| 2262 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2263 cport_mutex); | |
| 2264 | |
| 2265 info_len = strlen(ap_info) + 1; | |
| 2266 | |
| 2267 if (ioc.get_size) { | |
| 2268 if (ddi_copyout((void *)&info_len, | |
| 2269 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2270 rv = EFAULT; | |
| 2271 break; | |
| 2272 } | |
| 2273 } else { | |
| 2274 if (ioc.bufsiz < info_len) { | |
| 2275 rv = EINVAL; | |
| 2276 break; | |
| 2277 } | |
| 2278 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2279 ioc.bufsiz, mode) != 0) { | |
| 2280 rv = EFAULT; | |
| 2281 break; | |
| 2282 } | |
| 2283 } | |
| 2284 | |
| 2285 break; | |
| 2286 } | |
| 2287 | |
| 2288 case SATA_CFGA_GET_REVFIRMWARE_INFO: | |
| 2289 { | |
| 2290 uint32_t info_len; | |
| 2291 char ap_info[ | |
| 2292 sizeof (sdinfo->satadrv_id.ai_fw) + 1]; | |
| 2293 | |
| 2294 /* | |
| 2295 * This operation should return to cfgadm the | |
| 2296 * device firmware revision information string | |
| 2297 */ | |
| 2298 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2299 cport_mutex); | |
| 2300 /* only handle device connected to cport for now */ | |
| 2301 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2302 | |
| 2303 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2304 &sata_device); | |
| 2305 if (sdinfo == NULL) { | |
| 2306 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2307 cport)->cport_mutex); | |
| 2308 rv = EINVAL; | |
| 2309 break; | |
| 2310 } | |
| 2311 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, | |
| 2312 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 2313 swab(ap_info, ap_info, | |
| 2314 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 2315 ap_info[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; | |
| 2316 | |
| 2317 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2318 cport_mutex); | |
| 2319 | |
| 2320 info_len = strlen(ap_info) + 1; | |
| 2321 | |
| 2322 if (ioc.get_size) { | |
| 2323 if (ddi_copyout((void *)&info_len, | |
| 2324 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2325 rv = EFAULT; | |
| 2326 break; | |
| 2327 } | |
| 2328 } else { | |
| 2329 if (ioc.bufsiz < info_len) { | |
| 2330 rv = EINVAL; | |
| 2331 break; | |
| 2332 } | |
| 2333 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2334 ioc.bufsiz, mode) != 0) { | |
| 2335 rv = EFAULT; | |
| 2336 break; | |
| 2337 } | |
| 2338 } | |
| 2339 | |
| 2340 break; | |
| 2341 } | |
| 2342 | |
| 2343 case SATA_CFGA_GET_SERIALNUMBER_INFO: | |
| 2344 { | |
| 2345 uint32_t info_len; | |
| 2346 char ap_info[ | |
| 2347 sizeof (sdinfo->satadrv_id.ai_drvser) + 1]; | |
| 2348 | |
| 2349 /* | |
| 2350 * This operation should return to cfgadm the | |
| 2351 * device serial number information string | |
| 2352 */ | |
| 2353 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2354 cport_mutex); | |
| 2355 /* only handle device connected to cport for now */ | |
| 2356 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2357 | |
| 2358 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2359 &sata_device); | |
| 2360 if (sdinfo == NULL) { | |
| 2361 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2362 cport)->cport_mutex); | |
| 2363 rv = EINVAL; | |
| 2364 break; | |
| 2365 } | |
| 2366 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, | |
| 2367 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 2368 swab(ap_info, ap_info, | |
| 2369 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 2370 ap_info[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; | |
| 2371 | |
| 2372 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2373 cport_mutex); | |
| 2374 | |
| 2375 info_len = strlen(ap_info) + 1; | |
| 2376 | |
| 2377 if (ioc.get_size) { | |
| 2378 if (ddi_copyout((void *)&info_len, | |
| 2379 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2380 rv = EFAULT; | |
| 2381 break; | |
| 2382 } | |
| 2383 } else { | |
| 2384 if (ioc.bufsiz < info_len) { | |
| 2385 rv = EINVAL; | |
| 2386 break; | |
| 2387 } | |
| 2388 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2389 ioc.bufsiz, mode) != 0) { | |
| 2390 rv = EFAULT; | |
| 2391 break; | |
| 2392 } | |
| 2393 } | |
| 2394 | |
| 2395 break; | |
| 2396 } | |
| 2397 | |
| 2398 default: | |
| 2399 rv = EINVAL; | |
| 2400 break; | |
| 2401 | |
| 2402 } /* End of DEVCTL_AP_CONTROL cmd switch */ | |
| 2403 | |
| 2404 break; | |
| 2405 } | |
| 2406 | |
| 2407 default: | |
| 2408 { | |
| 2409 /* | |
| 2410 * If we got here, we got an IOCTL that SATA HBA Framework | |
| 2411 * does not recognize. Pass ioctl to HBA driver, in case | |
| 2412 * it could process it. | |
| 2413 */ | |
| 2414 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; | |
| 2415 dev_info_t *mydip = SATA_DIP(sata_hba_inst); | |
| 2416 | |
| 2417 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 2418 "IOCTL 0x%2x not supported in SATA framework, " | |
| 2419 "passthrough to HBA", cmd); | |
| 2420 | |
| 2421 if (sata_tran->sata_tran_ioctl == NULL) { | |
| 2422 rv = EINVAL; | |
| 2423 break; | |
| 2424 } | |
| 2425 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); | |
| 2426 if (rval != 0) { | |
| 2427 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 2428 "IOCTL 0x%2x failed in HBA", cmd); | |
| 2429 rv = rval; | |
| 2430 } | |
| 2431 break; | |
| 2432 } | |
| 2433 | |
| 2434 } /* End of main IOCTL switch */ | |
| 2435 | |
| 2436 if (dcp) { | |
| 2437 ndi_dc_freehdl(dcp); | |
| 2438 } | |
| 2439 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 2440 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; | |
| 2441 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 2442 | |
| 2443 return (rv); | |
| 2444 } | |
| 2445 | |
| 2446 | |
| 2447 | |
| 2448 | |
| 2449 /* ****************** SCSA required entry points *********************** */ | |
| 2450 | |
| 2451 /* | |
| 2452 * Implementation of scsi tran_tgt_init. | |
| 2453 * sata_scsi_tgt_init() initializes scsi_device structure | |
| 2454 * | |
| 2455 * If successful, DDI_SUCCESS is returned. | |
| 2456 * DDI_FAILURE is returned if addressed device does not exist | |
| 2457 */ | |
| 2458 | |
| 2459 static int | |
| 2460 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, | |
| 2461 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) | |
| 2462 { | |
| 2463 #ifndef __lock_lint | |
| 2464 _NOTE(ARGUNUSED(hba_dip)) | |
| 2465 #endif | |
| 2466 sata_device_t sata_device; | |
| 2467 sata_drive_info_t *sdinfo; | |
| 2468 sata_hba_inst_t *sata_hba_inst; | |
| 2469 | |
| 2470 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); | |
| 2471 | |
| 2472 /* Validate scsi device address */ | |
| 2473 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, | |
| 2474 &sata_device) != 0) | |
| 2475 return (DDI_FAILURE); | |
| 2476 | |
| 2477 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2478 sata_device.satadev_addr.cport))); | |
| 2479 | |
| 2480 /* sata_device now contains a valid sata address */ | |
| 2481 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 2482 if (sdinfo == NULL) { | |
| 2483 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2484 sata_device.satadev_addr.cport))); | |
| 2485 return (DDI_FAILURE); | |
| 2486 } | |
| 2487 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { | |
| 2488 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2489 sata_device.satadev_addr.cport))); | |
| 2490 if (ndi_prop_update_string(DDI_DEV_T_NONE, tgt_dip, | |
| 2491 "variant", "atapi") != DDI_PROP_SUCCESS) { | |
| 2492 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2493 "sata_scsi_tgt_init: variant atapi " | |
| 2494 "property could not be created")); | |
| 2495 return (DDI_FAILURE); | |
| 2496 } | |
| 2497 return (DDI_SUCCESS); | |
| 2498 } | |
| 2499 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2500 sata_device.satadev_addr.cport))); | |
| 2501 return (DDI_SUCCESS); | |
| 2502 } | |
| 2503 | |
| 2504 /* | |
| 2505 * Implementation of scsi tran_tgt_probe. | |
| 2506 * Probe target, by calling default scsi routine scsi_hba_probe() | |
| 2507 */ | |
| 2508 static int | |
| 2509 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) | |
| 2510 { | |
| 2511 sata_hba_inst_t *sata_hba_inst = | |
| 2512 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); | |
| 2513 int rval; | |
| 2514 | |
| 2515 rval = scsi_hba_probe(sd, callback); | |
| 2516 | |
| 2517 if (rval == SCSIPROBE_EXISTS) { | |
| 2518 /* | |
| 2519 * Set property "pm-capable" on the target device node, so that | |
| 2520 * the target driver will not try to fetch scsi cycle counters | |
| 2521 * before enabling device power-management. | |
| 2522 */ | |
| 2523 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, | |
| 2524 "pm-capable", 1)) != DDI_PROP_SUCCESS) { | |
| 2525 sata_log(sata_hba_inst, CE_WARN, | |
| 2526 "device at port %d: will not be power-managed ", | |
| 2527 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); | |
| 2528 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2529 "failure updating pm-capable property")); | |
| 2530 } | |
| 2531 } | |
| 2532 return (rval); | |
| 2533 } | |
| 2534 | |
| 2535 /* | |
| 2536 * Implementation of scsi tran_tgt_free. | |
| 2537 * Release all resources allocated for scsi_device | |
| 2538 */ | |
| 2539 static void | |
| 2540 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, | |
| 2541 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) | |
| 2542 { | |
| 2543 #ifndef __lock_lint | |
| 2544 _NOTE(ARGUNUSED(hba_dip)) | |
| 2545 #endif | |
| 2546 sata_device_t sata_device; | |
| 2547 sata_drive_info_t *sdinfo; | |
| 2548 sata_hba_inst_t *sata_hba_inst; | |
| 2549 | |
| 2550 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); | |
| 2551 | |
| 2552 /* Validate scsi device address */ | |
| 2553 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, | |
| 2554 &sata_device) != 0) | |
| 2555 return; | |
| 2556 | |
| 2557 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2558 sata_device.satadev_addr.cport))); | |
| 2559 | |
| 2560 /* sata_device now should contain a valid sata address */ | |
| 2561 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 2562 if (sdinfo == NULL) { | |
| 2563 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2564 sata_device.satadev_addr.cport))); | |
| 2565 return; | |
| 2566 } | |
| 2567 /* | |
| 2568 * We did not allocate any resources in sata_scsi_tgt_init() | |
| 2569 * other than property for ATAPI device, if any | |
| 2570 */ | |
| 2571 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { | |
| 2572 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2573 sata_device.satadev_addr.cport))); | |
| 2574 if (ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "variant") != | |
| 2575 DDI_PROP_SUCCESS) | |
| 2576 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2577 "sata_scsi_tgt_free: variant atapi " | |
| 2578 "property could not be removed")); | |
| 2579 } else { | |
| 2580 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2581 sata_device.satadev_addr.cport))); | |
| 2582 } | |
| 2583 } | |
| 2584 | |
| 2585 /* | |
| 2586 * Implementation of scsi tran_init_pkt | |
| 2587 * Upon successful return, scsi pkt buffer has DMA resources allocated. | |
| 2588 * | |
| 2589 * It seems that we should always allocate pkt, even if the address is | |
| 2590 * for non-existing device - just use some default for dma_attr. | |
| 2591 * The reason is that there is no way to communicate this to a caller here. | |
| 2592 * Subsequent call to sata_scsi_start may fail appropriately. | |
| 2593 * Simply returning NULL does not seem to discourage a target driver... | |
| 2594 * | |
| 2595 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. | |
| 2596 */ | |
| 2597 static struct scsi_pkt * | |
| 2598 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, | |
| 2599 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, | |
| 2600 int (*callback)(caddr_t), caddr_t arg) | |
| 2601 { | |
| 2602 sata_hba_inst_t *sata_hba_inst = | |
| 2603 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2604 dev_info_t *dip = SATA_DIP(sata_hba_inst); | |
| 2605 sata_device_t sata_device; | |
| 2606 sata_drive_info_t *sdinfo; | |
| 2607 sata_pkt_txlate_t *spx; | |
| 2608 ddi_dma_attr_t cur_dma_attr; | |
| 2609 int rval; | |
| 2610 boolean_t new_pkt = TRUE; | |
| 2611 | |
| 2612 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); | |
| 2613 | |
| 2614 /* | |
| 2615 * We need to translate the address, even if it could be | |
| 2616 * a bogus one, for a non-existing device | |
| 2617 */ | |
| 2618 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); | |
| 2619 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 2620 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); | |
| 2621 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 2622 | |
| 2623 if (pkt == NULL) { | |
| 2624 /* | |
| 2625 * Have to allocate a brand new scsi packet. | |
| 2626 * We need to operate with auto request sense enabled. | |
| 2627 */ | |
| 2628 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, | |
| 2629 MAX(statuslen, sizeof (struct scsi_arq_status)), | |
| 2630 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); | |
| 2631 | |
| 2632 if (pkt == NULL) | |
| 2633 return (NULL); | |
| 2634 | |
| 2635 /* Fill scsi packet structure */ | |
| 2636 pkt->pkt_comp = (void (*)())NULL; | |
| 2637 pkt->pkt_time = 0; | |
| 2638 pkt->pkt_resid = 0; | |
| 2639 pkt->pkt_statistics = 0; | |
| 2640 pkt->pkt_reason = 0; | |
| 2641 | |
| 2642 /* | |
| 2643 * pkt_hba_private will point to sata pkt txlate structure | |
| 2644 */ | |
| 2645 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2646 bzero(spx, sizeof (sata_pkt_txlate_t)); | |
| 2647 | |
| 2648 spx->txlt_scsi_pkt = pkt; | |
| 2649 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 2650 | |
| 2651 /* Allocate sata_pkt */ | |
| 2652 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); | |
| 2653 if (spx->txlt_sata_pkt == NULL) { | |
| 2654 /* Could not allocate sata pkt */ | |
| 2655 scsi_hba_pkt_free(ap, pkt); | |
| 2656 return (NULL); | |
| 2657 } | |
| 2658 /* Set sata address */ | |
| 2659 spx->txlt_sata_pkt->satapkt_device = sata_device; | |
| 2660 | |
| 2661 if ((bp == NULL) || (bp->b_bcount == 0)) | |
| 2662 return (pkt); | |
| 2663 | |
| 2664 spx->txlt_total_residue = bp->b_bcount; | |
| 2665 } else { | |
| 2666 new_pkt = FALSE; | |
| 2667 /* | |
| 2668 * Packet was preallocated/initialized by previous call | |
| 2669 */ | |
| 2670 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2671 | |
| 2672 if ((bp == NULL) || (bp->b_bcount == 0)) { | |
| 2673 return (pkt); | |
| 2674 } | |
| 2675 ASSERT(spx->txlt_buf_dma_handle != NULL); | |
| 2676 | |
| 2677 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ | |
| 2678 } | |
| 2679 | |
| 2680 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; | |
| 2681 | |
| 2682 /* | |
| 2683 * We use an adjusted version of the dma_attr, to account | |
| 2684 * for device addressing limitations. | |
| 2685 * sata_adjust_dma_attr() will handle sdinfo == NULL which may | |
| 2686 * happen when a device is not yet configured. | |
| 2687 */ | |
| 2688 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2689 sata_device.satadev_addr.cport))); | |
| 2690 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 2691 &spx->txlt_sata_pkt->satapkt_device); | |
| 2692 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ | |
| 2693 sata_adjust_dma_attr(sdinfo, | |
| 2694 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); | |
| 2695 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2696 sata_device.satadev_addr.cport))); | |
| 2697 /* | |
| 2698 * Allocate necessary DMA resources for the packet's buffer | |
| 2699 */ | |
| 2700 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, | |
| 2701 &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
|
2702 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; |
| 1258 | 2703 sata_pkt_free(spx); |
| 2704 /* | |
| 2705 * If a DMA allocation request fails with | |
| 2706 * DDI_DMA_NOMAPPING, indicate the error by calling | |
| 2707 * bioerror(9F) with bp and an error code of EFAULT. | |
| 2708 * If a DMA allocation request fails with | |
| 2709 * DDI_DMA_TOOBIG, indicate the error by calling | |
| 2710 * bioerror(9F) with bp and an error code of EINVAL. | |
| 2711 */ | |
| 2712 switch (rval) { | |
| 2713 case DDI_DMA_NORESOURCES: | |
| 2714 bioerror(bp, 0); | |
| 2715 break; | |
| 2716 case DDI_DMA_NOMAPPING: | |
| 2717 case DDI_DMA_BADATTR: | |
| 2718 bioerror(bp, EFAULT); | |
| 2719 break; | |
| 2720 case DDI_DMA_TOOBIG: | |
| 2721 default: | |
| 2722 bioerror(bp, EINVAL); | |
| 2723 break; | |
| 2724 } | |
| 2177 | 2725 if (new_pkt == TRUE) |
| 1258 | 2726 scsi_hba_pkt_free(ap, pkt); |
| 2727 return (NULL); | |
| 2728 } | |
| 2729 /* Set number of bytes that are not yet accounted for */ | |
| 2730 pkt->pkt_resid = spx->txlt_total_residue; | |
| 2731 ASSERT(pkt->pkt_resid >= 0); | |
| 2732 | |
| 2733 return (pkt); | |
| 2734 } | |
| 2735 | |
| 2736 /* | |
| 2737 * Implementation of scsi tran_start. | |
| 2738 * Translate scsi cmd into sata operation and return status. | |
| 2739 * Supported scsi commands: | |
| 2740 * SCMD_INQUIRY | |
| 2741 * SCMD_TEST_UNIT_READY | |
| 2742 * SCMD_START_STOP | |
| 2743 * SCMD_READ_CAPACITY | |
| 2744 * SCMD_REQUEST_SENSE | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
2745 * SCMD_LOG_SENSE_G1 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
2746 * SCMD_LOG_SELECT_G1 |
| 1258 | 2747 * SCMD_MODE_SENSE (specific pages) |
| 2748 * SCMD_MODE_SENSE_G1 (specific pages) | |
| 2749 * SCMD_MODE_SELECT (specific pages) | |
| 2750 * SCMD_MODE_SELECT_G1 (specific pages) | |
| 2751 * SCMD_SYNCHRONIZE_CACHE | |
| 2752 * SCMD_SYNCHRONIZE_CACHE_G1 | |
| 2753 * SCMD_READ | |
| 2754 * SCMD_READ_G1 | |
| 2755 * SCMD_READ_G4 | |
| 2756 * SCMD_READ_G5 | |
| 2757 * SCMD_WRITE | |
| 2758 * SCMD_WRITE_G1 | |
| 2759 * SCMD_WRITE_G4 | |
| 2760 * SCMD_WRITE_G5 | |
| 2761 * SCMD_SEEK (noop) | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
2762 * SCMD_SDIAG |
| 1258 | 2763 * |
| 2764 * All other commands are rejected as unsupported. | |
| 2765 * | |
| 2766 * Returns: | |
| 2767 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver | |
| 2768 * for execution. | |
| 2769 * TRAN_BADPKT if cmd was directed to invalid address. | |
| 2770 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including | |
| 2771 * unexpected removal of a device or some other unspecified error. | |
| 2772 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA | |
| 2773 * framework was busy performing some other operation(s). | |
| 2774 * | |
| 2775 */ | |
| 2776 static int | |
| 2777 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 2778 { | |
| 2779 sata_hba_inst_t *sata_hba_inst = | |
| 2780 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2781 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2782 sata_drive_info_t *sdinfo; | |
| 2783 struct buf *bp; | |
| 2784 int cport; | |
| 2785 int rval; | |
| 2786 | |
| 2787 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2788 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); | |
| 2789 | |
| 2790 ASSERT(spx != NULL && | |
| 2791 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); | |
| 2792 | |
| 2793 /* | |
| 2794 * Mutex-protected section below is just to identify device type | |
| 2795 * and switch to ATAPI processing, if necessary | |
| 2796 */ | |
| 2797 cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 2798 | |
| 2799 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2800 | |
| 2801 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2802 &spx->txlt_sata_pkt->satapkt_device); | |
| 2803 if (sdinfo == NULL) { | |
| 2804 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2805 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; | |
| 2806 return (TRAN_FATAL_ERROR); | |
| 2807 } | |
| 2808 | |
| 2809 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 2810 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2811 rval = sata_txlt_atapi(spx); | |
| 2812 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2813 "sata_scsi_start atapi: rval %d\n", rval); | |
| 2814 return (rval); | |
| 2815 } | |
| 2816 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2817 | |
| 2818 /* ATA Disk commands processing starts here */ | |
| 2819 | |
| 2820 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 2821 | |
| 2822 switch (pkt->pkt_cdbp[0]) { | |
| 2823 | |
| 2824 case SCMD_INQUIRY: | |
| 2825 /* Mapped to identify device */ | |
| 2826 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2827 bp_mapin(bp); | |
| 2828 rval = sata_txlt_inquiry(spx); | |
| 2829 break; | |
| 2830 | |
| 2831 case SCMD_TEST_UNIT_READY: | |
| 2832 /* | |
| 2833 * SAT "SATA to ATA Translation" doc specifies translation | |
| 2834 * to ATA CHECK POWER MODE. | |
| 2835 */ | |
| 2836 rval = sata_txlt_test_unit_ready(spx); | |
| 2837 break; | |
| 2838 | |
| 2839 case SCMD_START_STOP: | |
| 2840 /* Mapping depends on the command */ | |
| 2841 rval = sata_txlt_start_stop_unit(spx); | |
| 2842 break; | |
| 2843 | |
| 2844 case SCMD_READ_CAPACITY: | |
| 2845 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2846 bp_mapin(bp); | |
| 2847 rval = sata_txlt_read_capacity(spx); | |
| 2848 break; | |
| 2849 | |
| 2850 case SCMD_REQUEST_SENSE: | |
| 2851 /* | |
| 2852 * Always No Sense, since we force ARQ | |
| 2853 */ | |
| 2854 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2855 bp_mapin(bp); | |
| 2856 rval = sata_txlt_request_sense(spx); | |
| 2857 break; | |
| 2858 | |
| 2859 case SCMD_LOG_SENSE_G1: | |
| 2860 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2861 bp_mapin(bp); | |
| 2862 rval = sata_txlt_log_sense(spx); | |
| 2863 break; | |
| 2864 | |
| 2865 case SCMD_LOG_SELECT_G1: | |
| 2866 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2867 bp_mapin(bp); | |
| 2868 rval = sata_txlt_log_select(spx); | |
| 2869 break; | |
| 2870 | |
| 2871 case SCMD_MODE_SENSE: | |
| 2872 case SCMD_MODE_SENSE_G1: | |
| 2873 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2874 bp_mapin(bp); | |
| 2875 rval = sata_txlt_mode_sense(spx); | |
| 2876 break; | |
| 2877 | |
| 2878 | |
| 2879 case SCMD_MODE_SELECT: | |
| 2880 case SCMD_MODE_SELECT_G1: | |
| 2881 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2882 bp_mapin(bp); | |
| 2883 rval = sata_txlt_mode_select(spx); | |
| 2884 break; | |
| 2885 | |
| 2886 case SCMD_SYNCHRONIZE_CACHE: | |
| 2887 case SCMD_SYNCHRONIZE_CACHE_G1: | |
| 2888 rval = sata_txlt_synchronize_cache(spx); | |
| 2889 break; | |
| 2890 | |
| 2891 case SCMD_READ: | |
| 2892 case SCMD_READ_G1: | |
| 2893 case SCMD_READ_G4: | |
| 2894 case SCMD_READ_G5: | |
| 2895 rval = sata_txlt_read(spx); | |
| 2896 break; | |
| 2897 | |
| 2898 case SCMD_WRITE: | |
| 2899 case SCMD_WRITE_G1: | |
| 2900 case SCMD_WRITE_G4: | |
| 2901 case SCMD_WRITE_G5: | |
| 2902 rval = sata_txlt_write(spx); | |
| 2903 break; | |
| 2904 | |
| 2905 case SCMD_SEEK: | |
| 2906 rval = sata_txlt_nodata_cmd_immediate(spx); | |
| 2907 break; | |
| 2908 | |
| 2909 /* Other cases will be filed later */ | |
| 2910 /* postponed until phase 2 of the development */ | |
| 2911 default: | |
| 2912 rval = sata_txlt_invalid_command(spx); | |
| 2913 break; | |
| 2914 } | |
| 2915 | |
| 2916 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2917 "sata_scsi_start: rval %d\n", rval); | |
| 2918 | |
| 2919 return (rval); | |
| 2920 } | |
| 2921 | |
| 2922 /* | |
| 2923 * Implementation of scsi tran_abort. | |
| 2924 * Abort specific pkt or all packets. | |
| 2925 * | |
| 2926 * Returns 1 if one or more packets were aborted, returns 0 otherwise | |
| 2927 * | |
| 2928 * May be called from an interrupt level. | |
| 2929 */ | |
| 2930 static int | |
| 2931 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) | |
| 2932 { | |
| 2933 sata_hba_inst_t *sata_hba_inst = | |
| 2934 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2935 sata_device_t sata_device; | |
| 2936 sata_pkt_t *sata_pkt; | |
| 2937 | |
| 2938 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2939 "sata_scsi_abort: %s at target: 0x%x\n", | |
| 2940 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); | |
| 2941 | |
| 2942 /* Validate address */ | |
| 2943 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) | |
| 2944 /* Invalid address */ | |
| 2945 return (0); | |
| 2946 | |
| 2947 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2948 sata_device.satadev_addr.cport))); | |
| 2949 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 2950 /* invalid address */ | |
| 2951 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2952 sata_device.satadev_addr.cport))); | |
| 2953 return (0); | |
| 2954 } | |
| 2955 if (scsi_pkt == NULL) { | |
| 2956 /* | |
| 2957 * Abort all packets. | |
| 2958 * Although we do not have specific packet, we still need | |
| 2959 * dummy packet structure to pass device address to HBA. | |
| 2960 * Allocate one, without sleeping. Fail if pkt cannot be | |
| 2961 * allocated. | |
| 2962 */ | |
| 2963 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); | |
| 2964 if (sata_pkt == NULL) { | |
| 2965 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2966 sata_device.satadev_addr.cport))); | |
| 2967 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " | |
| 2968 "could not allocate sata_pkt")); | |
| 2969 return (0); | |
| 2970 } | |
| 2971 sata_pkt->satapkt_rev = SATA_PKT_REV; | |
| 2972 sata_pkt->satapkt_device = sata_device; | |
| 2973 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; | |
| 2974 } else { | |
| 2975 if (scsi_pkt->pkt_ha_private == NULL) { | |
| 2976 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2977 sata_device.satadev_addr.cport))); | |
| 2978 return (0); /* Bad scsi pkt */ | |
| 2979 } | |
| 2980 /* extract pointer to sata pkt */ | |
| 2981 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> | |
| 2982 txlt_sata_pkt; | |
| 2983 } | |
| 2984 | |
| 2985 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2986 sata_device.satadev_addr.cport))); | |
| 2987 /* Send abort request to HBA */ | |
| 2988 if ((*SATA_ABORT_FUNC(sata_hba_inst)) | |
| 2989 (SATA_DIP(sata_hba_inst), sata_pkt, | |
| 2990 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == | |
| 2991 SATA_SUCCESS) { | |
| 2992 if (scsi_pkt == NULL) | |
| 2993 kmem_free(sata_pkt, sizeof (sata_pkt_t)); | |
| 2994 /* Success */ | |
| 2995 return (1); | |
| 2996 } | |
| 2997 /* Else, something did not go right */ | |
| 2998 if (scsi_pkt == NULL) | |
| 2999 kmem_free(sata_pkt, sizeof (sata_pkt_t)); | |
| 3000 /* Failure */ | |
| 3001 return (0); | |
| 3002 } | |
| 3003 | |
| 3004 | |
| 3005 /* | |
| 3006 * Implementation os scsi tran_reset. | |
| 3007 * RESET_ALL request is translated into port reset. | |
| 3008 * RESET_TARGET requests is translated into a device reset, | |
| 3009 * RESET_LUN request is accepted only for LUN 0 and translated into | |
| 3010 * device reset. | |
| 3011 * The target reset should cause all HBA active and queued packets to | |
| 3012 * be terminated and returned with pkt reason SATA_PKT_RESET prior to | |
| 3013 * the return. HBA should report reset event for the device. | |
| 3014 * | |
| 3015 * Returns 1 upon success, 0 upon failure. | |
| 3016 */ | |
| 3017 static int | |
| 3018 sata_scsi_reset(struct scsi_address *ap, int level) | |
| 3019 { | |
| 3020 sata_hba_inst_t *sata_hba_inst = | |
| 3021 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3022 sata_device_t sata_device; | |
| 3023 int val; | |
| 3024 | |
| 3025 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3026 "sata_scsi_reset: level %d target: 0x%x\n", | |
| 3027 level, ap->a_target); | |
| 3028 | |
| 3029 /* Validate address */ | |
| 3030 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); | |
| 3031 if (val == -1) | |
| 3032 /* Invalid address */ | |
| 3033 return (0); | |
| 3034 | |
| 3035 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3036 sata_device.satadev_addr.cport))); | |
| 3037 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 3038 /* invalid address */ | |
| 3039 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3040 sata_device.satadev_addr.cport))); | |
| 3041 return (0); | |
| 3042 } | |
| 3043 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3044 sata_device.satadev_addr.cport))); | |
| 3045 if (level == RESET_ALL) { | |
| 3046 /* port reset - cport only */ | |
| 3047 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 3048 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 3049 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) | |
| 3050 return (1); | |
| 3051 else | |
| 3052 return (0); | |
| 3053 | |
| 3054 } else if (val == 0 && | |
| 3055 (level == RESET_TARGET || level == RESET_LUN)) { | |
| 3056 /* reset device (device attached) */ | |
| 3057 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 3058 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) | |
| 3059 return (1); | |
| 3060 else | |
| 3061 return (0); | |
| 3062 } | |
| 3063 return (0); | |
| 3064 } | |
| 3065 | |
| 3066 | |
| 3067 /* | |
| 3068 * Implementation of scsi tran_getcap (get transport/device capabilities). | |
| 3069 * Supported capabilities: | |
| 3070 * auto-rqsense (always supported) | |
| 3071 * 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
|
3072 * 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
|
3073 * caching behavior allowing untagged queuing actually |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3074 * 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
|
3075 * 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
|
3076 * 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
|
3077 * 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
|
3078 * results in cache thrashing.) |
| 1258 | 3079 * dma_max |
| 3080 * interconnect-type (INTERCONNECT_SATA) | |
| 3081 * | |
| 3082 * Request for other capabilities is rejected as unsupported. | |
| 3083 * | |
| 3084 * Returns supported capability value, or -1 if capability is unsuppported or | |
| 3085 * the address is invalid (no device). | |
| 3086 */ | |
| 3087 | |
| 3088 static int | |
| 3089 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) | |
| 3090 { | |
| 3091 | |
| 3092 sata_hba_inst_t *sata_hba_inst = | |
| 3093 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3094 sata_device_t sata_device; | |
| 3095 sata_drive_info_t *sdinfo; | |
| 3096 ddi_dma_attr_t adj_dma_attr; | |
| 3097 int rval; | |
| 3098 | |
| 3099 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3100 "sata_scsi_getcap: target: 0x%x, cap: %s\n", | |
| 3101 ap->a_target, cap); | |
| 3102 | |
| 3103 /* | |
| 3104 * We want to process the capabilities on per port granularity. | |
| 3105 * So, we are specifically restricting ourselves to whom != 0 | |
| 3106 * to exclude the controller wide handling. | |
| 3107 */ | |
| 3108 if (cap == NULL || whom == 0) | |
| 3109 return (-1); | |
| 3110 | |
| 3111 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { | |
| 3112 /* Invalid address */ | |
| 3113 return (-1); | |
| 3114 } | |
| 3115 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3116 sata_device.satadev_addr.cport))); | |
| 3117 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == | |
| 3118 NULL) { | |
| 3119 /* invalid address */ | |
| 3120 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3121 sata_device.satadev_addr.cport))); | |
| 3122 return (0); | |
| 3123 } | |
| 3124 | |
| 3125 switch (scsi_hba_lookup_capstr(cap)) { | |
| 3126 case SCSI_CAP_ARQ: | |
| 3127 rval = 1; /* ARQ supported, turned on */ | |
| 3128 break; | |
| 3129 | |
| 3130 case SCSI_CAP_SECTOR_SIZE: | |
| 3131 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) | |
| 3132 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ | |
| 3133 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) | |
| 3134 rval = SATA_ATAPI_SECTOR_SIZE; | |
| 3135 else rval = -1; | |
| 3136 break; | |
| 3137 | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3138 /* |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3139 * 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
|
3140 * 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
|
3141 * use it when available. |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3142 */ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3143 #if defined(_UNTAGGED_QING_SUPPORTED) |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3144 case SCSI_CAP_UNTAGGED_QING: |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3145 if (SATA_QDEPTH(sata_hba_inst) > 1) |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3146 rval = 1; /* Untagged queuing supported */ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3147 else |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3148 rval = -1; /* Untagged queuing not supported */ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3149 break; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3150 #endif |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3151 |
| 1258 | 3152 case SCSI_CAP_TAGGED_QING: |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3153 /* This can TCQ or NCQ */ |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3154 if (sata_func_enable & SATA_ENABLE_QUEUING && |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3155 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3156 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3157 (sata_func_enable & SATA_ENABLE_NCQ && |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3158 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3159 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ))) |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3160 rval = 1; /* Tagged queuing supported */ |
| 1258 | 3161 else |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3162 rval = -1; /* Tagged queuing not supported */ |
| 1258 | 3163 break; |
| 3164 | |
| 3165 case SCSI_CAP_DMA_MAX: | |
| 3166 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), | |
| 3167 &adj_dma_attr); | |
| 3168 rval = (int)adj_dma_attr.dma_attr_maxxfer; | |
| 3169 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ | |
| 3170 break; | |
| 3171 | |
| 3172 case SCSI_CAP_INTERCONNECT_TYPE: | |
| 3173 rval = INTERCONNECT_SATA; /* SATA interconnect type */ | |
| 3174 break; | |
| 3175 | |
| 3176 default: | |
| 3177 rval = -1; | |
| 3178 break; | |
| 3179 } | |
| 3180 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3181 sata_device.satadev_addr.cport))); | |
| 3182 return (rval); | |
| 3183 } | |
| 3184 | |
| 3185 /* | |
| 3186 * Implementation of scsi tran_setcap | |
| 3187 * | |
| 3188 * All supported capabilities are fixed/unchangeable. | |
| 3189 * Returns 0 for all supported capabilities and valid device, -1 otherwise. | |
| 3190 */ | |
| 3191 static int | |
| 3192 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) | |
| 3193 { | |
| 3194 #ifndef __lock_lint | |
| 3195 _NOTE(ARGUNUSED(value)) | |
| 3196 #endif | |
| 3197 sata_hba_inst_t *sata_hba_inst = | |
| 3198 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3199 sata_device_t sata_device; | |
| 3200 int rval; | |
| 3201 | |
| 3202 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3203 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); | |
| 3204 | |
| 3205 /* | |
| 3206 * We want to process the capabilities on per port granularity. | |
| 3207 * So, we are specifically restricting ourselves to whom != 0 | |
| 3208 * to exclude the controller wide handling. | |
| 3209 */ | |
| 3210 if (cap == NULL || whom == 0) { | |
| 3211 return (-1); | |
| 3212 } | |
| 3213 | |
| 3214 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { | |
| 3215 /* Invalid address */ | |
| 3216 return (-1); | |
| 3217 } | |
| 3218 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3219 sata_device.satadev_addr.cport))); | |
| 3220 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 3221 /* invalid address */ | |
| 3222 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3223 sata_device.satadev_addr.cport))); | |
| 3224 return (0); | |
| 3225 } | |
| 3226 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3227 sata_device.satadev_addr.cport))); | |
| 3228 | |
| 3229 switch (scsi_hba_lookup_capstr(cap)) { | |
| 3230 case SCSI_CAP_ARQ: | |
| 3231 case SCSI_CAP_SECTOR_SIZE: | |
| 3232 case SCSI_CAP_TAGGED_QING: | |
| 3233 case SCSI_CAP_DMA_MAX: | |
| 3234 case SCSI_CAP_INTERCONNECT_TYPE: | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3235 #if defined(_UNTAGGED_QING_SUPPORTED) |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3236 case SCSI_CAP_UNTAGGED_QING: |
| 1258 | 3237 rval = 0; /* Capability cannot be changed */ |
| 3238 break; | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
3239 #endif |
| 1258 | 3240 |
| 3241 default: | |
| 3242 rval = -1; | |
| 3243 break; | |
| 3244 } | |
| 3245 return (rval); | |
| 3246 } | |
| 3247 | |
| 3248 /* | |
| 3249 * Implementations of scsi tran_destroy_pkt. | |
| 3250 * Free resources allocated by sata_scsi_init_pkt() | |
| 3251 */ | |
| 3252 static void | |
| 3253 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3254 { | |
| 3255 sata_pkt_txlate_t *spx; | |
| 3256 | |
| 3257 ASSERT(pkt != NULL); | |
| 3258 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 3259 | |
| 3260 if (spx->txlt_buf_dma_handle != NULL) { | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3261 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3262 ASSERT(spx->txlt_tmp_buf_handle != 0); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3263 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3264 * Intermediate DMA buffer was allocated. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3265 * Free allocated buffer and associated access handle. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3266 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3267 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3268 spx->txlt_tmp_buf = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3269 } |
| 1258 | 3270 /* |
| 3271 * Free DMA resources - cookies and handles | |
| 3272 */ | |
| 3273 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
| 3274 (void) kmem_free(spx->txlt_dma_cookie_list, | |
| 3275 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); | |
| 3276 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); | |
| 3277 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 3278 } | |
| 3279 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 3280 sata_pkt_free(spx); | |
| 3281 | |
| 3282 scsi_hba_pkt_free(ap, pkt); | |
| 3283 } | |
| 3284 | |
| 3285 /* | |
| 3286 * Implementation of scsi tran_dmafree. | |
| 3287 * Free DMA resources allocated by sata_scsi_init_pkt() | |
| 3288 */ | |
| 3289 | |
| 3290 static void | |
| 3291 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3292 { | |
| 3293 #ifndef __lock_lint | |
| 3294 _NOTE(ARGUNUSED(ap)) | |
| 3295 #endif | |
| 3296 sata_pkt_txlate_t *spx; | |
| 3297 | |
| 3298 ASSERT(pkt != NULL); | |
| 3299 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 3300 | |
| 3301 if (spx->txlt_buf_dma_handle != NULL) { | |
| 3302 /* | |
| 3303 * Free DMA resources - cookies and handles | |
| 3304 */ | |
| 3305 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
| 3306 (void) kmem_free(spx->txlt_dma_cookie_list, | |
| 3307 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); | |
| 3308 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); | |
| 3309 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 3310 } | |
| 3311 } | |
| 3312 | |
| 3313 /* | |
| 3314 * Implementation of scsi tran_sync_pkt. | |
| 3315 * | |
| 3316 * 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
|
3317 * |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3318 * 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
|
3319 * into/from the real buffer. |
| 1258 | 3320 */ |
| 3321 static void | |
| 3322 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3323 { | |
| 3324 #ifndef __lock_lint | |
| 3325 _NOTE(ARGUNUSED(ap)) | |
| 3326 #endif | |
| 3327 int rval; | |
| 3328 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
|
3329 struct buf *bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3330 int direction; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3331 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3332 ASSERT(spx != NULL); |
| 1258 | 3333 if (spx->txlt_buf_dma_handle != NULL) { |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3334 direction = spx->txlt_sata_pkt-> |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3335 satapkt_cmd.satacmd_flags.sata_data_direction; |
| 1258 | 3336 if (spx->txlt_sata_pkt != NULL && |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3337 direction != SATA_DIR_NODATA_XFER) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3338 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3339 /* Intermediate DMA buffer used */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3340 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3341 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3342 if (direction & SATA_DIR_WRITE) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3343 bcopy(bp->b_un.b_addr, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3344 spx->txlt_tmp_buf, bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3345 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3346 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3347 /* Sync the buffer for device or for CPU */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3348 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
|
3349 (direction & SATA_DIR_WRITE) ? |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3350 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3351 ASSERT(rval == DDI_SUCCESS); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3352 if (spx->txlt_tmp_buf != NULL && |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3353 !(direction & SATA_DIR_WRITE)) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3354 /* Intermediate DMA buffer used for read */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3355 bcopy(spx->txlt_tmp_buf, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3356 bp->b_un.b_addr, bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3357 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
3358 |
| 1258 | 3359 } |
| 3360 } | |
| 3361 } | |
| 3362 | |
| 3363 | |
| 3364 | |
| 3365 /* ******************* SATA - SCSI Translation functions **************** */ | |
| 3366 /* | |
| 3367 * SCSI to SATA pkt and command translation and SATA to SCSI status/error | |
| 3368 * translation. | |
| 3369 */ | |
| 3370 | |
| 3371 /* | |
| 3372 * Checks if a device exists and can be access and translates common | |
| 3373 * scsi_pkt data to sata_pkt data. | |
| 3374 * | |
| 3375 * Returns TRAN_ACCEPT if device exists and sata_pkt was set-up. | |
| 3376 * Returns other TRAN_XXXXX values when error occured. | |
| 3377 * | |
| 3378 * This function should be called with port mutex held. | |
| 3379 */ | |
| 3380 static int | |
| 3381 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx) | |
| 3382 { | |
| 3383 sata_drive_info_t *sdinfo; | |
| 3384 sata_device_t sata_device; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3385 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
|
3386 SATA_DIR_NODATA_XFER, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3387 /* all other values to 0/FALSE */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3388 }; |
| 1258 | 3389 |
| 3390 /* Validate address */ | |
| 3391 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, | |
| 3392 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { | |
| 3393 | |
| 3394 case -1: | |
| 3395 /* Invalid address or invalid device type */ | |
| 3396 return (TRAN_BADPKT); | |
| 3397 case 1: | |
| 3398 /* valid address but no device - it has disappeared ? */ | |
| 3399 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; | |
| 3400 return (TRAN_FATAL_ERROR); | |
| 3401 default: | |
| 3402 /* all OK */ | |
| 3403 break; | |
| 3404 } | |
| 3405 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 3406 &spx->txlt_sata_pkt->satapkt_device); | |
| 3407 | |
| 3408 /* | |
| 3409 * If device is in reset condition, reject the packet with | |
| 3410 * TRAN_BUSY | |
| 3411 */ | |
| 3412 if (sdinfo->satadrv_event_flags & | |
| 3413 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { | |
| 3414 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 3415 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3416 "sata_scsi_start: rejecting command because " | |
| 3417 "of device reset state\n", NULL); | |
| 3418 return (TRAN_BUSY); | |
| 3419 } | |
| 3420 | |
| 3421 /* | |
| 3422 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by | |
| 3423 * sata_scsi_pkt_init() because pkt init had to work also with | |
| 3424 * non-existing devices. | |
| 3425 * Now we know that the packet was set-up for a real device, so its | |
| 3426 * type is known. | |
| 3427 */ | |
| 3428 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; | |
| 3429 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3430 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; |
| 1258 | 3431 |
| 3432 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; | |
| 3433 | |
| 3434 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { | |
| 3435 /* Synchronous execution */ | |
| 3436 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | | |
| 3437 SATA_OPMODE_POLLING; | |
| 3438 } else { | |
| 3439 /* Asynchronous execution */ | |
| 3440 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | | |
| 3441 SATA_OPMODE_INTERRUPTS; | |
| 3442 } | |
| 3443 /* Convert queuing information */ | |
| 3444 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
|
3445 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
|
3446 B_TRUE; |
| 1258 | 3447 else if (spx->txlt_scsi_pkt->pkt_flags & |
| 3448 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3449 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
|
3450 B_TRUE; |
| 1258 | 3451 |
| 3452 /* Always limit pkt time */ | |
| 3453 if (spx->txlt_scsi_pkt->pkt_time == 0) | |
| 3454 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; | |
| 3455 else | |
| 3456 /* Pass on scsi_pkt time */ | |
| 3457 spx->txlt_sata_pkt->satapkt_time = | |
| 3458 spx->txlt_scsi_pkt->pkt_time; | |
| 3459 | |
| 3460 return (TRAN_ACCEPT); | |
| 3461 } | |
| 3462 | |
| 3463 | |
| 3464 /* | |
| 3465 * Translate ATA(ATAPI) Identify (Packet) Device data to SCSI Inquiry data. | |
| 3466 * SATA Identify Device data has to be valid in sata_rive_info. | |
| 3467 * Buffer has to accomodate the inquiry length (36 bytes). | |
| 3468 * | |
| 3469 * This function should be called with a port mutex held. | |
| 3470 */ | |
| 3471 static void | |
| 3472 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, | |
| 3473 sata_drive_info_t *sdinfo, uint8_t *buf) | |
| 3474 { | |
| 3475 | |
| 3476 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; | |
| 3477 struct sata_id *sid = &sdinfo->satadrv_id; | |
| 3478 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3479 /* Start with a nice clean slate */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3480 bzero((void *)inq, sizeof (struct scsi_inquiry)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3481 |
| 1258 | 3482 /* Rely on the dev_type for setting paripheral qualifier */ |
| 3483 /* Does DTYPE_RODIRECT apply to CD/DVD R/W devices ? */ | |
| 3484 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 3485 DTYPE_DIRECT : DTYPE_RODIRECT; | |
| 3486 | |
| 3487 inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0; | |
| 3488 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ | |
| 3489 inq->inq_iso = 0; /* ISO version */ | |
| 3490 inq->inq_ecma = 0; /* ECMA version */ | |
| 3491 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ | |
| 3492 inq->inq_aenc = 0; /* Async event notification cap. */ | |
| 3493 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg ??? */ | |
| 3494 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ | |
| 3495 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ | |
| 3496 inq->inq_len = 31; /* Additional length */ | |
| 3497 inq->inq_dualp = 0; /* dual port device - NO */ | |
| 3498 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ | |
| 3499 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ | |
| 3500 inq->inq_linked = 0; /* Supports linked commands - NO */ | |
| 3501 /* | |
| 3502 * Queuing support - controller has to | |
| 3503 * support some sort of command queuing. | |
| 3504 */ | |
| 3505 if (SATA_QDEPTH(sata_hba_inst) > 1) | |
| 3506 inq->inq_cmdque = 1; /* Supports command queueing - YES */ | |
| 3507 else | |
| 3508 inq->inq_cmdque = 0; /* Supports command queueing - NO */ | |
| 3509 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ | |
| 3510 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ | |
| 3511 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ | |
| 3512 | |
| 3513 #ifdef _LITTLE_ENDIAN | |
| 3514 /* Swap text fields to match SCSI format */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3515 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3516 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
|
3517 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3518 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
|
3519 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3520 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ |
| 1258 | 3521 #else |
| 3522 bcopy(sid->ai_model, inq->inq_vid, 8); /* Vendor ID */ | |
| 3523 bcopy(&sid->ai_model[8], inq->inq_pid, 16); /* Product ID */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3524 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3525 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
|
3526 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3527 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ |
| 1258 | 3528 #endif |
| 3529 } | |
| 3530 | |
| 3531 | |
| 3532 /* | |
| 3533 * Scsi response set up for invalid command (command not supported) | |
| 3534 * | |
| 3535 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3536 */ | |
| 3537 static int | |
| 3538 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) | |
| 3539 { | |
| 3540 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3541 struct scsi_extended_sense *sense; | |
| 3542 | |
| 3543 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3544 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3545 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3546 | |
| 3547 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3548 | |
| 3549 sense = sata_arq_sense(spx); | |
| 3550 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3551 sense->es_add_code = SD_SCSI_INVALID_COMMAND_CODE; | |
| 3552 | |
| 3553 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3554 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3555 | |
| 3556 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3557 scsipkt->pkt_comp != NULL) | |
| 3558 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3559 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3560 (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
|
3561 (void *)spx->txlt_scsi_pkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3562 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3563 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3564 return (TRAN_BUSY); |
| 1258 | 3565 return (TRAN_ACCEPT); |
| 3566 } | |
| 3567 | |
| 3568 /* | |
| 3569 * Scsi response setup for | |
| 3570 * emulated non-data command that requires no action/return data | |
| 3571 * | |
| 3572 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3573 */ | |
| 3574 static int | |
| 3575 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) | |
| 3576 { | |
| 3577 int rval; | |
| 3578 | |
| 3579 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3580 | |
| 3581 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3582 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3583 return (rval); | |
| 3584 } | |
| 3585 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3586 | |
| 3587 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3588 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3589 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; | |
| 3590 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; | |
| 3591 | |
| 3592 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3593 "Scsi_pkt completion reason %x\n", | |
| 3594 spx->txlt_scsi_pkt->pkt_reason); | |
| 3595 | |
| 3596 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3597 spx->txlt_scsi_pkt->pkt_comp != NULL) | |
| 3598 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3599 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3600 (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
|
3601 (void *)spx->txlt_scsi_pkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3602 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3603 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3604 return (TRAN_BUSY); |
| 1258 | 3605 return (TRAN_ACCEPT); |
| 3606 } | |
| 3607 | |
| 3608 | |
| 3609 /* | |
| 3610 * SATA translate command: Inquiry / Identify Device | |
| 3611 * Use cached Identify Device data for now, rather then issuing actual | |
| 3612 * Device Identify cmd request. If device is detached and re-attached, | |
| 3613 * asynchromous event processing should fetch and refresh Identify Device | |
| 3614 * data. | |
| 3615 * Two VPD pages are supported now: | |
| 3616 * Vital Product Data page | |
| 3617 * Unit Serial Number page | |
| 3618 * | |
| 3619 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3620 */ | |
| 3621 | |
| 3622 #define EVPD 1 /* Extended Vital Product Data flag */ | |
| 3623 #define CMDDT 2 /* Command Support Data - Obsolete */ | |
| 3624 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ | |
| 3625 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ | |
| 3626 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ | |
| 3627 | |
| 3628 static int | |
| 3629 sata_txlt_inquiry(sata_pkt_txlate_t *spx) | |
| 3630 { | |
| 3631 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3632 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 3633 sata_drive_info_t *sdinfo; | |
| 3634 struct scsi_extended_sense *sense; | |
| 3635 int count; | |
| 3636 uint8_t *p; | |
| 3637 int i, j; | |
| 3638 uint8_t page_buf[0xff]; /* Max length */ | |
| 3639 int rval; | |
| 3640 | |
| 3641 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3642 | |
| 3643 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3644 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3645 return (rval); | |
| 3646 } | |
| 3647 | |
| 3648 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 3649 &spx->txlt_sata_pkt->satapkt_device); | |
| 3650 | |
| 3651 ASSERT(sdinfo != NULL); | |
| 3652 | |
| 3653 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3654 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3655 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3656 | |
| 3657 /* Reject not supported request */ | |
| 3658 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ | |
| 3659 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3660 sense = sata_arq_sense(spx); | |
| 3661 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3662 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3663 goto done; | |
| 3664 } | |
| 3665 | |
| 3666 /* Valid Inquiry request */ | |
| 3667 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3668 | |
| 3669 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 3670 | |
| 3671 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { | |
| 3672 /* Standard Inquiry Data request */ | |
| 3673 struct scsi_inquiry inq; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3674 unsigned int bufsize; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3675 |
| 1258 | 3676 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, |
| 3677 sdinfo, (uint8_t *)&inq); | |
| 3678 /* Copy no more than requested */ | |
| 3679 count = MIN(bp->b_bcount, | |
| 3680 sizeof (struct scsi_inquiry)); | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3681 bufsize = scsipkt->pkt_cdbp[4]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3682 bufsize |= scsipkt->pkt_cdbp[3] << 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3683 count = MIN(count, bufsize); |
| 1258 | 3684 bcopy(&inq, bp->b_un.b_addr, count); |
| 3685 | |
| 3686 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3687 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
|
3688 bufsize - count : 0; |
| 1258 | 3689 } else { |
| 3690 /* | |
| 3691 * peripheral_qualifier = 0; | |
| 3692 * | |
| 3693 * We are dealing only with HD and will be | |
| 3694 * dealing with CD/DVD devices soon | |
| 3695 */ | |
| 3696 uint8_t peripheral_device_type = | |
| 3697 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 3698 DTYPE_DIRECT : DTYPE_RODIRECT; | |
| 3699 | |
| 3700 switch ((uint_t)scsipkt->pkt_cdbp[2]) { | |
| 3701 case INQUIRY_SUP_VPD_PAGE: | |
| 3702 /* | |
| 3703 * Request for suported Vital Product Data | |
| 3704 * pages - assuming only 2 page codes | |
| 3705 * supported | |
| 3706 */ | |
| 3707 page_buf[0] = peripheral_device_type; | |
| 3708 page_buf[1] = INQUIRY_SUP_VPD_PAGE; | |
| 3709 page_buf[2] = 0; | |
| 3710 page_buf[3] = 2; /* page length */ | |
| 3711 page_buf[4] = INQUIRY_SUP_VPD_PAGE; | |
| 3712 page_buf[5] = INQUIRY_USN_PAGE; | |
| 3713 /* Copy no more than requested */ | |
| 3714 count = MIN(bp->b_bcount, 6); | |
| 3715 bcopy(page_buf, bp->b_un.b_addr, count); | |
| 3716 break; | |
| 3717 case INQUIRY_USN_PAGE: | |
| 3718 /* | |
| 3719 * Request for Unit Serial Number page | |
| 3720 */ | |
| 3721 page_buf[0] = peripheral_device_type; | |
| 3722 page_buf[1] = INQUIRY_USN_PAGE; | |
| 3723 page_buf[2] = 0; | |
| 3724 page_buf[3] = 20; /* remaining page length */ | |
| 3725 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); | |
| 3726 #ifdef _LITTLE_ENDIAN | |
| 3727 swab(p, &page_buf[4], 20); | |
| 3728 #else | |
| 3729 bcopy(p, &page_buf[4], 20); | |
| 3730 #endif | |
| 3731 for (i = 0; i < 20; i++) { | |
| 3732 if (page_buf[4 + i] == '\0' || | |
| 3733 page_buf[4 + i] == '\040') { | |
| 3734 break; | |
| 3735 } | |
| 3736 } | |
| 3737 /* | |
| 3738 * 'i' contains string length. | |
| 3739 * | |
| 3740 * Least significant character of the serial | |
| 3741 * number shall appear as the last byte, | |
| 3742 * according to SBC-3 spec. | |
| 3743 */ | |
| 3744 p = &page_buf[20 + 4 - 1]; | |
| 3745 for (j = i; j > 0; j--, p--) { | |
| 3746 *p = *(p - 20 + i); | |
| 3747 } | |
| 3748 p = &page_buf[4]; | |
| 3749 for (j = 20 - i; j > 0; j--) { | |
| 3750 *p++ = '\040'; | |
| 3751 } | |
| 3752 count = MIN(bp->b_bcount, 24); | |
| 3753 bcopy(page_buf, bp->b_un.b_addr, count); | |
| 3754 break; | |
| 3755 | |
| 3756 case INQUIRY_DEV_IDENTIFICATION_PAGE: | |
| 3757 /* | |
| 3758 * We may want to implement this page, when | |
| 3759 * identifiers are common for SATA devices | |
| 3760 * But not now. | |
| 3761 */ | |
| 3762 /*FALLTHRU*/ | |
| 3763 | |
| 3764 default: | |
| 3765 /* Request for unsupported VPD page */ | |
| 3766 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3767 sense = sata_arq_sense(spx); | |
| 3768 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3769 sense->es_add_code = | |
| 3770 SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3771 goto done; | |
| 3772 } | |
| 3773 } | |
| 3774 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3775 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? | |
| 3776 scsipkt->pkt_cdbp[4] - count : 0; | |
| 3777 } | |
| 3778 done: | |
| 3779 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3780 | |
| 3781 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3782 "Scsi_pkt completion reason %x\n", | |
| 3783 scsipkt->pkt_reason); | |
| 3784 | |
| 3785 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3786 scsipkt->pkt_comp != NULL) { |
| 1258 | 3787 /* scsi callback required */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3788 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3789 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3790 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3791 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3792 return (TRAN_BUSY); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3793 } |
| 1258 | 3794 return (TRAN_ACCEPT); |
| 3795 } | |
| 3796 | |
| 3797 /* | |
| 3798 * SATA translate command: Request Sense | |
| 3799 * emulated command (ATA version so far, no ATAPI) | |
| 3800 * Always NO SENSE, because any sense data should be reported by ARQ sense. | |
| 3801 * | |
| 3802 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3803 */ | |
| 3804 static int | |
| 3805 sata_txlt_request_sense(sata_pkt_txlate_t *spx) | |
| 3806 { | |
| 3807 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3808 struct scsi_extended_sense sense; | |
| 3809 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 3810 int rval; | |
| 3811 | |
| 3812 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3813 | |
| 3814 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3815 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3816 return (rval); | |
| 3817 } | |
| 3818 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3819 | |
| 3820 | |
| 3821 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3822 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3823 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3824 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3825 | |
| 3826 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 3827 int count = MIN(bp->b_bcount, | |
| 3828 sizeof (struct scsi_extended_sense)); | |
| 3829 bzero(&sense, sizeof (struct scsi_extended_sense)); | |
| 3830 sense.es_valid = 0; /* Valid LBA */ | |
| 3831 sense.es_class = 7; /* Response code 0x70 - current err */ | |
| 3832 sense.es_key = KEY_NO_SENSE; | |
| 3833 sense.es_add_len = 6; /* Additional length */ | |
| 3834 /* Copy no more than requested */ | |
| 3835 bcopy(&sense, bp->b_un.b_addr, count); | |
| 3836 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3837 scsipkt->pkt_resid = 0; | |
| 3838 } | |
| 3839 | |
| 3840 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3841 "Scsi_pkt completion reason %x\n", | |
| 3842 scsipkt->pkt_reason); | |
| 3843 | |
| 3844 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3845 scsipkt->pkt_comp != NULL) | |
| 3846 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3847 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3848 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3849 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3850 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3851 return (TRAN_BUSY); |
| 1258 | 3852 return (TRAN_ACCEPT); |
| 3853 } | |
| 3854 | |
| 3855 /* | |
| 3856 * SATA translate command: Test Unit Ready | |
| 3857 * At the moment this is an emulated command (ATA version so far, no ATAPI). | |
| 3858 * May be translated into Check Power Mode command in the future | |
| 3859 * | |
| 3860 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3861 */ | |
| 3862 static int | |
| 3863 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) | |
| 3864 { | |
| 3865 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3866 struct scsi_extended_sense *sense; | |
| 3867 int power_state; | |
| 3868 int rval; | |
| 3869 | |
| 3870 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3871 | |
| 3872 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3873 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3874 return (rval); | |
| 3875 } | |
| 3876 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3877 | |
| 3878 /* At this moment, emulate it rather than execute anything */ | |
| 3879 power_state = SATA_PWRMODE_ACTIVE; | |
| 3880 | |
| 3881 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3882 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3883 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3884 | |
| 3885 switch (power_state) { | |
| 3886 case SATA_PWRMODE_ACTIVE: | |
| 3887 case SATA_PWRMODE_IDLE: | |
| 3888 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3889 break; | |
| 3890 default: | |
| 3891 /* PWR mode standby */ | |
| 3892 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3893 sense = sata_arq_sense(spx); | |
| 3894 sense->es_key = KEY_NOT_READY; | |
| 3895 sense->es_add_code = SD_SCSI_LU_NOT_READY; | |
| 3896 break; | |
| 3897 } | |
| 3898 | |
| 3899 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3900 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3901 | |
| 3902 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3903 scsipkt->pkt_comp != NULL) | |
| 3904 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3905 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3906 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3907 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3908 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3909 return (TRAN_BUSY); |
| 1258 | 3910 |
| 3911 return (TRAN_ACCEPT); | |
| 3912 } | |
| 3913 | |
| 3914 | |
| 3915 /* | |
| 3916 * SATA translate command: Start Stop Unit | |
| 3917 * Translation depends on a command: | |
| 3918 * Start Unit translated into Idle Immediate | |
| 3919 * Stop Unit translated into Standby Immediate | |
| 3920 * Unload Media / NOT SUPPORTED YET | |
| 3921 * Load Media / NOT SUPPROTED YET | |
| 3922 * Power condition bits are ignored, so is Immediate bit | |
| 3923 * Requesting synchronous execution. | |
| 3924 * | |
| 3925 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 3926 * appropriate values in scsi_pkt fields. | |
| 3927 */ | |
| 3928 static int | |
| 3929 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) | |
| 3930 { | |
| 3931 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3932 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 3933 struct scsi_extended_sense *sense; | |
| 3934 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 3935 int cport = SATA_TXLT_CPORT(spx); | |
| 3936 int rval; | |
| 3937 int synch; | |
| 3938 | |
| 3939 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3940 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); | |
| 3941 | |
| 3942 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); | |
| 3943 | |
| 3944 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3945 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3946 return (rval); | |
| 3947 } | |
| 3948 | |
| 3949 if (scsipkt->pkt_cdbp[4] & 2) { | |
| 3950 /* Load/Unload Media - invalid request */ | |
| 3951 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3952 sense = sata_arq_sense(spx); | |
| 3953 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3954 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3955 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3956 | |
| 3957 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3958 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3959 | |
| 3960 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3961 scsipkt->pkt_comp != NULL) | |
| 3962 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3963 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3964 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3965 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3966 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3967 return (TRAN_BUSY); |
| 1258 | 3968 |
| 3969 return (TRAN_ACCEPT); | |
| 3970 } | |
| 3971 scmd->satacmd_addr_type = 0; | |
| 3972 scmd->satacmd_sec_count_lsb = 0; | |
| 3973 scmd->satacmd_lba_low_lsb = 0; | |
| 3974 scmd->satacmd_lba_mid_lsb = 0; | |
| 3975 scmd->satacmd_lba_high_lsb = 0; | |
| 3976 scmd->satacmd_features_reg = 0; | |
| 3977 scmd->satacmd_device_reg = 0; | |
| 3978 scmd->satacmd_status_reg = 0; | |
| 3979 if (scsipkt->pkt_cdbp[4] & 1) { | |
| 3980 /* Start Unit */ | |
| 3981 scmd->satacmd_cmd_reg = SATAC_IDLE_IM; | |
| 3982 } else { | |
| 3983 /* Stop Unit */ | |
| 3984 scmd->satacmd_cmd_reg = SATAC_STANDBY_IM; | |
| 3985 } | |
| 3986 | |
| 3987 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 3988 /* Need to set-up a callback function */ | |
| 3989 spx->txlt_sata_pkt->satapkt_comp = | |
| 3990 sata_txlt_nodata_cmd_completion; | |
| 3991 synch = FALSE; | |
| 3992 } else { | |
| 3993 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; | |
| 3994 synch = TRUE; | |
| 3995 } | |
| 3996 | |
| 3997 /* Transfer command to HBA */ | |
| 3998 if (sata_hba_start(spx, &rval) != 0) { | |
| 3999 /* Pkt not accepted for execution */ | |
| 4000 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 4001 return (rval); | |
| 4002 } | |
| 4003 | |
| 4004 /* | |
| 4005 * If execution is non-synchronous, | |
| 4006 * a callback function will handle potential errors, translate | |
| 4007 * the response and will do a callback to a target driver. | |
| 4008 * If it was synchronous, check execution status using the same | |
| 4009 * framework callback. | |
| 4010 */ | |
| 4011 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 4012 if (synch) { | |
| 4013 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4014 "synchronous execution status %x\n", | |
| 4015 spx->txlt_sata_pkt->satapkt_reason); | |
| 4016 | |
| 4017 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); | |
| 4018 } | |
| 4019 return (TRAN_ACCEPT); | |
| 4020 | |
| 4021 } | |
| 4022 | |
| 4023 | |
| 4024 /* | |
| 4025 * SATA translate command: Read Capacity. | |
| 4026 * Emulated command for SATA disks. | |
| 4027 * Capacity is retrieved from cached Idenifty Device data. | |
| 4028 * Identify Device data shows effective disk capacity, not the native | |
| 4029 * capacity, which may be limitted by Set Max Address command. | |
| 4030 * This is ATA version (non-ATAPI). | |
| 4031 * | |
| 4032 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4033 */ | |
| 4034 static int | |
| 4035 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) | |
| 4036 { | |
| 4037 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4038 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4039 sata_drive_info_t *sdinfo; | |
| 4040 uint64_t val; | |
| 4041 uchar_t *rbuf; | |
| 4042 int rval; | |
| 4043 | |
| 4044 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4045 "sata_txlt_read_capacity: ", NULL); | |
| 4046 | |
| 4047 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4048 | |
| 4049 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4050 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4051 return (rval); | |
| 4052 } | |
| 4053 | |
| 4054 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4055 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4056 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4057 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 4058 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 4059 sdinfo = sata_get_device_info( | |
| 4060 spx->txlt_sata_hba_inst, | |
| 4061 &spx->txlt_sata_pkt->satapkt_device); | |
| 4062 /* Last logical block address */ | |
| 4063 val = sdinfo->satadrv_capacity - 1; | |
| 4064 rbuf = (uchar_t *)bp->b_un.b_addr; | |
| 4065 /* Need to swap endians to match scsi format */ | |
| 4066 rbuf[0] = (val >> 24) & 0xff; | |
| 4067 rbuf[1] = (val >> 16) & 0xff; | |
| 4068 rbuf[2] = (val >> 8) & 0xff; | |
| 4069 rbuf[3] = val & 0xff; | |
| 4070 /* block size - always 512 bytes, for now */ | |
| 4071 rbuf[4] = 0; | |
| 4072 rbuf[5] = 0; | |
| 4073 rbuf[6] = 0x02; | |
| 4074 rbuf[7] = 0; | |
| 4075 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4076 scsipkt->pkt_resid = 0; | |
| 4077 | |
| 4078 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", | |
| 4079 sdinfo->satadrv_capacity -1); | |
| 4080 } | |
| 4081 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4082 /* | |
| 4083 * If a callback was requested, do it now. | |
| 4084 */ | |
| 4085 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4086 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4087 | |
| 4088 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4089 scsipkt->pkt_comp != NULL) | |
| 4090 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4091 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4092 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4093 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4094 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4095 return (TRAN_BUSY); |
| 1258 | 4096 |
| 4097 return (TRAN_ACCEPT); | |
| 4098 } | |
| 4099 | |
| 4100 /* | |
| 4101 * SATA translate command: Mode Sense. | |
| 4102 * Translated into appropriate SATA command or emulated. | |
| 4103 * Saved Values Page Control (03) are not supported. | |
| 4104 * | |
| 4105 * NOTE: only caching mode sense page is currently implemented. | |
| 4106 * | |
| 4107 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4108 */ | |
| 4109 | |
| 4110 static int | |
| 4111 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) | |
| 4112 { | |
| 4113 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4114 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4115 sata_drive_info_t *sdinfo; | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4116 sata_id_t *sata_id; |
| 1258 | 4117 struct scsi_extended_sense *sense; |
| 4118 int len, bdlen, count, alc_len; | |
| 4119 int pc; /* Page Control code */ | |
| 4120 uint8_t *buf; /* mode sense buffer */ | |
| 4121 int rval; | |
| 4122 | |
| 4123 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4124 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", | |
| 4125 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, | |
| 4126 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4127 | |
| 4128 buf = kmem_zalloc(1024, KM_SLEEP); | |
| 4129 | |
| 4130 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4131 | |
| 4132 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4133 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4134 kmem_free(buf, 1024); | |
| 4135 return (rval); | |
| 4136 } | |
| 4137 | |
| 4138 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4139 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4140 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4141 | |
| 4142 pc = scsipkt->pkt_cdbp[2] >> 6; | |
| 4143 | |
| 4144 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 4145 len = 0; | |
| 4146 bdlen = 0; | |
| 4147 if (!(scsipkt->pkt_cdbp[1] & 8)) { | |
| 4148 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && | |
| 4149 (scsipkt->pkt_cdbp[0] & 0x10)) | |
| 4150 bdlen = 16; | |
| 4151 else | |
| 4152 bdlen = 8; | |
| 4153 } | |
| 4154 /* Build mode parameter header */ | |
| 4155 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4156 /* 4-byte mode parameter header */ | |
| 4157 buf[len++] = 0; /* mode data length */ | |
| 4158 buf[len++] = 0; /* medium type */ | |
| 4159 buf[len++] = 0; /* dev-specific param */ | |
| 4160 buf[len++] = bdlen; /* Block Descriptor length */ | |
| 4161 } else { | |
| 4162 /* 8-byte mode parameter header */ | |
| 4163 buf[len++] = 0; /* mode data length */ | |
| 4164 buf[len++] = 0; | |
| 4165 buf[len++] = 0; /* medium type */ | |
| 4166 buf[len++] = 0; /* dev-specific param */ | |
| 4167 if (bdlen == 16) | |
| 4168 buf[len++] = 1; /* long lba descriptor */ | |
| 4169 else | |
| 4170 buf[len++] = 0; | |
| 4171 buf[len++] = 0; | |
| 4172 buf[len++] = 0; /* Block Descriptor length */ | |
| 4173 buf[len++] = bdlen; | |
| 4174 } | |
| 4175 | |
| 4176 sdinfo = sata_get_device_info( | |
| 4177 spx->txlt_sata_hba_inst, | |
| 4178 &spx->txlt_sata_pkt->satapkt_device); | |
| 4179 | |
| 4180 /* Build block descriptor only if not disabled (DBD) */ | |
| 4181 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { | |
| 4182 /* Block descriptor - direct-access device format */ | |
| 4183 if (bdlen == 8) { | |
| 4184 /* build regular block descriptor */ | |
| 4185 buf[len++] = | |
| 4186 (sdinfo->satadrv_capacity >> 24) & 0xff; | |
| 4187 buf[len++] = | |
| 4188 (sdinfo->satadrv_capacity >> 16) & 0xff; | |
| 4189 buf[len++] = | |
| 4190 (sdinfo->satadrv_capacity >> 8) & 0xff; | |
| 4191 buf[len++] = sdinfo->satadrv_capacity & 0xff; | |
| 4192 buf[len++] = 0; /* density code */ | |
| 4193 buf[len++] = 0; | |
| 4194 if (sdinfo->satadrv_type == | |
| 4195 SATA_DTYPE_ATADISK) | |
| 4196 buf[len++] = 2; | |
| 4197 else | |
| 4198 /* ATAPI */ | |
| 4199 buf[len++] = 8; | |
| 4200 buf[len++] = 0; | |
| 4201 } else if (bdlen == 16) { | |
| 4202 /* Long LBA Accepted */ | |
| 4203 /* build long lba block descriptor */ | |
| 4204 #ifndef __lock_lint | |
| 4205 buf[len++] = | |
| 4206 (sdinfo->satadrv_capacity >> 56) & 0xff; | |
| 4207 buf[len++] = | |
| 4208 (sdinfo->satadrv_capacity >> 48) & 0xff; | |
| 4209 buf[len++] = | |
| 4210 (sdinfo->satadrv_capacity >> 40) & 0xff; | |
| 4211 buf[len++] = | |
| 4212 (sdinfo->satadrv_capacity >> 32) & 0xff; | |
| 4213 #endif | |
| 4214 buf[len++] = | |
| 4215 (sdinfo->satadrv_capacity >> 24) & 0xff; | |
| 4216 buf[len++] = | |
| 4217 (sdinfo->satadrv_capacity >> 16) & 0xff; | |
| 4218 buf[len++] = | |
| 4219 (sdinfo->satadrv_capacity >> 8) & 0xff; | |
| 4220 buf[len++] = sdinfo->satadrv_capacity & 0xff; | |
| 4221 buf[len++] = 0; | |
| 4222 buf[len++] = 0; /* density code */ | |
| 4223 buf[len++] = 0; | |
| 4224 buf[len++] = 0; | |
| 4225 if (sdinfo->satadrv_type == | |
| 4226 SATA_DTYPE_ATADISK) | |
| 4227 buf[len++] = 2; | |
| 4228 else | |
| 4229 /* ATAPI */ | |
| 4230 buf[len++] = 8; | |
| 4231 buf[len++] = 0; | |
| 4232 } | |
| 4233 } | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4234 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4235 sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4236 |
| 1258 | 4237 /* |
| 4238 * Add requested pages. | |
| 4239 * Page 3 and 4 are obsolete and we are not supporting them. | |
| 4240 * We deal now with: | |
| 4241 * caching (read/write cache control). | |
| 4242 * We should eventually deal with following mode pages: | |
| 4243 * error recovery (0x01), | |
| 4244 * power condition (0x1a), | |
| 4245 * exception control page (enables SMART) (0x1c), | |
| 4246 * enclosure management (ses), | |
| 4247 * protocol-specific port mode (port control). | |
| 4248 */ | |
| 4249 switch (scsipkt->pkt_cdbp[2] & 0x3f) { | |
| 4250 case MODEPAGE_RW_ERRRECOV: | |
| 4251 /* DAD_MODE_ERR_RECOV */ | |
| 4252 /* R/W recovery */ | |
| 4253 len += sata_build_msense_page_1(sdinfo, pc, buf+len); | |
| 4254 break; | |
| 4255 case MODEPAGE_CACHING: | |
| 4256 /* DAD_MODE_CACHE */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4257 /* Reject not supported request for saved parameters */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4258 if (pc == 3) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4259 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4260 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4261 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4262 sense->es_add_code = |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4263 SD_SCSI_SAVING_PARAMS_NOT_SUP; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4264 goto done; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4265 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4266 |
| 1258 | 4267 /* caching */ |
| 4268 len += sata_build_msense_page_8(sdinfo, pc, buf+len); | |
| 4269 break; | |
| 4270 case MODEPAGE_INFO_EXCPT: | |
| 4271 /* exception cntrl */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4272 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4273 len += sata_build_msense_page_1c(sdinfo, pc, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4274 buf+len); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4275 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4276 else |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4277 goto err; |
| 1258 | 4278 break; |
| 4279 case MODEPAGE_POWER_COND: | |
| 4280 /* DAD_MODE_POWER_COND */ | |
| 4281 /* power condition */ | |
| 4282 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); | |
| 4283 break; | |
| 4284 case MODEPAGE_ALLPAGES: | |
| 4285 /* all pages */ | |
| 4286 len += sata_build_msense_page_1(sdinfo, pc, buf+len); | |
| 4287 len += sata_build_msense_page_8(sdinfo, pc, buf+len); | |
| 4288 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
|
4289 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4290 len += sata_build_msense_page_1c(sdinfo, pc, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4291 buf+len); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4292 } |
| 1258 | 4293 break; |
| 4294 default: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4295 err: |
| 1258 | 4296 /* Invalid request */ |
| 4297 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4298 sense = sata_arq_sense(spx); | |
| 4299 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4300 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 4301 goto done; | |
| 4302 } | |
| 4303 | |
| 4304 /* fix total mode data length */ | |
| 4305 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4306 /* 4-byte mode parameter header */ | |
| 4307 buf[0] = len - 1; /* mode data length */ | |
| 4308 } else { | |
| 4309 buf[0] = (len -2) >> 8; | |
| 4310 buf[1] = (len -2) & 0xff; | |
| 4311 } | |
| 4312 | |
| 4313 | |
| 4314 /* Check allocation length */ | |
| 4315 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4316 alc_len = scsipkt->pkt_cdbp[4]; | |
| 4317 } else { | |
| 4318 alc_len = scsipkt->pkt_cdbp[7]; | |
| 4319 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; | |
| 4320 } | |
| 4321 /* | |
| 4322 * We do not check for possible parameters truncation | |
| 4323 * (alc_len < len) assuming that the target driver works | |
| 4324 * correctly. Just avoiding overrun. | |
| 4325 * Copy no more than requested and possible, buffer-wise. | |
| 4326 */ | |
| 4327 count = MIN(alc_len, len); | |
| 4328 count = MIN(bp->b_bcount, count); | |
| 4329 bcopy(buf, bp->b_un.b_addr, count); | |
| 4330 | |
| 4331 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4332 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; | |
| 4333 } | |
| 4334 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 4335 done: | |
| 4336 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4337 (void) kmem_free(buf, 1024); | |
| 4338 | |
| 4339 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4340 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4341 | |
| 4342 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4343 scsipkt->pkt_comp != NULL) | |
| 4344 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4345 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4346 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4347 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4348 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4349 return (TRAN_BUSY); |
| 1258 | 4350 |
| 4351 return (TRAN_ACCEPT); | |
| 4352 } | |
| 4353 | |
| 4354 | |
| 4355 /* | |
| 4356 * SATA translate command: Mode Select. | |
| 4357 * Translated into appropriate SATA command or emulated. | |
| 4358 * Saving parameters is not supported. | |
| 4359 * Changing device capacity is not supported (although theoretically | |
| 4360 * possible by executing SET FEATURES/SET MAX ADDRESS) | |
| 4361 * | |
| 4362 * Assumption is that the target driver is working correctly. | |
| 4363 * | |
| 4364 * More than one SATA command may be executed to perform operations specified | |
| 4365 * by mode select pages. The first error terminates further execution. | |
| 4366 * Operations performed successully are not backed-up in such case. | |
| 4367 * | |
| 4368 * NOTE: only caching mode select page is implemented. | |
| 4369 * Caching setup is remembered so it could be re-stored in case of | |
| 4370 * an unexpected device reset. | |
| 4371 * | |
| 4372 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4373 */ | |
| 4374 | |
| 4375 static int | |
| 4376 sata_txlt_mode_select(sata_pkt_txlate_t *spx) | |
| 4377 { | |
| 4378 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4379 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4380 struct scsi_extended_sense *sense; | |
| 4381 int len, pagelen, count, pllen; | |
| 4382 uint8_t *buf; /* mode select buffer */ | |
| 4383 int rval, stat; | |
| 4384 uint_t nointr_flag; | |
| 4385 int dmod = 0; | |
| 4386 | |
| 4387 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4388 "sata_txlt_mode_select, pc %x page code 0x%02x\n", | |
| 4389 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, | |
| 4390 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4391 | |
| 4392 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4393 | |
| 4394 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4395 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4396 return (rval); | |
| 4397 } | |
| 4398 | |
| 4399 rval = TRAN_ACCEPT; | |
| 4400 | |
| 4401 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4402 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4403 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4404 | |
| 4405 /* Reject not supported request */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4406 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ |
| 1258 | 4407 *scsipkt->pkt_scbp = STATUS_CHECK; |
| 4408 sense = sata_arq_sense(spx); | |
| 4409 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4410 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 4411 goto done; | |
| 4412 } | |
| 4413 | |
| 4414 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { | |
| 4415 pllen = scsipkt->pkt_cdbp[4]; | |
| 4416 } else { | |
| 4417 pllen = scsipkt->pkt_cdbp[7]; | |
| 4418 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; | |
| 4419 } | |
| 4420 | |
| 4421 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ | |
| 4422 | |
| 4423 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { | |
| 4424 buf = (uint8_t *)bp->b_un.b_addr; | |
| 4425 count = MIN(bp->b_bcount, pllen); | |
| 4426 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4427 scsipkt->pkt_resid = 0; | |
| 4428 pllen = count; | |
| 4429 | |
| 4430 /* | |
| 4431 * Check the header to skip the block descriptor(s) - we | |
| 4432 * do not support setting device capacity. | |
| 4433 * Existing macros do not recognize long LBA dscriptor, | |
| 4434 * hence manual calculation. | |
| 4435 */ | |
| 4436 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { | |
| 4437 /* 6-bytes CMD, 4 bytes header */ | |
| 4438 if (count <= 4) | |
| 4439 goto done; /* header only */ | |
| 4440 len = buf[3] + 4; | |
| 4441 } else { | |
| 4442 /* 10-bytes CMD, 8 bytes header */ | |
| 4443 if (count <= 8) | |
| 4444 goto done; /* header only */ | |
| 4445 len = buf[6]; | |
| 4446 len = (len << 8) + buf[7] + 8; | |
| 4447 } | |
| 4448 if (len >= count) | |
| 4449 goto done; /* header + descriptor(s) only */ | |
| 4450 | |
| 4451 pllen -= len; /* remaining data length */ | |
| 4452 | |
| 4453 /* | |
| 4454 * We may be executing SATA command and want to execute it | |
| 4455 * in SYNCH mode, regardless of scsi_pkt setting. | |
| 4456 * Save scsi_pkt setting and indicate SYNCH mode | |
| 4457 */ | |
| 4458 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; | |
| 4459 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4460 scsipkt->pkt_comp != NULL) { | |
| 4461 scsipkt->pkt_flags |= FLAG_NOINTR; | |
| 4462 } | |
| 4463 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; | |
| 4464 | |
| 4465 /* | |
| 4466 * len is now the offset to a first mode select page | |
| 4467 * Process all pages | |
| 4468 */ | |
| 4469 while (pllen > 0) { | |
| 4470 switch ((int)buf[len]) { | |
| 4471 case MODEPAGE_CACHING: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4472 /* No support for SP (saving) */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4473 if (scsipkt->pkt_cdbp[1] & 0x01) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4474 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4475 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4476 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4477 sense->es_add_code = |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4478 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4479 goto done; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4480 } |
| 1258 | 4481 stat = sata_mode_select_page_8(spx, |
| 4482 (struct mode_cache_scsi3 *)&buf[len], | |
| 4483 pllen, &pagelen, &rval, &dmod); | |
| 4484 /* | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4485 * The pagelen value indicates the number of |
| 1258 | 4486 * parameter bytes already processed. |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4487 * The rval is the return value from |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4488 * sata_tran_start(). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4489 * The stat indicates the overall status of |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4490 * the operation(s). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4491 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4492 if (stat != SATA_SUCCESS) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4493 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4494 * Page processing did not succeed - |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4495 * all error info is already set-up, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4496 * just return |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4497 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4498 pllen = 0; /* this breaks the loop */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4499 else { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4500 len += pagelen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4501 pllen -= pagelen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4502 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4503 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4504 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4505 case MODEPAGE_INFO_EXCPT: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4506 stat = sata_mode_select_page_1c(spx, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4507 (struct mode_info_excpt_page *)&buf[len], |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4508 pllen, &pagelen, &rval, &dmod); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4509 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4510 * The pagelen value indicates the number of |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4511 * parameter bytes already processed. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4512 * The rval is the return value from |
| 1258 | 4513 * sata_tran_start(). |
| 4514 * The stat indicates the overall status of | |
| 4515 * the operation(s). | |
| 4516 */ | |
| 4517 if (stat != SATA_SUCCESS) | |
| 4518 /* | |
| 4519 * Page processing did not succeed - | |
| 4520 * all error info is already set-up, | |
| 4521 * just return | |
| 4522 */ | |
| 4523 pllen = 0; /* this breaks the loop */ | |
| 4524 else { | |
| 4525 len += pagelen; | |
| 4526 pllen -= pagelen; | |
| 4527 } | |
| 4528 break; | |
| 4529 | |
| 4530 default: | |
| 4531 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4532 sense = sata_arq_sense(spx); | |
| 4533 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4534 sense->es_add_code = | |
| 4535 SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; | |
| 4536 goto done; | |
| 4537 } | |
| 4538 } | |
| 4539 } | |
| 4540 done: | |
| 4541 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4542 /* | |
| 4543 * If device parameters were modified, fetch and store the new | |
| 4544 * Identify Device data. Since port mutex could have been released | |
| 4545 * for accessing HBA driver, we need to re-check device existence. | |
| 4546 */ | |
| 4547 if (dmod != 0) { | |
| 4548 sata_drive_info_t new_sdinfo, *sdinfo; | |
| 4549 int rv; | |
| 4550 | |
| 4551 new_sdinfo.satadrv_addr = | |
| 4552 spx->txlt_sata_pkt->satapkt_device.satadev_addr; | |
| 4553 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, | |
| 4554 &new_sdinfo); | |
| 4555 | |
| 4556 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4557 /* | |
| 4558 * Since port mutex could have been released when | |
| 4559 * accessing HBA driver, we need to re-check that the | |
| 4560 * framework still holds the device info structure. | |
| 4561 */ | |
| 4562 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 4563 &spx->txlt_sata_pkt->satapkt_device); | |
| 4564 if (sdinfo != NULL) { | |
| 4565 /* | |
| 4566 * Device still has info structure in the | |
| 4567 * sata framework. Copy newly fetched info | |
| 4568 */ | |
| 4569 if (rv == 0) { | |
| 4570 sdinfo->satadrv_id = new_sdinfo.satadrv_id; | |
| 4571 sata_save_drive_settings(sdinfo); | |
| 4572 } else { | |
| 4573 /* | |
| 4574 * Could not fetch new data - invalidate | |
| 4575 * sata_drive_info. That makes device | |
| 4576 * unusable. | |
| 4577 */ | |
| 4578 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 4579 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 4580 } | |
| 4581 } | |
| 4582 if (rv != 0 || sdinfo == NULL) { | |
| 4583 /* | |
| 4584 * This changes the overall mode select completion | |
| 4585 * reason to a failed one !!!!! | |
| 4586 */ | |
| 4587 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4588 sense = sata_arq_sense(spx); | |
| 4589 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 4590 rval = TRAN_ACCEPT; | |
| 4591 } | |
| 4592 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4593 } | |
| 4594 /* Restore the scsi pkt flags */ | |
| 4595 scsipkt->pkt_flags &= ~FLAG_NOINTR; | |
| 4596 scsipkt->pkt_flags |= nointr_flag; | |
| 4597 | |
| 4598 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4599 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4600 | |
| 4601 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4602 scsipkt->pkt_comp != NULL) | |
| 4603 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4604 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4605 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4606 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4607 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4608 return (TRAN_BUSY); |
| 1258 | 4609 |
| 4610 return (rval); | |
| 4611 } | |
| 4612 | |
| 4613 | |
| 4614 | |
| 4615 /* | |
| 4616 * Translate command: Log Sense | |
| 4617 */ | |
| 4618 static int | |
| 4619 sata_txlt_log_sense(sata_pkt_txlate_t *spx) | |
| 4620 { | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4621 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4622 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
|
4623 sata_drive_info_t *sdinfo; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4624 struct scsi_extended_sense *sense; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4625 int len, count, alc_len; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4626 int pc; /* Page Control code */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4627 int page_code; /* Page code */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4628 uint8_t *buf; /* log sense buffer */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4629 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4630 #define MAX_LOG_SENSE_PAGE_SIZE 512 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4631 |
| 1258 | 4632 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
|
4633 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", |
| 1258 | 4634 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, |
| 4635 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4636 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4637 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
|
4638 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4639 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4640 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4641 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4642 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4643 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4644 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4645 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4646 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4647 scsipkt->pkt_reason = CMD_CMPLT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4648 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
|
4649 STATE_SENT_CMD | STATE_GOT_STATUS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4650 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4651 pc = scsipkt->pkt_cdbp[2] >> 6; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4652 page_code = scsipkt->pkt_cdbp[2] & 0x3f; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4653 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
4654 /* 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
|
4655 switch (pc) { |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
4656 case PC_CUMULATIVE_VALUES: |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4657 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4658 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4659 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4660 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4661 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4662 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
|
4663 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4664 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4665 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4666 switch (page_code) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4667 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4668 case PAGE_CODE_SELF_TEST_RESULTS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4669 case PAGE_CODE_INFORMATION_EXCEPTIONS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4670 case PAGE_CODE_SMART_READ_DATA: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4671 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4672 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4673 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4674 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4675 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4676 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
|
4677 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4678 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4679 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4680 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
|
4681 sata_id_t *sata_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4682 len = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4683 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4684 /* Build log parameter header */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4685 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
|
4686 buf[len++] = 0; /* reserved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4687 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
|
4688 buf[len++] = 0; /* (LSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4689 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4690 sdinfo = sata_get_device_info( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4691 spx->txlt_sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4692 &spx->txlt_sata_pkt->satapkt_device); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4693 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4694 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4695 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4696 * Add requested pages. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4697 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4698 switch (page_code) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4699 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4700 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
|
4701 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4702 case PAGE_CODE_SELF_TEST_RESULTS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4703 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4704 if ((! (sata_id->ai_cmdset84 & |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4705 SATA_SMART_SELF_TEST_SUPPORTED)) || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4706 (! (sata_id->ai_features87 & |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4707 SATA_SMART_SELF_TEST_SUPPORTED))) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4708 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4709 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4710 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4711 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4712 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4713 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4714 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4715 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4716 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
|
4717 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4718 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4719 case PAGE_CODE_INFORMATION_EXCEPTIONS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4720 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4721 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4722 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4723 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4724 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4725 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4726 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4727 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4728 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4729 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4730 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4731 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4732 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4733 sense->es_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4734 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4735 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4736 sense->es_qual_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4737 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4738 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4739 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4740 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4741 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4742 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
|
4743 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4744 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4745 case PAGE_CODE_SMART_READ_DATA: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4746 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4747 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4748 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4749 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4750 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4751 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4752 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4753 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4754 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4755 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4756 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4757 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4758 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4759 sense->es_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4760 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4761 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4762 sense->es_qual_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4763 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4764 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4765 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4766 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4767 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4768 /* This page doesn't include a page header */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4769 len = sata_build_lsense_page_30(sdinfo, buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4770 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4771 goto no_header; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4772 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4773 /* Invalid request */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4774 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4775 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4776 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4777 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
|
4778 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4779 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4780 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4781 /* set parameter log sense data length */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4782 buf[2] = len >> 8; /* log sense length (MSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4783 buf[3] = len & 0xff; /* log sense length (LSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4784 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4785 len += SCSI_LOG_PAGE_HDR_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4786 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4787 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4788 no_header: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4789 /* Check allocation length */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4790 alc_len = scsipkt->pkt_cdbp[7]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4791 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4792 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4793 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4794 * We do not check for possible parameters truncation |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4795 * (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
|
4796 * correctly. Just avoiding overrun. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4797 * 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
|
4798 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4799 count = MIN(alc_len, len); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4800 count = MIN(bp->b_bcount, count); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4801 bcopy(buf, bp->b_un.b_addr, count); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4802 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4803 scsipkt->pkt_state |= STATE_XFERRED_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4804 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
|
4805 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4806 *scsipkt->pkt_scbp = STATUS_GOOD; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4807 done: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4808 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4809 (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
|
4810 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4811 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
|
4812 "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
|
4813 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4814 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4815 scsipkt->pkt_comp != NULL) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4816 /* scsi callback required */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4817 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4818 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4819 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4820 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4821 return (TRAN_BUSY); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4822 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4823 return (TRAN_ACCEPT); |
| 1258 | 4824 } |
| 4825 | |
| 4826 /* | |
| 4827 * Translate command: Log Select | |
| 4828 * Not implemented at this time - returns invalid command response. | |
| 4829 */ | |
| 4830 static int | |
| 4831 sata_txlt_log_select(sata_pkt_txlate_t *spx) | |
| 4832 { | |
| 4833 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4834 "sata_txlt_log_select\n", NULL); | |
| 4835 | |
| 4836 return (sata_txlt_invalid_command(spx)); | |
| 4837 } | |
| 4838 | |
| 4839 | |
| 4840 /* | |
| 4841 * Translate command: Read (various types). | |
| 4842 * Translated into appropriate type of ATA READ command | |
| 4843 * (NO ATAPI implementation yet). | |
| 4844 * Both the device capabilities and requested operation mode are | |
| 4845 * considered. | |
| 4846 * | |
| 4847 * Following scsi cdb fields are ignored: | |
| 4848 * rdprotect, dpo, fua, fua_nv, group_number. | |
| 4849 * | |
| 4850 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework | |
| 4851 * enable variable sata_func_enable), the capability of the controller and | |
| 4852 * capability of a device are checked and if both support queueing, read | |
| 4853 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT | |
| 4854 * command rather than plain READ_XXX command. | |
| 4855 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and | |
| 4856 * both the controller and device suport such functionality, the read | |
| 4857 * request will be translated to READ_FPDMA_QUEUED command. | |
| 4858 * | |
| 4859 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 4860 * appropriate values in scsi_pkt fields. | |
| 4861 */ | |
| 4862 static int | |
| 4863 sata_txlt_read(sata_pkt_txlate_t *spx) | |
| 4864 { | |
| 4865 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4866 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 4867 sata_drive_info_t *sdinfo; | |
| 4868 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 4869 int cport = SATA_TXLT_CPORT(spx); | |
| 4870 uint16_t sec_count; | |
| 4871 uint64_t lba; | |
| 4872 int rval; | |
| 4873 int synch; | |
| 4874 | |
| 4875 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4876 | |
| 4877 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4878 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4879 return (rval); | |
| 4880 } | |
| 4881 | |
| 4882 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 4883 &spx->txlt_sata_pkt->satapkt_device); | |
| 4884 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4885 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
| 1258 | 4886 /* |
| 4887 * Build cmd block depending on the device capability and | |
| 4888 * requested operation mode. | |
| 4889 * Do not bother with non-dma mode. | |
| 4890 */ | |
| 4891 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 4892 case SCMD_READ: | |
| 4893 /* 6-byte scsi read cmd : 0x08 */ | |
| 4894 lba = (scsipkt->pkt_cdbp[1] & 0x1f); | |
| 4895 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; | |
| 4896 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4897 sec_count = scsipkt->pkt_cdbp[4]; | |
| 4898 /* sec_count 0 will be interpreted as 256 by a device */ | |
| 4899 break; | |
| 4900 case SCMD_READ_G1: | |
| 4901 /* 10-bytes scsi read command : 0x28 */ | |
| 4902 lba = scsipkt->pkt_cdbp[2]; | |
| 4903 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4904 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 4905 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 4906 sec_count = scsipkt->pkt_cdbp[7]; | |
| 4907 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 4908 break; | |
| 4909 case SCMD_READ_G5: | |
| 4910 /* 12-bytes scsi read command : 0xA8 */ | |
| 4911 lba = scsipkt->pkt_cdbp[2]; | |
| 4912 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4913 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 4914 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 4915 sec_count = scsipkt->pkt_cdbp[6]; | |
| 4916 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; | |
| 4917 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 4918 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; | |
| 4919 break; | |
| 4920 case SCMD_READ_G4: | |
| 4921 /* 16-bytes scsi read command : 0x88 */ | |
| 4922 lba = scsipkt->pkt_cdbp[2]; | |
| 4923 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4924 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 4925 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 4926 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; | |
| 4927 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; | |
| 4928 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; | |
| 4929 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; | |
| 4930 sec_count = scsipkt->pkt_cdbp[10]; | |
| 4931 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; | |
| 4932 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; | |
| 4933 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; | |
| 4934 break; | |
| 4935 default: | |
| 4936 /* Unsupported command */ | |
| 4937 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4938 return (sata_txlt_invalid_command(spx)); | |
| 4939 } | |
| 4940 | |
| 4941 /* | |
| 4942 * Check if specified address exceeds device capacity | |
| 4943 */ | |
| 4944 if ((lba >= sdinfo->satadrv_capacity) || | |
| 4945 ((lba + sec_count) >= sdinfo->satadrv_capacity)) { | |
| 4946 /* LBA out of range */ | |
| 4947 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4948 return (sata_txlt_lba_out_of_range(spx)); | |
| 4949 } | |
| 4950 | |
| 4951 scmd->satacmd_addr_type = ATA_ADDR_LBA; | |
| 4952 scmd->satacmd_device_reg = SATA_ADH_LBA; | |
| 4953 scmd->satacmd_cmd_reg = SATAC_READ_DMA; | |
| 4954 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { | |
| 4955 scmd->satacmd_addr_type = ATA_ADDR_LBA48; | |
| 4956 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; | |
| 4957 scmd->satacmd_sec_count_msb = sec_count >> 8; | |
| 4958 #ifndef __lock_lint | |
| 4959 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; | |
| 4960 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; | |
| 4961 scmd->satacmd_lba_high_msb = lba >> 40; | |
| 4962 #endif | |
| 4963 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { | |
| 4964 scmd->satacmd_addr_type = ATA_ADDR_LBA28; | |
| 4965 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); | |
| 4966 } | |
| 4967 scmd->satacmd_sec_count_lsb = sec_count & 0xff; | |
| 4968 scmd->satacmd_lba_low_lsb = lba & 0xff; | |
| 4969 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; | |
| 4970 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; | |
| 4971 scmd->satacmd_features_reg = 0; | |
| 4972 scmd->satacmd_status_reg = 0; | |
| 4973 scmd->satacmd_error_reg = 0; | |
| 4974 | |
| 4975 /* | |
| 4976 * Check if queueing commands should be used and switch | |
| 4977 * to appropriate command if possible | |
| 4978 */ | |
| 4979 if (sata_func_enable & SATA_ENABLE_QUEUING) { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4980 boolean_t using_queuing; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4981 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4982 /* Queuing supported by controller and device? */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4983 if ((sata_func_enable & SATA_ENABLE_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4984 (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4985 SATA_DEV_F_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4986 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4987 SATA_CTLF_NCQ)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4988 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4989 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4990 /* NCQ supported - use FPDMA READ */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4991 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4992 SATAC_READ_FPDMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4993 scmd->satacmd_features_reg_ext = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4994 scmd->satacmd_sec_count_msb; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4995 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
|
4996 scmd->satacmd_rle_sata_cmd = &sata_rle_cmd; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4997 } else if ((sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4998 SATA_DEV_F_TCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4999 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5000 SATA_CTLF_QCMD)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5001 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5002 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5003 /* Legacy queueing */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5004 if (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5005 SATA_DEV_F_LBA48) { |
| 1258 | 5006 scmd->satacmd_cmd_reg = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5007 SATAC_READ_DMA_QUEUED_EXT; |
| 1258 | 5008 scmd->satacmd_features_reg_ext = |
| 5009 scmd->satacmd_sec_count_msb; | |
| 5010 scmd->satacmd_sec_count_msb = 0; | |
| 5011 } else { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5012 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5013 SATAC_READ_DMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5014 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5015 } else /* Queuing not supported */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5016 using_queuing = B_FALSE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5017 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5018 /* |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5019 * 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
|
5020 * and the secount count will contain the tag. |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5021 */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5022 if (using_queuing) { |
| 1258 | 5023 scmd->satacmd_features_reg = |
| 5024 scmd->satacmd_sec_count_lsb; | |
| 5025 scmd->satacmd_sec_count_lsb = 0; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5026 scmd->satacmd_flags.sata_queued = B_TRUE; |
| 1258 | 5027 } |
| 5028 } | |
| 5029 | |
| 5030 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, | |
| 5031 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", | |
| 5032 scmd->satacmd_cmd_reg, lba, sec_count); | |
| 5033 | |
| 5034 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5035 /* Need callback function */ | |
| 5036 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; | |
| 5037 synch = FALSE; | |
| 5038 } else | |
| 5039 synch = TRUE; | |
| 5040 | |
| 5041 /* Transfer command to HBA */ | |
| 5042 if (sata_hba_start(spx, &rval) != 0) { | |
| 5043 /* Pkt not accepted for execution */ | |
| 5044 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5045 return (rval); | |
| 5046 } | |
| 5047 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5048 /* | |
| 5049 * If execution is non-synchronous, | |
| 5050 * a callback function will handle potential errors, translate | |
| 5051 * the response and will do a callback to a target driver. | |
| 5052 * If it was synchronous, check execution status using the same | |
| 5053 * framework callback. | |
| 5054 */ | |
| 5055 if (synch) { | |
| 5056 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5057 "synchronous execution status %x\n", | |
| 5058 spx->txlt_sata_pkt->satapkt_reason); | |
| 5059 sata_txlt_rw_completion(spx->txlt_sata_pkt); | |
| 5060 } | |
| 5061 return (TRAN_ACCEPT); | |
| 5062 } | |
| 5063 | |
| 5064 | |
| 5065 /* | |
| 5066 * SATA translate command: Write (various types) | |
| 5067 * Translated into appropriate type of ATA WRITE command | |
| 5068 * (NO ATAPI implementation yet). | |
| 5069 * Both the device capabilities and requested operation mode are | |
| 5070 * considered. | |
| 5071 * | |
| 5072 * Following scsi cdb fields are ignored: | |
| 5073 * rwprotect, dpo, fua, fua_nv, group_number. | |
| 5074 * | |
| 5075 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 5076 * appropriate values in scsi_pkt fields. | |
| 5077 */ | |
| 5078 static int | |
| 5079 sata_txlt_write(sata_pkt_txlate_t *spx) | |
| 5080 { | |
| 5081 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5082 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5083 sata_drive_info_t *sdinfo; | |
| 5084 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5085 int cport = SATA_TXLT_CPORT(spx); | |
| 5086 uint16_t sec_count; | |
| 5087 uint64_t lba; | |
| 5088 int rval; | |
| 5089 int synch; | |
| 5090 | |
| 5091 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5092 | |
| 5093 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 5094 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5095 return (rval); | |
| 5096 } | |
| 5097 | |
| 5098 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 5099 &spx->txlt_sata_pkt->satapkt_device); | |
| 5100 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5101 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; |
| 1258 | 5102 /* |
| 5103 * Build cmd block depending on the device capability and | |
| 5104 * requested operation mode. | |
| 5105 * Do not bother with non-dma mode. | |
| 5106 */ | |
| 5107 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 5108 case SCMD_WRITE: | |
| 5109 /* 6-byte scsi read cmd : 0x0A */ | |
| 5110 lba = (scsipkt->pkt_cdbp[1] & 0x1f); | |
| 5111 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; | |
| 5112 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5113 sec_count = scsipkt->pkt_cdbp[4]; | |
| 5114 /* sec_count 0 will be interpreted as 256 by a device */ | |
| 5115 break; | |
| 5116 case SCMD_WRITE_G1: | |
| 5117 /* 10-bytes scsi write command : 0x2A */ | |
| 5118 lba = scsipkt->pkt_cdbp[2]; | |
| 5119 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5120 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5121 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5122 sec_count = scsipkt->pkt_cdbp[7]; | |
| 5123 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5124 break; | |
| 5125 case SCMD_WRITE_G5: | |
| 5126 /* 12-bytes scsi read command : 0xAA */ | |
| 5127 lba = scsipkt->pkt_cdbp[2]; | |
| 5128 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5129 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5130 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5131 sec_count = scsipkt->pkt_cdbp[6]; | |
| 5132 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; | |
| 5133 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5134 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; | |
| 5135 break; | |
| 5136 case SCMD_WRITE_G4: | |
| 5137 /* 16-bytes scsi write command : 0x8A */ | |
| 5138 lba = scsipkt->pkt_cdbp[2]; | |
| 5139 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5140 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5141 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5142 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; | |
| 5143 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; | |
| 5144 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; | |
| 5145 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; | |
| 5146 sec_count = scsipkt->pkt_cdbp[10]; | |
| 5147 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; | |
| 5148 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; | |
| 5149 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; | |
| 5150 break; | |
| 5151 default: | |
| 5152 /* Unsupported command */ | |
| 5153 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5154 return (sata_txlt_invalid_command(spx)); | |
| 5155 } | |
| 5156 | |
| 5157 /* | |
| 5158 * Check if specified address and length exceeds device capacity | |
| 5159 */ | |
| 5160 if ((lba >= sdinfo->satadrv_capacity) || | |
| 5161 ((lba + sec_count) >= sdinfo->satadrv_capacity)) { | |
| 5162 /* LBA out of range */ | |
| 5163 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5164 return (sata_txlt_lba_out_of_range(spx)); | |
| 5165 } | |
| 5166 | |
| 5167 scmd->satacmd_addr_type = ATA_ADDR_LBA; | |
| 5168 scmd->satacmd_device_reg = SATA_ADH_LBA; | |
| 5169 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; | |
| 5170 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { | |
| 5171 scmd->satacmd_addr_type = ATA_ADDR_LBA48; | |
| 5172 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; | |
| 5173 scmd->satacmd_sec_count_msb = sec_count >> 8; | |
| 5174 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; | |
| 5175 #ifndef __lock_lint | |
| 5176 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; | |
| 5177 scmd->satacmd_lba_high_msb = lba >> 40; | |
| 5178 #endif | |
| 5179 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { | |
| 5180 scmd->satacmd_addr_type = ATA_ADDR_LBA28; | |
| 5181 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); | |
| 5182 } | |
| 5183 scmd->satacmd_sec_count_lsb = sec_count & 0xff; | |
| 5184 scmd->satacmd_lba_low_lsb = lba & 0xff; | |
| 5185 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; | |
| 5186 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; | |
| 5187 scmd->satacmd_features_reg = 0; | |
| 5188 scmd->satacmd_status_reg = 0; | |
| 5189 scmd->satacmd_error_reg = 0; | |
| 5190 | |
| 5191 /* | |
| 5192 * Check if queueing commands should be used and switch | |
| 5193 * to appropriate command if possible | |
| 5194 */ | |
| 5195 if (sata_func_enable & SATA_ENABLE_QUEUING) { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5196 boolean_t using_queuing; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5197 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5198 /* Queuing supported by controller and device? */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5199 if ((sata_func_enable & SATA_ENABLE_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5200 (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5201 SATA_DEV_F_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5202 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5203 SATA_CTLF_NCQ)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5204 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5205 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5206 /* NCQ supported - use FPDMA WRITE */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5207 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5208 SATAC_WRITE_FPDMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5209 scmd->satacmd_features_reg_ext = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5210 scmd->satacmd_sec_count_msb; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5211 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
|
5212 scmd->satacmd_rle_sata_cmd = &sata_rle_cmd; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5213 } else if ((sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5214 SATA_DEV_F_TCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5215 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5216 SATA_CTLF_QCMD)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5217 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5218 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5219 /* Legacy queueing */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5220 if (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5221 SATA_DEV_F_LBA48) { |
| 1258 | 5222 scmd->satacmd_cmd_reg = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5223 SATAC_WRITE_DMA_QUEUED_EXT; |
| 1258 | 5224 scmd->satacmd_features_reg_ext = |
| 5225 scmd->satacmd_sec_count_msb; | |
| 5226 scmd->satacmd_sec_count_msb = 0; | |
| 5227 } else { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5228 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5229 SATAC_WRITE_DMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5230 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5231 } else /* Queuing not supported */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5232 using_queuing = B_FALSE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5233 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5234 if (using_queuing) { |
| 1258 | 5235 scmd->satacmd_features_reg = |
| 5236 scmd->satacmd_sec_count_lsb; | |
| 5237 scmd->satacmd_sec_count_lsb = 0; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5238 scmd->satacmd_flags.sata_queued = B_TRUE; |
| 1258 | 5239 } |
| 5240 } | |
| 5241 | |
| 5242 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5243 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", | |
| 5244 scmd->satacmd_cmd_reg, lba, sec_count); | |
| 5245 | |
| 5246 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5247 /* Need callback function */ | |
| 5248 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; | |
| 5249 synch = FALSE; | |
| 5250 } else | |
| 5251 synch = TRUE; | |
| 5252 | |
| 5253 /* Transfer command to HBA */ | |
| 5254 if (sata_hba_start(spx, &rval) != 0) { | |
| 5255 /* Pkt not accepted for execution */ | |
| 5256 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5257 return (rval); | |
| 5258 } | |
| 5259 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5260 | |
| 5261 /* | |
| 5262 * If execution is non-synchronous, | |
| 5263 * a callback function will handle potential errors, translate | |
| 5264 * the response and will do a callback to a target driver. | |
| 5265 * If it was synchronous, check execution status using the same | |
| 5266 * framework callback. | |
| 5267 */ | |
| 5268 if (synch) { | |
| 5269 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5270 "synchronous execution status %x\n", | |
| 5271 spx->txlt_sata_pkt->satapkt_reason); | |
| 5272 sata_txlt_rw_completion(spx->txlt_sata_pkt); | |
| 5273 } | |
| 5274 return (TRAN_ACCEPT); | |
| 5275 } | |
| 5276 | |
| 5277 | |
| 5278 /* | |
| 5279 * NOTE: NOT FUNCTIONAL IMPLEMENTATION. THIS IS A PLACEHOLDER for the function | |
| 5280 * that will be fixed in phase 2 of the development. | |
| 5281 * Currently ATAPI is not supported. ATAPI devices are threated as not-valid | |
| 5282 * devices. | |
| 5283 * This function is not called, since scsi_sata_start() will bail-out prior | |
| 5284 * to calling it. | |
| 5285 */ | |
| 5286 static int | |
| 5287 sata_txlt_atapi(sata_pkt_txlate_t *spx) | |
| 5288 { | |
| 5289 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5290 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5291 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 5292 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5293 int cport = SATA_TXLT_CPORT(spx); | |
| 5294 int rval; | |
| 5295 int synch; | |
| 5296 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; | |
| 5297 | |
| 5298 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5299 | |
| 5300 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 5301 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5302 return (rval); | |
| 5303 } | |
| 5304 | |
| 5305 /* | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5306 * scmd->satacmd_flags.sata_data_direction default - |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5307 * SATA_DIR_NODATA_XFER - is set by |
| 1258 | 5308 * sata_txlt_generic_pkt_info(). |
| 5309 */ | |
| 5310 if (scmd->satacmd_bp) { | |
| 5311 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
|
5312 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
| 1258 | 5313 } else { |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5314 scmd->satacmd_flags.sata_data_direction = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5315 SATA_DIR_WRITE; |
| 1258 | 5316 } |
| 5317 } | |
| 5318 | |
| 5319 scmd->satacmd_acdb_len = scsi_cdb_size[GETGROUP(cdbp)]; | |
| 5320 scmd->satacmd_cmd_reg = SATAC_PACKET; | |
| 5321 bcopy(cdbp, scmd->satacmd_acdb, 16); | |
| 5322 | |
| 5323 /* | |
| 5324 * For non-read/write commands we need to | |
| 5325 * map buffer | |
| 5326 */ | |
| 5327 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 5328 case SCMD_READ: | |
| 5329 case SCMD_READ_G1: | |
| 5330 case SCMD_READ_G5: | |
| 5331 case SCMD_READ_G4: | |
| 5332 case SCMD_WRITE: | |
| 5333 case SCMD_WRITE_G1: | |
| 5334 case SCMD_WRITE_G5: | |
| 5335 case SCMD_WRITE_G4: | |
| 5336 break; | |
| 5337 default: | |
| 5338 if (bp->b_flags & (B_PHYS | B_PAGEIO)) | |
| 5339 bp_mapin(bp); | |
| 5340 break; | |
| 5341 } | |
| 5342 | |
| 5343 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5344 /* Need callback function */ | |
| 5345 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; | |
| 5346 synch = FALSE; | |
| 5347 } else | |
| 5348 synch = TRUE; | |
| 5349 | |
| 5350 /* Transfer command to HBA */ | |
| 5351 if (sata_hba_start(spx, &rval) != 0) { | |
| 5352 /* Pkt not accepted for execution */ | |
| 5353 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5354 return (rval); | |
| 5355 } | |
| 5356 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5357 /* | |
| 5358 * If execution is non-synchronous, | |
| 5359 * a callback function will handle potential errors, translate | |
| 5360 * the response and will do a callback to a target driver. | |
| 5361 * If it was synchronous, check execution status using the same | |
| 5362 * framework callback. | |
| 5363 */ | |
| 5364 if (synch) { | |
| 5365 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5366 "synchronous execution status %x\n", | |
| 5367 spx->txlt_sata_pkt->satapkt_reason); | |
| 5368 sata_txlt_atapi_completion(spx->txlt_sata_pkt); | |
| 5369 } | |
| 5370 return (TRAN_ACCEPT); | |
| 5371 } | |
| 5372 | |
| 5373 /* | |
| 5374 * Translate command: Synchronize Cache. | |
| 5375 * Translates into Flush Cache command. | |
| 5376 * (NO ATAPI implementation yet). | |
| 5377 * | |
| 5378 * NOTE: We should check if Flush Cache is supported by the device (ATAPI | |
| 5379 * devices) | |
| 5380 * | |
| 5381 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 5382 * appropriate values in scsi_pkt fields. | |
| 5383 */ | |
| 5384 static int | |
| 5385 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) | |
| 5386 { | |
| 5387 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5388 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5389 int cport = SATA_TXLT_CPORT(spx); | |
| 5390 int rval; | |
| 5391 int synch; | |
| 5392 | |
| 5393 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5394 | |
| 5395 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 5396 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5397 return (rval); | |
| 5398 } | |
| 5399 | |
| 5400 scmd->satacmd_addr_type = 0; | |
| 5401 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; | |
| 5402 scmd->satacmd_device_reg = 0; | |
| 5403 scmd->satacmd_sec_count_lsb = 0; | |
| 5404 scmd->satacmd_lba_low_lsb = 0; | |
| 5405 scmd->satacmd_lba_mid_lsb = 0; | |
| 5406 scmd->satacmd_lba_high_lsb = 0; | |
| 5407 scmd->satacmd_features_reg = 0; | |
| 5408 scmd->satacmd_status_reg = 0; | |
| 5409 scmd->satacmd_error_reg = 0; | |
| 5410 | |
| 5411 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5412 "sata_txlt_synchronize_cache\n", NULL); | |
| 5413 | |
| 5414 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5415 /* Need to set-up a callback function */ | |
| 5416 spx->txlt_sata_pkt->satapkt_comp = | |
| 5417 sata_txlt_nodata_cmd_completion; | |
| 5418 synch = FALSE; | |
| 5419 } else | |
| 5420 synch = TRUE; | |
| 5421 | |
| 5422 /* Transfer command to HBA */ | |
| 5423 if (sata_hba_start(spx, &rval) != 0) { | |
| 5424 /* Pkt not accepted for execution */ | |
| 5425 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5426 return (rval); | |
| 5427 } | |
| 5428 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5429 | |
| 5430 /* | |
| 5431 * If execution non-synchronous, it had to be completed | |
| 5432 * a callback function will handle potential errors, translate | |
| 5433 * the response and will do a callback to a target driver. | |
| 5434 * If it was synchronous, check status, using the same | |
| 5435 * framework callback. | |
| 5436 */ | |
| 5437 if (synch) { | |
| 5438 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5439 "synchronous execution status %x\n", | |
| 5440 spx->txlt_sata_pkt->satapkt_reason); | |
| 5441 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); | |
| 5442 } | |
| 5443 return (TRAN_ACCEPT); | |
| 5444 } | |
| 5445 | |
| 5446 /* | |
| 5447 * Send pkt to SATA HBA driver | |
| 5448 * | |
| 5449 * This function may be called only if the operation is requested by scsi_pkt, | |
| 5450 * i.e. scsi_pkt is not NULL. | |
| 5451 * | |
| 5452 * This function has to be called with cport mutex held. It does release | |
| 5453 * the mutex when it calls HBA driver sata_tran_start function and | |
| 5454 * re-acquires it afterwards. | |
| 5455 * | |
| 5456 * If return value is 0, pkt was accepted, -1 otherwise | |
| 5457 * rval is set to appropriate sata_scsi_start return value. | |
| 5458 * | |
| 5459 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not | |
| 5460 * have called the sata_pkt callback function for this packet. | |
| 5461 * | |
| 5462 * The scsi callback has to be performed by the caller of this routine. | |
| 5463 * | |
| 5464 * Note 2: No port multiplier support for now. | |
| 5465 */ | |
| 5466 static int | |
| 5467 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) | |
| 5468 { | |
| 5469 int stat; | |
| 5470 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; | |
| 5471 sata_drive_info_t *sdinfo; | |
| 5472 sata_device_t sata_device; | |
| 5473 uint8_t cmd; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5474 struct sata_cmd_flags cmd_flags; |
| 1258 | 5475 |
| 5476 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 5477 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(spx->txlt_sata_hba_inst, | |
| 5478 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport))); | |
| 5479 | |
| 5480 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 5481 &spx->txlt_sata_pkt->satapkt_device); | |
| 5482 ASSERT(sdinfo != NULL); | |
| 5483 | |
| 5484 /* Clear device reset state? */ | |
| 5485 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
|
5486 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5487 sata_clear_dev_reset = B_TRUE; |
| 1258 | 5488 sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET; |
| 5489 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5490 "sata_hba_start: clearing device reset state\n", NULL); | |
| 5491 } | |
| 5492 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; | |
| 5493 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; | |
| 5494 sata_device = spx->txlt_sata_pkt->satapkt_device; /* local copy */ | |
| 5495 | |
| 5496 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5497 sdinfo->satadrv_addr.cport))); | |
| 5498 | |
| 5499 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5500 "Sata cmd 0x%2x\n", cmd); | |
| 5501 | |
| 5502 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), | |
| 5503 spx->txlt_sata_pkt); | |
| 5504 | |
| 5505 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5506 sdinfo->satadrv_addr.cport))); | |
| 5507 /* | |
| 5508 * If sata pkt was accepted and executed in asynchronous mode, i.e. | |
| 5509 * with the sata callback, the sata_pkt could be already destroyed | |
| 5510 * by the time we check ther return status from the hba_start() | |
| 5511 * function, because sata_scsi_destroy_pkt() could have been already | |
| 5512 * called (perhaps in the interrupt context). So, in such case, there | |
| 5513 * should be no references to it. In other cases, sata_pkt still | |
| 5514 * exists. | |
| 5515 */ | |
| 5516 switch (stat) { | |
| 5517 case SATA_TRAN_ACCEPTED: | |
| 5518 /* | |
| 5519 * pkt accepted for execution. | |
| 5520 * If it was executed synchronously, it is already completed | |
| 5521 * and pkt completion_reason indicates completion status. | |
| 5522 */ | |
| 5523 *rval = TRAN_ACCEPT; | |
| 5524 return (0); | |
| 5525 | |
| 5526 case SATA_TRAN_QUEUE_FULL: | |
| 5527 /* | |
| 5528 * Controller detected queue full condition. | |
| 5529 */ | |
| 5530 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, | |
| 5531 "sata_hba_start: queue full\n", NULL); | |
| 5532 | |
| 5533 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 5534 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; | |
| 5535 | |
| 5536 *rval = TRAN_BUSY; | |
| 5537 break; | |
| 5538 | |
| 5539 case SATA_TRAN_PORT_ERROR: | |
| 5540 /* | |
| 5541 * Communication/link with device or general port error | |
| 5542 * detected before pkt execution begun. | |
| 5543 */ | |
| 5544 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == | |
| 5545 SATA_ADDR_CPORT) | |
| 5546 sata_log(sata_hba_inst, CE_CONT, | |
| 5547 "port %d error", | |
| 5548 sata_device.satadev_addr.cport); | |
| 5549 else | |
| 5550 sata_log(sata_hba_inst, CE_CONT, | |
| 5551 "port %d pmport %d error\n", | |
| 5552 sata_device.satadev_addr.cport, | |
| 5553 sata_device.satadev_addr.pmport); | |
| 5554 | |
| 5555 /* | |
| 5556 * Update the port/device structure. | |
| 5557 * sata_pkt should be still valid. Since port error is | |
| 5558 * returned, sata_device content should reflect port | |
| 5559 * state - it means, that sata address have been changed, | |
| 5560 * because original packet's sata address refered to a device | |
| 5561 * attached to some port. | |
| 5562 */ | |
| 5563 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 5564 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; | |
| 5565 *rval = TRAN_FATAL_ERROR; | |
| 5566 break; | |
| 5567 | |
| 5568 case SATA_TRAN_CMD_UNSUPPORTED: | |
| 5569 /* | |
| 5570 * Command rejected by HBA as unsupported. It was HBA driver | |
| 5571 * that rejected the command, command was not sent to | |
| 5572 * an attached device. | |
| 5573 */ | |
| 5574 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5575 sdinfo->satadrv_addr.cport))); | |
| 5576 (void) sata_txlt_invalid_command(spx); | |
| 5577 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5578 sdinfo->satadrv_addr.cport))); | |
| 5579 | |
| 5580 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) | |
| 5581 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5582 "sat_hba_start: cmd 0x%2x rejected " | |
| 5583 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); | |
| 5584 | |
| 5585 *rval = TRAN_ACCEPT; | |
| 5586 break; | |
| 5587 | |
| 5588 case SATA_TRAN_BUSY: | |
| 5589 /* | |
| 5590 * Command rejected by HBA because other operation prevents | |
| 5591 * accepting the packet, or device is in RESET condition. | |
| 5592 */ | |
| 5593 if (sdinfo != NULL) { | |
| 5594 sdinfo->satadrv_state = | |
| 5595 spx->txlt_sata_pkt->satapkt_device.satadev_state; | |
| 5596 | |
| 5597 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { | |
| 5598 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5599 "sata_hba_start: cmd 0x%2x rejected " | |
| 5600 "because of device reset condition\n", | |
| 5601 cmd); | |
| 5602 } else { | |
| 5603 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5604 "sata_hba_start: cmd 0x%2x rejected " | |
| 5605 "with SATA_TRAN_BUSY status\n", | |
| 5606 cmd); | |
| 5607 } | |
| 5608 } | |
| 5609 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 5610 *rval = TRAN_BUSY; | |
| 5611 break; | |
| 5612 | |
| 5613 default: | |
| 5614 /* Unrecognized HBA response */ | |
| 5615 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 5616 "sata_hba_start: unrecognized HBA response " | |
| 5617 "to cmd : 0x%2x resp 0x%x", cmd, rval)); | |
| 5618 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; | |
| 5619 *rval = TRAN_FATAL_ERROR; | |
| 5620 break; | |
| 5621 } | |
| 5622 | |
| 5623 /* | |
| 5624 * If we got here, the packet was rejected. | |
| 5625 * Check if we need to remember reset state clearing request | |
| 5626 */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5627 if (cmd_flags.sata_clear_dev_reset) { |
| 1258 | 5628 /* |
| 5629 * Check if device is still configured - it may have | |
| 5630 * disapeared from the configuration | |
| 5631 */ | |
| 5632 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 5633 if (sdinfo != NULL) { | |
| 5634 /* | |
| 5635 * Restore the flag that requests clearing of | |
| 5636 * the device reset state, | |
| 5637 * so the next sata packet may carry it to HBA. | |
| 5638 */ | |
| 5639 sdinfo->satadrv_event_flags |= | |
| 5640 SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 5641 } | |
| 5642 } | |
| 5643 return (-1); | |
| 5644 } | |
| 5645 | |
| 5646 /* | |
| 5647 * Scsi response setup for invalid LBA | |
| 5648 * | |
| 5649 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 5650 */ | |
| 5651 static int | |
| 5652 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) | |
| 5653 { | |
| 5654 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5655 struct scsi_extended_sense *sense; | |
| 5656 | |
| 5657 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5658 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5659 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5660 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 5661 | |
| 5662 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 5663 sense = sata_arq_sense(spx); | |
| 5664 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 5665 sense->es_add_code = SD_SCSI_LBA_OUT_OF_RANGE; | |
| 5666 | |
| 5667 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5668 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 5669 | |
| 5670 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 5671 scsipkt->pkt_comp != NULL) | |
| 5672 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5673 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5674 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5675 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5676 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5677 return (TRAN_BUSY); |
| 1258 | 5678 return (TRAN_ACCEPT); |
| 5679 } | |
| 5680 | |
| 5681 | |
| 5682 /* | |
| 5683 * Analyze device status and error registers and translate them into | |
| 5684 * appropriate scsi sense codes. | |
| 5685 * NOTE: non-packet commands only for now | |
| 5686 */ | |
| 5687 static void | |
| 5688 sata_decode_device_error(sata_pkt_txlate_t *spx, | |
| 5689 struct scsi_extended_sense *sense) | |
| 5690 { | |
| 5691 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; | |
| 5692 | |
| 5693 ASSERT(sense != NULL); | |
| 5694 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 5695 SATA_STATUS_ERR); | |
| 5696 | |
| 5697 | |
| 5698 if (err_reg & SATA_ERROR_ICRC) { | |
| 5699 sense->es_key = KEY_ABORTED_COMMAND; | |
| 5700 sense->es_add_code = 0x08; /* Communication failure */ | |
| 5701 return; | |
| 5702 } | |
| 5703 | |
| 5704 if (err_reg & SATA_ERROR_UNC) { | |
| 5705 sense->es_key = KEY_MEDIUM_ERROR; | |
| 5706 /* Information bytes (LBA) need to be set by a caller */ | |
| 5707 return; | |
| 5708 } | |
| 5709 | |
| 5710 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ | |
| 5711 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { | |
| 5712 sense->es_key = KEY_UNIT_ATTENTION; | |
| 5713 sense->es_add_code = 0x3a; /* No media present */ | |
| 5714 return; | |
| 5715 } | |
| 5716 | |
| 5717 if (err_reg & SATA_ERROR_IDNF) { | |
| 5718 if (err_reg & SATA_ERROR_ABORT) { | |
| 5719 sense->es_key = KEY_ABORTED_COMMAND; | |
| 5720 } else { | |
| 5721 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 5722 sense->es_add_code = 0x21; /* LBA out of range */ | |
| 5723 } | |
| 5724 return; | |
| 5725 } | |
| 5726 | |
| 5727 if (err_reg & SATA_ERROR_ABORT) { | |
| 5728 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 5729 sense->es_key = KEY_ABORTED_COMMAND; | |
| 5730 return; | |
| 5731 } | |
| 5732 } | |
| 5733 | |
| 5734 /* | |
| 5735 * Extract error LBA from sata_pkt.satapkt_cmd register fields | |
| 5736 */ | |
| 5737 static void | |
| 5738 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) | |
| 5739 { | |
| 5740 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5741 | |
| 5742 *lba = 0; | |
| 5743 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { | |
| 5744 *lba = sata_cmd->satacmd_lba_high_msb; | |
| 5745 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; | |
| 5746 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; | |
| 5747 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { | |
| 5748 *lba = sata_cmd->satacmd_device_reg & 0xf; | |
| 5749 } | |
| 5750 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; | |
| 5751 *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
|
5752 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; |
| 1258 | 5753 } |
| 5754 | |
| 5755 /* | |
| 5756 * This is fixed sense format - if LBA exceeds the info field size, | |
| 5757 * no valid info will be returned (valid bit in extended sense will | |
| 5758 * be set to 0). | |
| 5759 */ | |
| 5760 static struct scsi_extended_sense * | |
| 5761 sata_arq_sense(sata_pkt_txlate_t *spx) | |
| 5762 { | |
| 5763 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5764 struct scsi_arq_status *arqs; | |
| 5765 struct scsi_extended_sense *sense; | |
| 5766 | |
| 5767 /* Fill ARQ sense data */ | |
| 5768 scsipkt->pkt_state |= STATE_ARQ_DONE; | |
| 5769 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; | |
| 5770 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; | |
| 5771 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; | |
| 5772 arqs->sts_rqpkt_reason = CMD_CMPLT; | |
| 5773 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5774 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5775 arqs->sts_rqpkt_resid = 0; | |
| 5776 sense = &arqs->sts_sensedata; | |
| 5777 bzero(sense, sizeof (struct scsi_extended_sense)); | |
| 5778 sense->es_valid = 1; /* Valid sense */ | |
| 5779 sense->es_class = 7; /* Response code 0x70 - current err */ | |
| 5780 sense->es_key = KEY_NO_SENSE; | |
| 5781 sense->es_info_1 = 0; | |
| 5782 sense->es_info_2 = 0; | |
| 5783 sense->es_info_3 = 0; | |
| 5784 sense->es_info_4 = 0; | |
| 5785 sense->es_add_len = 6; /* Additional length */ | |
| 5786 sense->es_cmd_info[0] = 0; | |
| 5787 sense->es_cmd_info[1] = 0; | |
| 5788 sense->es_cmd_info[2] = 0; | |
| 5789 sense->es_cmd_info[3] = 0; | |
| 5790 sense->es_add_code = 0; | |
| 5791 sense->es_qual_code = 0; | |
| 5792 return (sense); | |
| 5793 } | |
| 5794 | |
| 5795 | |
| 5796 /* | |
| 5797 * Translate completion status of SATA read/write commands into scsi response. | |
| 5798 * pkt completion_reason is checked to determine the completion status. | |
| 5799 * Do scsi callback if necessary. | |
| 5800 * | |
| 5801 * Note: this function may be called also for synchronously executed | |
| 5802 * commands. | |
| 5803 * This function may be used only if scsi_pkt is non-NULL. | |
| 5804 */ | |
| 5805 static void | |
| 5806 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) | |
| 5807 { | |
| 5808 sata_pkt_txlate_t *spx = | |
| 5809 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 5810 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; | |
| 5811 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5812 struct scsi_extended_sense *sense; | |
| 5813 uint64_t lba; | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5814 struct buf *bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5815 int rval; |
| 1258 | 5816 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { |
| 5817 /* Normal completion */ | |
| 5818 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5819 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; | |
| 5820 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5821 *scsipkt->pkt_scbp = STATUS_GOOD; | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5822 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5823 /* Temporary buffer was used */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5824 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5825 if (bp->b_flags & B_READ) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5826 rval = ddi_dma_sync( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5827 spx->txlt_buf_dma_handle, 0, 0, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5828 DDI_DMA_SYNC_FORCPU); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5829 ASSERT(rval == DDI_SUCCESS); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5830 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
|
5831 bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5832 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
5833 } |
| 1258 | 5834 } else { |
| 5835 /* | |
| 5836 * Something went wrong - analyze return | |
| 5837 */ | |
| 5838 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5839 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5840 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5841 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 5842 sense = sata_arq_sense(spx); | |
| 5843 ASSERT(sense != NULL); | |
| 5844 | |
| 5845 /* | |
| 5846 * 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
|
5847 * extract from device registers the failing LBA. |
| 1258 | 5848 */ |
| 5849 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { | |
| 5850 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && | |
| 5851 (scmd->satacmd_lba_mid_msb != 0 || | |
| 5852 scmd->satacmd_lba_high_msb != 0)) { | |
| 5853 /* | |
| 5854 * We have problem reporting this cmd LBA | |
| 5855 * in fixed sense data format, because of | |
| 5856 * the size of the scsi LBA fields. | |
| 5857 */ | |
| 5858 sense->es_valid = 0; | |
| 5859 } else { | |
| 5860 sata_extract_error_lba(spx, &lba); | |
| 5861 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
|
5862 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
|
5863 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
|
5864 sense->es_info_4 = lba & 0xFF; |
| 1258 | 5865 } |
| 5866 } else { | |
| 5867 /* Invalid extended sense info */ | |
| 5868 sense->es_valid = 0; | |
| 5869 } | |
| 5870 | |
| 5871 switch (sata_pkt->satapkt_reason) { | |
| 5872 case SATA_PKT_PORT_ERROR: | |
| 5873 /* We may want to handle DEV GONE state as well */ | |
| 5874 /* | |
| 5875 * We have no device data. Assume no data transfered. | |
| 5876 */ | |
| 5877 sense->es_key = KEY_HARDWARE_ERROR; | |
| 5878 break; | |
| 5879 | |
| 5880 case SATA_PKT_DEV_ERROR: | |
| 5881 if (sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 5882 SATA_STATUS_ERR) { | |
| 5883 /* | |
| 5884 * determine dev error reason from error | |
| 5885 * reg content | |
| 5886 */ | |
| 5887 sata_decode_device_error(spx, sense); | |
| 5888 if (sense->es_key == KEY_MEDIUM_ERROR) { | |
| 5889 switch (scmd->satacmd_cmd_reg) { | |
| 5890 case SATAC_READ_DMA: | |
| 5891 case SATAC_READ_DMA_EXT: | |
| 5892 case SATAC_READ_DMA_QUEUED: | |
| 5893 case SATAC_READ_DMA_QUEUED_EXT: | |
| 5894 case SATAC_READ_FPDMA_QUEUED: | |
| 5895 /* Unrecovered read error */ | |
| 5896 sense->es_add_code = | |
| 5897 SD_SCSI_UNREC_READ_ERROR; | |
| 5898 break; | |
| 5899 case SATAC_WRITE_DMA: | |
| 5900 case SATAC_WRITE_DMA_EXT: | |
| 5901 case SATAC_WRITE_DMA_QUEUED: | |
| 5902 case SATAC_WRITE_DMA_QUEUED_EXT: | |
| 5903 case SATAC_WRITE_FPDMA_QUEUED: | |
| 5904 /* Write error */ | |
| 5905 sense->es_add_code = | |
| 5906 SD_SCSI_WRITE_ERROR; | |
| 5907 break; | |
| 5908 default: | |
| 5909 /* Internal error */ | |
| 5910 SATA_LOG_D(( | |
| 5911 spx->txlt_sata_hba_inst, | |
| 5912 CE_WARN, | |
| 5913 "sata_txlt_rw_completion :" | |
| 5914 "internal error - invalid " | |
| 5915 "command 0x%2x", | |
| 5916 scmd->satacmd_cmd_reg)); | |
| 5917 break; | |
| 5918 } | |
| 5919 } | |
| 5920 break; | |
| 5921 } | |
| 5922 /* No extended sense key - no info available */ | |
| 5923 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5924 break; | |
| 5925 | |
| 5926 case SATA_PKT_TIMEOUT: | |
| 5927 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ | |
| 5928 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5929 /* No extended sense key ? */ | |
| 5930 break; | |
| 5931 | |
| 5932 case SATA_PKT_ABORTED: | |
| 5933 scsipkt->pkt_reason = CMD_ABORTED; | |
| 5934 /* No extended sense key ? */ | |
| 5935 break; | |
| 5936 | |
| 5937 case SATA_PKT_RESET: | |
| 5938 scsipkt->pkt_reason = CMD_RESET; | |
| 5939 break; | |
| 5940 | |
| 5941 default: | |
| 5942 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 5943 "sata_txlt_rw_completion: " | |
| 5944 "invalid packet completion reason")); | |
| 5945 scsipkt->pkt_reason = CMD_TRAN_ERR; | |
| 5946 break; | |
| 5947 } | |
| 5948 } | |
| 5949 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5950 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 5951 | |
| 5952 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 5953 scsipkt->pkt_comp != NULL) | |
| 5954 /* scsi callback required */ | |
| 5955 (*scsipkt->pkt_comp)(scsipkt); | |
| 5956 | |
| 5957 } | |
| 5958 | |
| 5959 /* | |
| 5960 * NON FUNCTIONAL IMPLEMENTATION. THIS IS A PLACE HOLDER. | |
| 5961 * ATAPI devices are not supported currently (are not be attached recognized | |
| 5962 * as valid devices). | |
| 5963 * Will be fixed in phase 2 of the development. | |
| 5964 */ | |
| 5965 static void | |
| 5966 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) | |
| 5967 { | |
| 5968 sata_pkt_txlate_t *spx = | |
| 5969 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 5970 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5971 struct scsi_arq_status *arqs; | |
| 5972 | |
| 5973 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { | |
| 5974 /* Normal completion */ | |
| 5975 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5976 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; | |
| 5977 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5978 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 5979 scsipkt->pkt_resid = 0; | |
| 5980 } else { | |
| 5981 /* | |
| 5982 * Something went wrong - analyze return | |
| 5983 */ | |
| 5984 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5985 STATE_SENT_CMD | STATE_GOT_STATUS | STATE_ARQ_DONE; | |
| 5986 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5987 | |
| 5988 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; | |
| 5989 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; | |
| 5990 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; | |
| 5991 arqs->sts_rqpkt_reason = CMD_CMPLT; | |
| 5992 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5993 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5994 arqs->sts_rqpkt_resid = 0; | |
| 5995 | |
| 5996 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, | |
| 5997 &arqs->sts_sensedata, SATA_ATAPI_RQSENSE_LEN); | |
| 5998 } | |
| 5999 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6000 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 6001 | |
| 6002 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 6003 scsipkt->pkt_comp != NULL) { | |
| 6004 /* scsi callback required */ | |
| 6005 (*scsipkt->pkt_comp)(scsipkt); | |
| 6006 } | |
| 6007 } | |
| 6008 | |
| 6009 | |
| 6010 /* | |
| 6011 * Translate completion status of non-data commands (i.e. commands returning | |
| 6012 * no data). | |
| 6013 * pkt completion_reason is checked to determine the completion status. | |
| 6014 * Do scsi callback if necessary (FLAG_NOINTR == 0) | |
| 6015 * | |
| 6016 * Note: this function may be called also for synchronously executed | |
| 6017 * commands. | |
| 6018 * This function may be used only if scsi_pkt is non-NULL. | |
| 6019 */ | |
| 6020 | |
| 6021 static void | |
| 6022 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) | |
| 6023 { | |
| 6024 sata_pkt_txlate_t *spx = | |
| 6025 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 6026 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6027 struct scsi_extended_sense *sense; | |
| 6028 | |
| 6029 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 6030 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 6031 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { | |
| 6032 /* Normal completion */ | |
| 6033 scsipkt->pkt_reason = CMD_CMPLT; | |
| 6034 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 6035 } else { | |
| 6036 /* Something went wrong */ | |
| 6037 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 6038 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 6039 sense = sata_arq_sense(spx); | |
| 6040 switch (sata_pkt->satapkt_reason) { | |
| 6041 case SATA_PKT_PORT_ERROR: | |
| 6042 /* | |
| 6043 * We have no device data. Assume no data transfered. | |
| 6044 */ | |
| 6045 sense->es_key = KEY_HARDWARE_ERROR; | |
| 6046 break; | |
| 6047 | |
| 6048 case SATA_PKT_DEV_ERROR: | |
| 6049 if (sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 6050 SATA_STATUS_ERR) { | |
| 6051 /* | |
| 6052 * determine dev error reason from error | |
| 6053 * reg content | |
| 6054 */ | |
| 6055 sata_decode_device_error(spx, sense); | |
| 6056 break; | |
| 6057 } | |
| 6058 /* No extended sense key - no info available */ | |
| 6059 break; | |
| 6060 | |
| 6061 case SATA_PKT_TIMEOUT: | |
| 6062 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ | |
| 6063 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 6064 /* No extended sense key ? */ | |
| 6065 break; | |
| 6066 | |
| 6067 case SATA_PKT_ABORTED: | |
| 6068 scsipkt->pkt_reason = CMD_ABORTED; | |
| 6069 /* No extended sense key ? */ | |
| 6070 break; | |
| 6071 | |
| 6072 case SATA_PKT_RESET: | |
| 6073 /* pkt aborted by an explicit reset from a host */ | |
| 6074 scsipkt->pkt_reason = CMD_RESET; | |
| 6075 break; | |
| 6076 | |
| 6077 default: | |
| 6078 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 6079 "sata_txlt_nodata_cmd_completion: " | |
| 6080 "invalid packet completion reason %d", | |
| 6081 sata_pkt->satapkt_reason)); | |
| 6082 scsipkt->pkt_reason = CMD_TRAN_ERR; | |
| 6083 break; | |
| 6084 } | |
| 6085 | |
| 6086 } | |
| 6087 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 6088 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 6089 | |
| 6090 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 6091 scsipkt->pkt_comp != NULL) | |
| 6092 /* scsi callback required */ | |
| 6093 (*scsipkt->pkt_comp)(scsipkt); | |
| 6094 } | |
| 6095 | |
| 6096 | |
| 6097 /* | |
| 6098 * Build Mode sense R/W recovery page | |
| 6099 * NOT IMPLEMENTED | |
| 6100 */ | |
| 6101 | |
| 6102 static int | |
| 6103 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6104 { | |
| 6105 #ifndef __lock_lint | |
| 6106 _NOTE(ARGUNUSED(sdinfo)) | |
| 6107 _NOTE(ARGUNUSED(pcntrl)) | |
| 6108 _NOTE(ARGUNUSED(buf)) | |
| 6109 #endif | |
| 6110 return (0); | |
| 6111 } | |
| 6112 | |
| 6113 /* | |
| 6114 * Build Mode sense caching page - scsi-3 implementation. | |
| 6115 * Page length distinguishes previous format from scsi-3 format. | |
| 6116 * buf must have space for 0x12 bytes. | |
| 6117 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. | |
| 6118 * | |
| 6119 */ | |
| 6120 static int | |
| 6121 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6122 { | |
| 6123 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; | |
| 6124 sata_id_t *sata_id = &sdinfo->satadrv_id; | |
| 6125 | |
| 6126 /* | |
| 6127 * Most of the fields are set to 0, being not supported and/or disabled | |
| 6128 */ | |
| 6129 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); | |
| 6130 | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6131 /* Saved paramters not supported */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6132 if (pcntrl == 3) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6133 return (0); |
| 1258 | 6134 if (pcntrl == 0 || pcntrl == 2) { |
| 6135 /* | |
| 6136 * For now treat current and default parameters as same | |
| 6137 * That may have to change, if target driver will complain | |
| 6138 */ | |
| 6139 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ | |
| 6140 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; | |
| 6141 | |
| 6142 if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 6143 !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) { | |
| 6144 page->dra = 1; /* Read Ahead disabled */ | |
| 6145 page->rcd = 1; /* Read Cache disabled */ | |
| 6146 } | |
| 6147 if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) && | |
| 6148 (sata_id->ai_features85 & SATA_WRITE_CACHE)) | |
| 6149 page->wce = 1; /* Write Cache enabled */ | |
| 6150 } else { | |
| 6151 /* Changeable parameters */ | |
| 6152 page->mode_page.code = MODEPAGE_CACHING; | |
| 6153 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; | |
| 6154 if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) { | |
| 6155 page->dra = 1; | |
| 6156 page->rcd = 1; | |
| 6157 } | |
| 6158 if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE) | |
| 6159 page->wce = 1; | |
| 6160 } | |
| 6161 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + | |
| 6162 sizeof (struct mode_page)); | |
| 6163 } | |
| 6164 | |
| 6165 /* | |
| 6166 * Build Mode sense exception cntrl page | |
| 6167 */ | |
| 6168 static int | |
| 6169 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6170 { | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6171 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
|
6172 sata_id_t *sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6173 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6174 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6175 * 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
|
6176 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6177 bzero(buf, PAGELENGTH_INFO_EXCPT); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6178 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6179 page->mode_page.code = MODEPAGE_INFO_EXCPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6180 page->mode_page.length = PAGELENGTH_INFO_EXCPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6181 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6182 /* Indicate that this is page is saveable */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6183 page->mode_page.ps = 1; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6184 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6185 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6186 * 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
|
6187 * 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
|
6188 * 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
|
6189 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6190 if (pcntrl != 1) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6191 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
|
6192 page->mrie = MRIE_ONLY_ON_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6193 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6194 else |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6195 page->dexcpt = 1; /* Only changeable parameter */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6196 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6197 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page)); |
| 1258 | 6198 } |
| 6199 | |
| 6200 | |
| 6201 /* | |
| 6202 * Build Mode sense power condition page | |
| 6203 * NOT IMPLEMENTED. | |
| 6204 */ | |
| 6205 static int | |
| 6206 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6207 { | |
| 6208 #ifndef __lock_lint | |
| 6209 _NOTE(ARGUNUSED(sdinfo)) | |
| 6210 _NOTE(ARGUNUSED(pcntrl)) | |
| 6211 _NOTE(ARGUNUSED(buf)) | |
| 6212 #endif | |
| 6213 return (0); | |
| 6214 } | |
| 6215 | |
| 6216 | |
| 6217 /* | |
| 6218 * Process mode select caching page 8 (scsi3 format only). | |
| 6219 * Read Ahead (same as read cache) and Write Cache may be turned on and off | |
| 6220 * if these features are supported by the device. If these features are not | |
| 6221 * supported, quietly ignore them. | |
| 6222 * This function fails only if the SET FEATURE command sent to | |
| 6223 * the device fails. The page format is not varified, assuming that the | |
| 6224 * target driver operates correctly - if parameters length is too short, | |
| 6225 * we just drop the page. | |
| 6226 * Two command may be sent if both Read Cache/Read Ahead and Write Cache | |
| 6227 * setting have to be changed. | |
| 6228 * SET FEATURE command is executed synchronously, i.e. we wait here until | |
| 6229 * it is completed, regardless of the scsi pkt directives. | |
| 6230 * | |
| 6231 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. | |
| 6232 * changing DRA will change RCD. | |
| 6233 * | |
| 6234 * More than one SATA command may be executed to perform operations specified | |
| 6235 * by mode select pages. The first error terminates further execution. | |
| 6236 * Operations performed successully are not backed-up in such case. | |
| 6237 * | |
| 6238 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. | |
| 6239 * If operation resulted in changing device setup, dmod flag should be set to | |
| 6240 * one (1). If parameters were not changed, dmod flag should be set to 0. | |
| 6241 * Upon return, if operation required sending command to the device, the rval | |
| 6242 * should be set to the value returned by sata_hba_start. If operation | |
| 6243 * did not require device access, rval should be set to TRAN_ACCEPT. | |
| 6244 * The pagelen should be set to the length of the page. | |
| 6245 * | |
| 6246 * This function has to be called with a port mutex held. | |
| 6247 * | |
| 6248 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. | |
| 6249 */ | |
| 6250 int | |
| 6251 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, | |
| 6252 int parmlen, int *pagelen, int *rval, int *dmod) | |
| 6253 { | |
| 6254 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6255 sata_drive_info_t *sdinfo; | |
| 6256 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 6257 sata_id_t *sata_id; | |
| 6258 struct scsi_extended_sense *sense; | |
| 6259 int wce, dra; /* Current settings */ | |
| 6260 | |
| 6261 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 6262 &spx->txlt_sata_pkt->satapkt_device); | |
| 6263 sata_id = &sdinfo->satadrv_id; | |
| 6264 *dmod = 0; | |
| 6265 | |
| 6266 /* Verify parameters length. If too short, drop it */ | |
| 6267 if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + | |
| 6268 sizeof (struct mode_page) < parmlen) { | |
| 6269 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 6270 sense = sata_arq_sense(spx); | |
| 6271 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 6272 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; | |
| 6273 *pagelen = parmlen; | |
| 6274 *rval = TRAN_ACCEPT; | |
| 6275 return (SATA_FAILURE); | |
| 6276 } | |
| 6277 | |
| 6278 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); | |
| 6279 | |
| 6280 /* | |
| 6281 * We can manipulate only write cache and read ahead | |
| 6282 * (read cache) setting. | |
| 6283 */ | |
| 6284 if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 6285 !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 6286 /* | |
| 6287 * None of the features is supported - ignore | |
| 6288 */ | |
| 6289 *rval = TRAN_ACCEPT; | |
| 6290 return (SATA_SUCCESS); | |
| 6291 } | |
| 6292 | |
| 6293 /* Current setting of Read Ahead (and Read Cache) */ | |
| 6294 if (sata_id->ai_features85 & SATA_LOOK_AHEAD) | |
| 6295 dra = 0; /* 0 == not disabled */ | |
| 6296 else | |
| 6297 dra = 1; | |
| 6298 /* Current setting of Write Cache */ | |
| 6299 if (sata_id->ai_features85 & SATA_WRITE_CACHE) | |
| 6300 wce = 1; | |
| 6301 else | |
| 6302 wce = 0; | |
| 6303 | |
| 6304 if (page->dra == dra && page->wce == wce && page->rcd == dra) { | |
| 6305 /* nothing to do */ | |
| 6306 *rval = TRAN_ACCEPT; | |
| 6307 return (SATA_SUCCESS); | |
| 6308 } | |
| 6309 /* | |
| 6310 * Need to flip some setting | |
| 6311 * Set-up Internal SET FEATURES command(s) | |
| 6312 */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6313 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
| 1258 | 6314 scmd->satacmd_addr_type = 0; |
| 6315 scmd->satacmd_device_reg = 0; | |
| 6316 scmd->satacmd_status_reg = 0; | |
| 6317 scmd->satacmd_error_reg = 0; | |
| 6318 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; | |
| 6319 if (page->dra != dra || page->rcd != dra) { | |
| 6320 /* Need to flip read ahead setting */ | |
| 6321 if (dra == 0) | |
| 6322 /* Disable read ahead / read cache */ | |
| 6323 scmd->satacmd_features_reg = | |
| 6324 SATAC_SF_DISABLE_READ_AHEAD; | |
| 6325 else | |
| 6326 /* Enable read ahead / read cache */ | |
| 6327 scmd->satacmd_features_reg = | |
| 6328 SATAC_SF_ENABLE_READ_AHEAD; | |
| 6329 | |
| 6330 /* Transfer command to HBA */ | |
| 6331 if (sata_hba_start(spx, rval) != 0) | |
| 6332 /* | |
| 6333 * Pkt not accepted for execution. | |
| 6334 */ | |
| 6335 return (SATA_FAILURE); | |
| 6336 | |
| 6337 *dmod = 1; | |
| 6338 | |
| 6339 /* Now process return */ | |
| 6340 if (spx->txlt_sata_pkt->satapkt_reason != | |
| 6341 SATA_PKT_COMPLETED) { | |
| 6342 goto failure; /* Terminate */ | |
| 6343 } | |
| 6344 } | |
| 6345 | |
| 6346 /* Note that the packet is not removed, so it could be re-used */ | |
| 6347 if (page->wce != wce) { | |
| 6348 /* Need to flip Write Cache setting */ | |
| 6349 if (page->wce == 1) | |
| 6350 /* Enable write cache */ | |
| 6351 scmd->satacmd_features_reg = | |
| 6352 SATAC_SF_ENABLE_WRITE_CACHE; | |
| 6353 else | |
| 6354 /* Disable write cache */ | |
| 6355 scmd->satacmd_features_reg = | |
| 6356 SATAC_SF_DISABLE_WRITE_CACHE; | |
| 6357 | |
| 6358 /* Transfer command to HBA */ | |
| 6359 if (sata_hba_start(spx, rval) != 0) | |
| 6360 /* | |
| 6361 * Pkt not accepted for execution. | |
| 6362 */ | |
| 6363 return (SATA_FAILURE); | |
| 6364 | |
| 6365 *dmod = 1; | |
| 6366 | |
| 6367 /* Now process return */ | |
| 6368 if (spx->txlt_sata_pkt->satapkt_reason != | |
| 6369 SATA_PKT_COMPLETED) { | |
| 6370 goto failure; | |
| 6371 } | |
| 6372 } | |
| 6373 return (SATA_SUCCESS); | |
| 6374 | |
| 6375 failure: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6376 sata_xlate_errors(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6377 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6378 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6379 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6380 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6381 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6382 * Process mode select informational exceptions control page 0x1c |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6383 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6384 * The only changeable bit is dexcpt (disable exceptions). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6385 * MRIE (method of reporting informational exceptions) must be |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6386 * "only on request". |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6387 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6388 * 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
|
6389 * 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
|
6390 * 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
|
6391 * 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
|
6392 * 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
|
6393 * 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
|
6394 * 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
|
6395 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6396 * 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
|
6397 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6398 * 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
|
6399 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6400 static int |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6401 sata_mode_select_page_1c( |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6402 sata_pkt_txlate_t *spx, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6403 struct mode_info_excpt_page *page, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6404 int parmlen, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6405 int *pagelen, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6406 int *rval, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6407 int *dmod) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6408 { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6409 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6410 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
|
6411 sata_drive_info_t *sdinfo; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6412 sata_id_t *sata_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6413 struct scsi_extended_sense *sense; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6414 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6415 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
|
6416 &spx->txlt_sata_pkt->satapkt_device); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6417 sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6418 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6419 *dmod = 0; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6420 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6421 /* Verify parameters length. If too short, drop it */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6422 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
|
6423 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
|
6424 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6425 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6426 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6427 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
|
6428 *pagelen = parmlen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6429 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6430 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6431 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6432 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6433 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6434 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6435 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6436 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6437 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6438 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6439 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
|
6440 *pagelen = parmlen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6441 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6442 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6443 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6444 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6445 /* 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
|
6446 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
|
6447 /* nothing to do */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6448 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6449 return (SATA_SUCCESS); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6450 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6451 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6452 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
|
6453 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6454 /* Build SMART_ENABLE or SMART_DISABLE command */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6455 scmd->satacmd_addr_type = 0; /* N/A */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6456 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
|
6457 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
|
6458 scmd->satacmd_features_reg = page->dexcpt ? |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6459 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6460 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6461 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6462 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6463 /* Transfer command to HBA */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6464 if (sata_hba_start(spx, rval) != 0) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6465 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6466 * Pkt not accepted for execution. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6467 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6468 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6469 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6470 *dmod = 1; /* At least may have been modified */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6471 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6472 /* Now process return */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6473 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
|
6474 return (SATA_SUCCESS); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6475 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6476 /* Packet did not complete successfully */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6477 sata_xlate_errors(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6478 |
| 1258 | 6479 return (SATA_FAILURE); |
| 6480 } | |
| 6481 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6482 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6483 * 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
|
6484 * SCSI LOG SENSE page 0 (supported log pages) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6485 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6486 * 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
|
6487 * (supported log pages, self-test results, informational exceptions |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6488 * and Sun vendor specific ATA SMART data). |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6489 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6490 * 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
|
6491 * in which to create the page information. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6492 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6493 * 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
|
6494 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6495 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6496 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
|
6497 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6498 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6499 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
|
6500 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
|
6501 sata_id_t *sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6502 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6503 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6504 lpp->param_code[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6505 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
|
6506 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6507 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6508 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6509 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
|
6510 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6511 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6512 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6513 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6514 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6515 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6516 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6517 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6518 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6519 lpp->param_len = num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6520 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6521 return ((&lpp->param_values[0] - (uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6522 num_pages_supported); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6523 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6524 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6525 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6526 * 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
|
6527 * SCSI LOG SENSE page 0x10 (self-test results) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6528 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6529 * 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
|
6530 * 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
|
6531 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6532 * 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
|
6533 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6534 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6535 sata_build_lsense_page_10( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6536 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6537 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6538 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6539 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6540 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6541 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6542 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6543 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
|
6544 struct smart_ext_selftest_log *ext_selftest_log; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6545 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6546 ext_selftest_log = kmem_zalloc( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6547 sizeof (struct smart_ext_selftest_log), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6548 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6549 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
|
6550 ext_selftest_log, 0); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6551 if (rval == 0) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6552 int index, start_index; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6553 struct smart_ext_selftest_log_entry *entry; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6554 static const struct smart_ext_selftest_log_entry empty = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6555 {0}; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6556 uint16_t block_num; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6557 int count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6558 boolean_t only_one_block = B_FALSE; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6559 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6560 index = ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6561 smart_ext_selftest_log_index[0]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6562 index |= ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6563 smart_ext_selftest_log_index[1] << 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6564 if (index == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6565 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6566 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6567 --index; /* Correct for 0 origin */ |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6568 start_index = index; /* remember where we started */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6569 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
|
6570 if (block_num != 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6571 rval = sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6572 sata_hba_inst, sdinfo, ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6573 block_num); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6574 if (rval != 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6575 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6576 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6577 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6578 entry = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6579 &ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6580 smart_ext_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6581 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6582 for (count = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6583 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6584 ++count) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6585 uint8_t status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6586 uint8_t code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6587 uint8_t sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6588 uint8_t add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6589 uint8_t add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6590 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6591 /* If this is an unused entry, we are done */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6592 if (bcmp(entry, &empty, sizeof (empty)) == 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6593 /* Broken firmware on some disks */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6594 if (index + 1 == |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6595 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6596 --entry; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6597 --index; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6598 if (bcmp(entry, &empty, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6599 sizeof (empty)) == 0) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6600 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6601 } else |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6602 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6603 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6604 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6605 if (only_one_block && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6606 start_index == index) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6607 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6608 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6609 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6610 lpp->param_code[1] = count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6611 lpp->param_ctrl_flags = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6612 LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6613 lpp->param_len = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6614 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6615 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6616 status = entry->smart_ext_selftest_log_status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6617 status >>= 4; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6618 switch (status) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6619 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6620 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6621 sense_key = KEY_NO_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6622 add_sense_code = SD_SCSI_NO_ADD_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6623 add_sense_code_qual = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6624 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6625 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6626 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6627 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6628 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6629 add_sense_code_qual = SCSI_COMPONENT_81; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6630 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6631 case 2: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6632 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6633 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6634 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6635 add_sense_code_qual = SCSI_COMPONENT_82; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6636 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6637 case 3: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6638 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6639 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6640 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6641 add_sense_code_qual = SCSI_COMPONENT_83; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6642 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6643 case 4: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6644 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6645 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6646 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6647 add_sense_code_qual = SCSI_COMPONENT_84; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6648 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6649 case 5: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6650 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6651 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6652 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6653 add_sense_code_qual = SCSI_COMPONENT_85; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6654 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6655 case 6: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6656 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6657 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6658 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6659 add_sense_code_qual = SCSI_COMPONENT_86; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6660 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6661 case 7: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6662 sense_key = KEY_MEDIUM_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6663 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6664 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6665 add_sense_code_qual = SCSI_COMPONENT_87; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6666 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6667 case 8: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6668 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6669 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6670 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6671 add_sense_code_qual = SCSI_COMPONENT_88; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6672 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6673 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6674 code = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6675 status |= (code << 4); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6676 lpp->param_values[0] = status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6677 lpp->param_values[1] = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6678 lpp->param_values[2] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6679 smart_ext_selftest_log_timestamp[1]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6680 lpp->param_values[3] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6681 smart_ext_selftest_log_timestamp[0]; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6682 if (status != 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6683 lpp->param_values[4] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6684 lpp->param_values[5] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6685 lpp->param_values[6] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6686 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6687 [5]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6688 lpp->param_values[7] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6689 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6690 [4]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6691 lpp->param_values[8] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6692 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6693 [3]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6694 lpp->param_values[9] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6695 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6696 [2]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6697 lpp->param_values[10] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6698 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6699 [1]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6700 lpp->param_values[11] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6701 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6702 [0]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6703 } else { /* No bad block address */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6704 lpp->param_values[4] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6705 lpp->param_values[5] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6706 lpp->param_values[6] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6707 lpp->param_values[7] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6708 lpp->param_values[8] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6709 lpp->param_values[9] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6710 lpp->param_values[10] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6711 lpp->param_values[11] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6712 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6713 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6714 lpp->param_values[12] = sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6715 lpp->param_values[13] = add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6716 lpp->param_values[14] = add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6717 lpp->param_values[15] = 0; /* undefined */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6718 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6719 lpp = (struct log_parameter *) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6720 (((uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6721 SCSI_LOG_PARAM_HDR_LEN + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6722 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6723 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6724 --index; /* Back up to previous entry */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6725 if (index < 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6726 if (block_num > 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6727 --block_num; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6728 } else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6729 struct read_log_ext_directory |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6730 logdir; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6731 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6732 rval = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6733 sata_read_log_ext_directory( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6734 sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6735 &logdir); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6736 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6737 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6738 if ((logdir.read_log_ext_vers |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6739 [0] == 0) && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6740 (logdir.read_log_ext_vers |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6741 [1] == 0)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6742 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6743 block_num = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6744 logdir.read_log_ext_nblks |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6745 [EXT_SMART_SELFTEST_LOG_PAGE |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6746 - 1][0]; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6747 block_num |= logdir. |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6748 read_log_ext_nblks |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6749 [EXT_SMART_SELFTEST_LOG_PAGE |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6750 - 1][1] << 8; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6751 --block_num; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6752 only_one_block = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6753 (block_num == 0); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6754 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6755 rval = sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6756 sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6757 ext_selftest_log, block_num); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6758 if (rval != 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6759 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6760 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6761 index = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6762 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6763 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6764 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6765 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6766 entry = &ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6767 smart_ext_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6768 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6769 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6770 out: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6771 kmem_free(ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6772 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6773 } else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6774 struct smart_selftest_log *selftest_log; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6775 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6776 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
|
6777 KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6778 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6779 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
|
6780 selftest_log); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6781 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6782 if (rval == 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6783 int index; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6784 int count; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6785 struct smart_selftest_log_entry *entry; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6786 static const struct smart_selftest_log_entry empty = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6787 { 0 }; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6788 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6789 index = selftest_log->smart_selftest_log_index; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6790 if (index == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6791 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6792 --index; /* Correct for 0 origin */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6793 entry = &selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6794 smart_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6795 for (count = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6796 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6797 ++count) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6798 uint8_t status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6799 uint8_t code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6800 uint8_t sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6801 uint8_t add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6802 uint8_t add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6803 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6804 if (bcmp(entry, &empty, sizeof (empty)) == 0) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6805 goto done; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6806 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6807 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6808 lpp->param_code[1] = count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6809 lpp->param_ctrl_flags = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6810 LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6811 lpp->param_len = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6812 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6813 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6814 status = entry->smart_selftest_log_status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6815 status >>= 4; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6816 switch (status) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6817 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6818 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6819 sense_key = KEY_NO_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6820 add_sense_code = SD_SCSI_NO_ADD_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6821 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6822 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6823 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6824 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6825 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6826 add_sense_code_qual = SCSI_COMPONENT_81; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6827 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6828 case 2: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6829 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6830 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6831 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6832 add_sense_code_qual = SCSI_COMPONENT_82; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6833 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6834 case 3: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6835 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6836 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6837 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6838 add_sense_code_qual = SCSI_COMPONENT_83; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6839 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6840 case 4: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6841 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6842 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6843 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6844 add_sense_code_qual = SCSI_COMPONENT_84; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6845 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6846 case 5: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6847 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6848 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6849 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6850 add_sense_code_qual = SCSI_COMPONENT_85; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6851 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6852 case 6: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6853 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6854 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6855 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6856 add_sense_code_qual = SCSI_COMPONENT_86; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6857 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6858 case 7: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6859 sense_key = KEY_MEDIUM_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6860 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6861 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6862 add_sense_code_qual = SCSI_COMPONENT_87; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6863 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6864 case 8: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6865 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6866 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6867 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6868 add_sense_code_qual = SCSI_COMPONENT_88; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6869 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6870 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6871 code = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6872 status |= (code << 4); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6873 lpp->param_values[0] = status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6874 lpp->param_values[1] = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6875 lpp->param_values[2] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6876 smart_selftest_log_timestamp[1]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6877 lpp->param_values[3] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6878 smart_selftest_log_timestamp[0]; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6879 if (status != 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6880 lpp->param_values[4] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6881 lpp->param_values[5] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6882 lpp->param_values[6] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6883 lpp->param_values[7] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6884 lpp->param_values[8] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6885 smart_selftest_log_failing_lba[3]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6886 lpp->param_values[9] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6887 smart_selftest_log_failing_lba[2]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6888 lpp->param_values[10] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6889 smart_selftest_log_failing_lba[1]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6890 lpp->param_values[11] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6891 smart_selftest_log_failing_lba[0]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6892 } else { /* No block address */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6893 lpp->param_values[4] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6894 lpp->param_values[5] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6895 lpp->param_values[6] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6896 lpp->param_values[7] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6897 lpp->param_values[8] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6898 lpp->param_values[9] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6899 lpp->param_values[10] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6900 lpp->param_values[11] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6901 } |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6902 lpp->param_values[12] = sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6903 lpp->param_values[13] = add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6904 lpp->param_values[14] = add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6905 lpp->param_values[15] = 0; /* undefined */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6906 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6907 lpp = (struct log_parameter *) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6908 (((uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6909 SCSI_LOG_PARAM_HDR_LEN + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6910 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6911 --index; /* back up to previous entry */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6912 if (index < 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6913 index = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6914 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6915 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6916 entry = &selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6917 smart_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6918 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6919 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6920 done: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6921 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
|
6922 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6923 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6924 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
|
6925 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6926 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6927 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6928 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6929 * 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
|
6930 * SCSI LOG SENSE page 0x10 (informational exceptions) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6931 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6932 * 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
|
6933 * 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
|
6934 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6935 * 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
|
6936 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6937 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6938 sata_build_lsense_page_2f( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6939 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6940 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6941 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6942 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6943 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6944 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6945 uint8_t *smart_data; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6946 uint8_t temp; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6947 sata_id_t *sata_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6948 #define SMART_NO_TEMP 0xff |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6949 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6950 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6951 lpp->param_code[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6952 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
|
6953 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6954 /* 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
|
6955 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
|
6956 switch (rval) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6957 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6958 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6959 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6960 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6961 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6962 case -1: /* failed to get data */ |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6963 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
|
6964 lpp->param_values[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6965 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6966 #if defined(SATA_DEBUG) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6967 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6968 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
|
6969 /* NOTREACHED */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6970 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6971 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6972 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6973 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6974 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
|
6975 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6976 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6977 /* Now get the temperature */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6978 smart_data = kmem_zalloc(512, KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6979 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
|
6980 SCT_STATUS_LOG_PAGE, 1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6981 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6982 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6983 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6984 temp = smart_data[200]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6985 if (temp & 0x80) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6986 if (temp & 0x7f) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6987 temp = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6988 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6989 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6990 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6991 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6992 kmem_free(smart_data, 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6993 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6994 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6995 lpp->param_values[2] = temp; /* most recent temperature */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6996 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
|
6997 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6998 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6999 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7000 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7001 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
|
7002 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7003 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7004 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7005 * 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
|
7006 * 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
|
7007 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7008 * 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
|
7009 * 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
|
7010 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7011 * 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
|
7012 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7013 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7014 sata_build_lsense_page_30( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7015 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7016 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7017 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7018 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7019 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
|
7020 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7021 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7022 /* Now do the SMART READ DATA */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7023 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
|
7024 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7025 return (0); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7026 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7027 return (sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7028 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
7029 |
| 1258 | 7030 |
| 7031 | |
| 7032 | |
| 7033 | |
| 7034 /* ************************** LOCAL FUNCTIONS ************************** */ | |
| 7035 | |
| 7036 /* | |
| 7037 * Validate sata_tran info | |
| 7038 * SATA_FAILURE returns if structure is inconsistent or structure revision | |
| 7039 * does not match one used by the framework. | |
| 7040 * | |
| 7041 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains | |
| 7042 * required function pointers. | |
| 7043 * Returns SATA_FAILURE otherwise. | |
| 7044 */ | |
| 7045 static int | |
| 7046 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) | |
| 7047 { | |
| 7048 if (sata_tran->sata_tran_hba_rev != SATA_TRAN_HBA_REV) { | |
| 7049 sata_log(NULL, CE_WARN, | |
| 7050 "sata: invalid sata_hba_tran version %d for driver %s", | |
| 7051 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); | |
| 7052 return (SATA_FAILURE); | |
| 7053 } | |
| 7054 | |
| 7055 if (dip != sata_tran->sata_tran_hba_dip) { | |
| 7056 SATA_LOG_D((NULL, CE_WARN, | |
| 7057 "sata: inconsistent sata_tran_hba_dip " | |
| 7058 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); | |
| 7059 return (SATA_FAILURE); | |
| 7060 } | |
| 7061 | |
| 7062 if (sata_tran->sata_tran_probe_port == NULL || | |
| 7063 sata_tran->sata_tran_start == NULL || | |
| 7064 sata_tran->sata_tran_abort == NULL || | |
| 7065 sata_tran->sata_tran_reset_dport == NULL) { | |
| 7066 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " | |
| 7067 "required functions")); | |
| 7068 } | |
| 7069 return (SATA_SUCCESS); | |
| 7070 } | |
| 7071 | |
| 7072 /* | |
| 7073 * Remove HBA instance from sata_hba_list. | |
| 7074 */ | |
| 7075 static void | |
| 7076 sata_remove_hba_instance(dev_info_t *dip) | |
| 7077 { | |
| 7078 sata_hba_inst_t *sata_hba_inst; | |
| 7079 | |
| 7080 mutex_enter(&sata_mutex); | |
| 7081 for (sata_hba_inst = sata_hba_list; | |
| 7082 sata_hba_inst != (struct sata_hba_inst *)NULL; | |
| 7083 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 7084 if (sata_hba_inst->satahba_dip == dip) | |
| 7085 break; | |
| 7086 } | |
| 7087 | |
| 7088 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { | |
| 7089 #ifdef SATA_DEBUG | |
| 7090 cmn_err(CE_WARN, "sata_remove_hba_instance: " | |
| 7091 "unknown HBA instance\n"); | |
| 7092 #endif | |
| 7093 ASSERT(FALSE); | |
| 7094 } | |
| 7095 if (sata_hba_inst == sata_hba_list) { | |
| 7096 sata_hba_list = sata_hba_inst->satahba_next; | |
| 7097 if (sata_hba_list) { | |
| 7098 sata_hba_list->satahba_prev = | |
| 7099 (struct sata_hba_inst *)NULL; | |
| 7100 } | |
| 7101 if (sata_hba_inst == sata_hba_list_tail) { | |
| 7102 sata_hba_list_tail = NULL; | |
| 7103 } | |
| 7104 } else if (sata_hba_inst == sata_hba_list_tail) { | |
| 7105 sata_hba_list_tail = sata_hba_inst->satahba_prev; | |
| 7106 if (sata_hba_list_tail) { | |
| 7107 sata_hba_list_tail->satahba_next = | |
| 7108 (struct sata_hba_inst *)NULL; | |
| 7109 } | |
| 7110 } else { | |
| 7111 sata_hba_inst->satahba_prev->satahba_next = | |
| 7112 sata_hba_inst->satahba_next; | |
| 7113 sata_hba_inst->satahba_next->satahba_prev = | |
| 7114 sata_hba_inst->satahba_prev; | |
| 7115 } | |
| 7116 mutex_exit(&sata_mutex); | |
| 7117 } | |
| 7118 | |
| 7119 | |
| 7120 | |
| 7121 | |
| 7122 | |
| 7123 /* | |
| 7124 * Probe all SATA ports of the specified HBA instance. | |
| 7125 * This function is called only from sata_hba_attach(). It does not have to | |
| 7126 * be protected by controller mutex, because the hba_attached flag is not set | |
| 7127 * yet and no one would be touching this HBA instance other then this thread. | |
| 7128 * Determines if port is active and what type of the device is attached | |
| 7129 * (if any). Allocates necessary structures for each port. | |
| 7130 * Creates attachment point minor node for each non-failed port. | |
| 7131 */ | |
| 7132 | |
| 7133 static void | |
| 7134 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) | |
| 7135 { | |
| 7136 dev_info_t *dip = SATA_DIP(sata_hba_inst); | |
| 7137 int ncport, npmport; | |
| 7138 sata_cport_info_t *cportinfo; | |
| 7139 sata_drive_info_t *drive; | |
| 7140 sata_pmult_info_t *pminfo; | |
| 7141 sata_pmport_info_t *pmportinfo; | |
| 7142 sata_device_t sata_device; | |
| 7143 int rval; | |
| 7144 dev_t minor_number; | |
| 7145 char name[16]; | |
| 7146 | |
| 7147 /* | |
| 7148 * Probe controller ports first, to find port status and | |
| 7149 * any port multiplier attached. | |
| 7150 */ | |
| 7151 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 7152 /* allocate cport structure */ | |
| 7153 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); | |
| 7154 ASSERT(cportinfo != NULL); | |
| 7155 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 7156 | |
| 7157 mutex_enter(&cportinfo->cport_mutex); | |
| 7158 | |
| 7159 cportinfo->cport_addr.cport = ncport; | |
| 7160 cportinfo->cport_addr.pmport = 0; | |
| 7161 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; | |
| 7162 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; | |
| 7163 cportinfo->cport_state |= SATA_STATE_PROBING; | |
| 7164 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; | |
| 7165 | |
| 7166 /* | |
| 7167 * Regardless if a port is usable or not, create | |
| 7168 * an attachment point | |
| 7169 */ | |
| 7170 mutex_exit(&cportinfo->cport_mutex); | |
| 7171 minor_number = | |
| 7172 SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0); | |
| 7173 (void) sprintf(name, "%d", ncport); | |
| 7174 if (ddi_create_minor_node(dip, name, S_IFCHR, | |
| 7175 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != | |
| 7176 DDI_SUCCESS) { | |
| 7177 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " | |
| 7178 "cannot create sata attachment point for port %d", | |
| 7179 ncport); | |
| 7180 } | |
| 7181 | |
| 7182 /* Probe port */ | |
| 7183 sata_device.satadev_addr.cport = ncport; | |
| 7184 sata_device.satadev_addr.pmport = 0; | |
| 7185 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 7186 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 7187 | |
| 7188 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7189 (dip, &sata_device); | |
| 7190 | |
| 7191 mutex_enter(&cportinfo->cport_mutex); | |
| 7192 sata_update_port_scr(&cportinfo->cport_scr, &sata_device); | |
| 7193 if (rval != SATA_SUCCESS) { | |
| 7194 /* Something went wrong? Fail the port */ | |
| 7195 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 7196 mutex_exit(&cportinfo->cport_mutex); | |
| 7197 continue; | |
| 7198 } | |
| 7199 cportinfo->cport_state &= ~SATA_STATE_PROBING; | |
| 7200 cportinfo->cport_state |= SATA_STATE_PROBED; | |
| 7201 cportinfo->cport_dev_type = sata_device.satadev_type; | |
| 7202 | |
| 7203 cportinfo->cport_state |= SATA_STATE_READY; | |
| 7204 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { | |
| 7205 mutex_exit(&cportinfo->cport_mutex); | |
| 7206 continue; | |
| 7207 } | |
| 7208 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 7209 /* | |
| 7210 * There is some device attached. | |
| 7211 * Allocate device info structure | |
| 7212 */ | |
| 7213 mutex_exit(&cportinfo->cport_mutex); | |
| 7214 drive = kmem_zalloc(sizeof (sata_drive_info_t), | |
| 7215 KM_SLEEP); | |
| 7216 mutex_enter(&cportinfo->cport_mutex); | |
| 7217 SATA_CPORTINFO_DRV_INFO(cportinfo) = drive; | |
| 7218 drive->satadrv_addr = cportinfo->cport_addr; | |
| 7219 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; | |
| 7220 drive->satadrv_type = cportinfo->cport_dev_type; | |
| 7221 drive->satadrv_state = SATA_STATE_UNKNOWN; | |
| 7222 } else { | |
| 7223 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); | |
| 7224 mutex_exit(&cportinfo->cport_mutex); | |
| 7225 pminfo = kmem_zalloc(sizeof (sata_pmult_info_t), | |
| 7226 KM_SLEEP); | |
| 7227 mutex_enter(&cportinfo->cport_mutex); | |
| 7228 ASSERT(pminfo != NULL); | |
| 7229 SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo; | |
| 7230 pminfo->pmult_addr.cport = cportinfo->cport_addr.cport; | |
| 7231 pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT; | |
| 7232 pminfo->pmult_addr.qual = SATA_ADDR_PMPORT; | |
| 7233 pminfo->pmult_num_dev_ports = | |
| 7234 sata_device.satadev_add_info; | |
| 7235 mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER, | |
| 7236 NULL); | |
| 7237 pminfo->pmult_state = SATA_STATE_PROBING; | |
| 7238 | |
| 7239 /* Probe Port Multiplier ports */ | |
| 7240 for (npmport = 0; | |
| 7241 npmport < pminfo->pmult_num_dev_ports; | |
| 7242 npmport++) { | |
| 7243 mutex_exit(&cportinfo->cport_mutex); | |
| 7244 pmportinfo = kmem_zalloc( | |
| 7245 sizeof (sata_pmport_info_t), KM_SLEEP); | |
| 7246 mutex_enter(&cportinfo->cport_mutex); | |
| 7247 ASSERT(pmportinfo != NULL); | |
| 7248 pmportinfo->pmport_addr.cport = ncport; | |
| 7249 pmportinfo->pmport_addr.pmport = npmport; | |
| 7250 pmportinfo->pmport_addr.qual = | |
| 7251 SATA_ADDR_PMPORT; | |
| 7252 pminfo->pmult_dev_port[npmport] = pmportinfo; | |
| 7253 mutex_init(&pmportinfo->pmport_mutex, NULL, | |
| 7254 MUTEX_DRIVER, NULL); | |
| 7255 | |
| 7256 sata_device.satadev_addr.pmport = npmport; | |
| 7257 sata_device.satadev_addr.qual = | |
| 7258 SATA_ADDR_PMPORT; | |
| 7259 | |
| 7260 mutex_exit(&cportinfo->cport_mutex); | |
| 7261 /* Create an attachment point */ | |
| 7262 minor_number = SATA_MAKE_AP_MINOR( | |
| 7263 ddi_get_instance(dip), ncport, npmport, 1); | |
| 7264 (void) sprintf(name, "%d.%d", ncport, npmport); | |
| 7265 if (ddi_create_minor_node(dip, name, S_IFCHR, | |
| 7266 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, | |
| 7267 0) != DDI_SUCCESS) { | |
| 7268 sata_log(sata_hba_inst, CE_WARN, | |
| 7269 "sata_hba_attach: " | |
| 7270 "cannot create sata attachment " | |
| 7271 "point for port %d pmult port %d", | |
| 7272 ncport, npmport); | |
| 7273 } | |
| 7274 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7275 (dip, &sata_device); | |
| 7276 mutex_enter(&cportinfo->cport_mutex); | |
| 7277 | |
| 7278 /* sata_update_port_info() */ | |
| 7279 sata_update_port_scr(&pmportinfo->pmport_scr, | |
| 7280 &sata_device); | |
| 7281 | |
| 7282 if (rval != SATA_SUCCESS) { | |
| 7283 pmportinfo->pmport_state = | |
| 7284 SATA_PSTATE_FAILED; | |
| 7285 continue; | |
| 7286 } | |
| 7287 pmportinfo->pmport_state &= | |
| 7288 ~SATA_STATE_PROBING; | |
| 7289 pmportinfo->pmport_state |= SATA_STATE_PROBED; | |
| 7290 pmportinfo->pmport_dev_type = | |
| 7291 sata_device.satadev_type; | |
| 7292 | |
| 7293 pmportinfo->pmport_state |= SATA_STATE_READY; | |
| 7294 if (pmportinfo->pmport_dev_type == | |
| 7295 SATA_DTYPE_NONE) | |
| 7296 continue; | |
| 7297 | |
| 7298 /* Port multipliers cannot be chained */ | |
| 7299 ASSERT(pmportinfo->pmport_dev_type != | |
| 7300 SATA_DTYPE_PMULT); | |
| 7301 /* | |
| 7302 * There is something attached to Port | |
| 7303 * Multiplier device port | |
| 7304 * Allocate device info structure | |
| 7305 */ | |
| 7306 mutex_exit(&cportinfo->cport_mutex); | |
| 7307 drive = kmem_zalloc( | |
| 7308 sizeof (sata_drive_info_t), KM_SLEEP); | |
| 7309 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7310 (dip, &sata_device); | |
| 7311 mutex_enter(&cportinfo->cport_mutex); | |
| 7312 | |
| 7313 /* sata_update_port_info() */ | |
| 7314 sata_update_port_scr(&pmportinfo->pmport_scr, | |
| 7315 &sata_device); | |
| 7316 | |
| 7317 pmportinfo->pmport_sata_drive = drive; | |
| 7318 drive->satadrv_addr.cport = | |
| 7319 pmportinfo->pmport_addr.cport; | |
| 7320 drive->satadrv_addr.pmport = npmport; | |
| 7321 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; | |
| 7322 drive->satadrv_type = pmportinfo-> | |
| 7323 pmport_dev_type; | |
| 7324 drive->satadrv_state = SATA_STATE_UNKNOWN; | |
| 7325 } | |
| 7326 pmportinfo->pmport_state = | |
| 7327 SATA_STATE_PROBED | SATA_STATE_READY; | |
| 7328 } | |
| 7329 mutex_exit(&cportinfo->cport_mutex); | |
| 7330 } | |
| 7331 } | |
| 7332 | |
| 7333 | |
| 7334 | |
| 7335 /* | |
| 7336 * Create SATA device nodes for specified HBA instance (SCSI target | |
| 7337 * device nodes). | |
| 7338 * This function is called only from sata_hba_attach(). The hba_attached flag | |
| 7339 * is not set yet, so no ports or device data structures would be touched | |
| 7340 * by anyone other then this thread, therefore per-port mutex protection is | |
| 7341 * not needed. | |
| 7342 * The assumption is that there are no target and attachment point minor nodes | |
| 7343 * created by the boot subsystems, so we do not need to prune device tree. | |
| 7344 * An AP (Attachement Point) node is created for each SATA device port even | |
| 7345 * when there is no device attached. | |
| 7346 * A target node is created when there is a supported type of device attached, | |
| 7347 * but may be removed if it cannot be put online. | |
| 7348 * | |
| 7349 * This function cannot be called from an interrupt context. | |
| 7350 * | |
| 7351 * ONLY DISK TARGET NODES ARE CREATED NOW | |
| 7352 */ | |
| 7353 static void | |
| 7354 sata_make_device_nodes(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst) | |
| 7355 { | |
| 7356 int ncport, npmport; | |
| 7357 sata_cport_info_t *cportinfo; | |
| 7358 sata_pmult_info_t *pminfo; | |
| 7359 sata_pmport_info_t *pmportinfo; | |
| 7360 dev_info_t *cdip; /* child dip */ | |
| 7361 sata_device_t sata_device; | |
| 7362 int rval; | |
| 7363 | |
| 7364 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7365 * Walk through pre-probed sata ports info in sata_hba_inst structure |
| 1258 | 7366 */ |
| 7367 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 7368 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 7369 mutex_enter(&cportinfo->cport_mutex); | |
| 7370 if (!(cportinfo->cport_state & SATA_STATE_PROBED)) { | |
| 7371 mutex_exit(&cportinfo->cport_mutex); | |
| 7372 continue; | |
| 7373 } | |
| 7374 if (cportinfo->cport_state == SATA_PSTATE_FAILED) { | |
| 7375 mutex_exit(&cportinfo->cport_mutex); | |
| 7376 continue; | |
| 7377 } | |
| 7378 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { | |
| 7379 /* No device attached to the controller port */ | |
| 7380 mutex_exit(&cportinfo->cport_mutex); | |
| 7381 continue; | |
| 7382 } | |
| 7383 /* | |
| 7384 * Some device is attached to a controller port. | |
| 7385 * We rely on controllers distinquishing between no-device, | |
| 7386 * attached port multiplier and other kind of attached device. | |
| 7387 * We need to get Identify Device data and determine | |
| 7388 * positively the dev type before trying to attach | |
| 7389 * the target driver. | |
| 7390 */ | |
| 7391 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 7392 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 7393 /* | |
| 7394 * Not port multiplier. | |
| 7395 */ | |
| 7396 sata_device.satadev_addr = cportinfo->cport_addr; | |
| 7397 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 7398 mutex_exit(&cportinfo->cport_mutex); | |
| 7399 rval = sata_probe_device(sata_hba_inst, &sata_device); | |
| 7400 if (rval != SATA_SUCCESS || | |
| 7401 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) | |
| 7402 continue; | |
| 7403 | |
| 7404 mutex_enter(&cportinfo->cport_mutex); | |
| 7405 if ((sata_device.satadev_type & | |
| 7406 SATA_VALID_DEV_TYPE) == 0) { | |
| 7407 /* | |
| 7408 * Could not determine device type or | |
| 7409 * a device is not supported. | |
| 7410 * Degrade this device to unknown. | |
| 7411 */ | |
| 7412 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7413 mutex_exit(&cportinfo->cport_mutex); | |
| 7414 continue; | |
| 7415 } | |
| 7416 cportinfo->cport_dev_type = sata_device.satadev_type; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7417 mutex_exit(&cportinfo->cport_mutex); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7418 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7419 if (sata_initialize_device(sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7420 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7421 /* Retry */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7422 (void) sata_initialize_device(sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7423 SATA_CPORTINFO_DRV_INFO(cportinfo)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7424 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7425 mutex_enter(&cportinfo->cport_mutex); |
| 1258 | 7426 sata_show_drive_info(sata_hba_inst, |
| 7427 SATA_CPORTINFO_DRV_INFO(cportinfo)); | |
| 7428 mutex_exit(&cportinfo->cport_mutex); | |
| 7429 cdip = sata_create_target_node(pdip, sata_hba_inst, | |
| 7430 &sata_device.satadev_addr); | |
| 7431 mutex_enter(&cportinfo->cport_mutex); | |
| 7432 if (cdip == NULL) { | |
| 7433 /* | |
| 7434 * Attaching target node failed. | |
| 7435 * We retain sata_drive_info structure... | |
| 7436 */ | |
| 7437 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 7438 satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 7439 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 7440 satadrv_state = SATA_STATE_UNKNOWN; | |
| 7441 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7442 mutex_exit(&cportinfo->cport_mutex); | |
| 7443 continue; | |
| 7444 } | |
| 7445 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 7446 satadrv_state = SATA_STATE_READY; | |
| 7447 } else { | |
| 7448 /* This must be Port Multiplier type */ | |
| 7449 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 7450 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7451 "sata_make_device_nodes: " | |
| 7452 "unknown dev type %x", | |
| 7453 cportinfo->cport_dev_type)); | |
| 7454 mutex_exit(&cportinfo->cport_mutex); | |
| 7455 continue; | |
| 7456 } | |
| 7457 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); | |
| 7458 for (npmport = 0; | |
| 7459 npmport < pminfo->pmult_num_dev_ports; | |
| 7460 npmport++) { | |
| 7461 pmportinfo = pminfo->pmult_dev_port[npmport]; | |
| 7462 if (pmportinfo->pmport_state & | |
| 7463 SATA_PSTATE_FAILED) { | |
| 7464 continue; | |
| 7465 } | |
| 7466 if (pmportinfo->pmport_dev_type & | |
| 7467 SATA_DTYPE_NONE) | |
| 7468 /* No device attached */ | |
| 7469 continue; | |
| 7470 | |
| 7471 sata_device.satadev_addr = | |
| 7472 pmportinfo->pmport_addr; | |
| 7473 sata_device.satadev_addr.qual = | |
| 7474 SATA_ADDR_DPMPORT; | |
| 7475 mutex_exit(&cportinfo->cport_mutex); | |
| 7476 rval = sata_probe_device(sata_hba_inst, | |
| 7477 &sata_device); | |
| 7478 if (rval != SATA_SUCCESS || | |
| 7479 sata_device.satadev_type == | |
| 7480 SATA_DTYPE_UNKNOWN) { | |
| 7481 mutex_enter(&cportinfo->cport_mutex); | |
| 7482 continue; | |
| 7483 } | |
| 7484 mutex_enter(&cportinfo->cport_mutex); | |
| 7485 if ((sata_device.satadev_type & | |
| 7486 SATA_VALID_DEV_TYPE) == 0) { | |
| 7487 /* | |
| 7488 * Could not determine device type. | |
| 7489 * Degrade this device to unknown. | |
| 7490 */ | |
| 7491 pmportinfo->pmport_dev_type = | |
| 7492 SATA_DTYPE_UNKNOWN; | |
| 7493 continue; | |
| 7494 } | |
| 7495 pmportinfo->pmport_dev_type = | |
| 7496 sata_device.satadev_type; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7497 mutex_exit(&cportinfo->cport_mutex); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7498 if (sata_initialize_device(sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7499 pmportinfo->pmport_sata_drive) != |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7500 SATA_SUCCESS) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7501 /* Retry */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7502 (void) sata_initialize_device( |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7503 sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7504 pmportinfo->pmport_sata_drive); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7505 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7506 mutex_enter(&cportinfo->cport_mutex); |
| 1258 | 7507 sata_show_drive_info(sata_hba_inst, |
| 7508 pmportinfo->pmport_sata_drive); | |
| 7509 mutex_exit(&cportinfo->cport_mutex); | |
| 7510 cdip = sata_create_target_node(pdip, | |
| 7511 sata_hba_inst, &sata_device.satadev_addr); | |
| 7512 mutex_enter(&cportinfo->cport_mutex); | |
| 7513 if (cdip == NULL) { | |
| 7514 /* | |
| 7515 * Attaching target node failed. | |
| 7516 * We retain sata_drive_info | |
| 7517 * structure... | |
| 7518 */ | |
| 7519 pmportinfo->pmport_sata_drive-> | |
| 7520 satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 7521 pmportinfo->pmport_sata_drive-> | |
| 7522 satadrv_state = SATA_STATE_UNKNOWN; | |
| 7523 pmportinfo->pmport_dev_type = | |
| 7524 SATA_DTYPE_UNKNOWN; | |
| 7525 continue; | |
| 7526 } | |
| 7527 pmportinfo->pmport_sata_drive-> | |
| 7528 satadrv_state |= SATA_STATE_READY; | |
| 7529 } | |
| 7530 } | |
| 7531 mutex_exit(&cportinfo->cport_mutex); | |
| 7532 } | |
| 7533 } | |
| 7534 | |
| 7535 | |
| 7536 | |
| 7537 /* | |
| 7538 * Create scsi target node for attached device, create node properties and | |
| 7539 * attach the node. | |
| 7540 * The node could be removed if the device onlining fails. | |
| 7541 * | |
| 7542 * A dev_info_t pointer is returned if operation is successful, NULL is | |
| 7543 * returned otherwise. | |
| 7544 */ | |
| 7545 | |
| 7546 static dev_info_t * | |
| 7547 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, | |
| 7548 sata_address_t *sata_addr) | |
| 7549 { | |
| 7550 dev_info_t *cdip = NULL; | |
| 7551 int rval; | |
| 7552 char *nname = NULL; | |
| 7553 char **compatible = NULL; | |
| 7554 int ncompatible; | |
| 7555 struct scsi_inquiry inq; | |
| 7556 sata_device_t sata_device; | |
| 7557 sata_drive_info_t *sdinfo; | |
| 7558 int target; | |
| 7559 int i; | |
| 7560 | |
| 7561 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 7562 sata_device.satadev_addr = *sata_addr; | |
| 7563 | |
| 7564 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); | |
| 7565 | |
| 7566 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 7567 | |
| 7568 target = SATA_TO_SCSI_TARGET(sata_addr->cport, | |
| 7569 sata_addr->pmport, sata_addr->qual); | |
| 7570 | |
| 7571 if (sdinfo == NULL) { | |
| 7572 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 7573 sata_addr->cport))); | |
| 7574 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7575 "sata_create_target_node: no sdinfo for target %x", | |
| 7576 target)); | |
| 7577 return (NULL); | |
| 7578 } | |
| 7579 | |
| 7580 /* | |
| 7581 * create scsi inquiry data, expected by | |
| 7582 * scsi_hba_nodename_compatible_get() | |
| 7583 */ | |
| 7584 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, (uint8_t *)&inq); | |
| 7585 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); | |
| 7586 | |
| 7587 /* determine the node name and compatible */ | |
| 7588 scsi_hba_nodename_compatible_get(&inq, NULL, | |
| 7589 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); | |
| 7590 | |
| 7591 #ifdef SATA_DEBUG | |
| 7592 if (sata_debug_flags & SATA_DBG_NODES) { | |
| 7593 if (nname == NULL) { | |
| 7594 cmn_err(CE_NOTE, "sata_create_target_node: " | |
| 7595 "cannot determine nodename for target %d\n", | |
| 7596 target); | |
| 7597 } else { | |
| 7598 cmn_err(CE_WARN, "sata_create_target_node: " | |
| 7599 "target %d nodename: %s\n", target, nname); | |
| 7600 } | |
| 7601 if (compatible == NULL) { | |
| 7602 cmn_err(CE_WARN, | |
| 7603 "sata_create_target_node: no compatible name\n"); | |
| 7604 } else { | |
| 7605 for (i = 0; i < ncompatible; i++) { | |
| 7606 cmn_err(CE_WARN, "sata_create_target_node: " | |
| 7607 "compatible name: %s\n", compatible[i]); | |
| 7608 } | |
| 7609 } | |
| 7610 } | |
| 7611 #endif | |
| 7612 | |
| 7613 /* if nodename can't be determined, log error and exit */ | |
| 7614 if (nname == NULL) { | |
| 7615 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7616 "sata_create_target_node: cannot determine nodename " | |
| 7617 "for target %d\n", target)); | |
| 7618 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 7619 return (NULL); | |
| 7620 } | |
| 7621 /* | |
| 7622 * Create scsi target node | |
| 7623 */ | |
| 7624 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); | |
| 7625 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, | |
| 7626 "device-type", "scsi"); | |
| 7627 | |
| 7628 if (rval != DDI_PROP_SUCCESS) { | |
| 7629 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7630 "updating device_type prop failed %d", rval)); | |
| 7631 goto fail; | |
| 7632 } | |
| 7633 | |
| 7634 /* | |
| 7635 * Create target node properties: target & lun | |
| 7636 */ | |
| 7637 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); | |
| 7638 if (rval != DDI_PROP_SUCCESS) { | |
| 7639 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7640 "updating target prop failed %d", rval)); | |
| 7641 goto fail; | |
| 7642 } | |
| 7643 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); | |
| 7644 if (rval != DDI_PROP_SUCCESS) { | |
| 7645 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7646 "updating target prop failed %d", rval)); | |
| 7647 goto fail; | |
| 7648 } | |
| 7649 | |
| 7650 /* decorate the node with compatible */ | |
| 7651 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", | |
| 7652 compatible, ncompatible) != DDI_PROP_SUCCESS) { | |
| 7653 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7654 "sata_create_target_node: FAIL compatible props cdip 0x%p", | |
| 7655 (void *)cdip)); | |
| 7656 goto fail; | |
| 7657 } | |
| 7658 | |
| 7659 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7660 * Set default write cache mode |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7661 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7662 rval = sata_init_write_cache_mode(sata_hba_inst, sdinfo); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7663 if (rval != SATA_SUCCESS) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7664 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7665 "cannot set deafult write cache mode for " |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7666 "device at port %d", sata_addr->cport); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7667 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7668 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7669 /* |
| 1258 | 7670 * Now, try to attach the driver. If probing of the device fails, |
| 7671 * the target node may be removed | |
| 7672 */ | |
| 7673 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); | |
| 7674 | |
| 7675 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 7676 | |
| 7677 if (rval == NDI_SUCCESS) | |
| 7678 return (cdip); | |
| 7679 | |
| 7680 /* target node was removed - are we sure? */ | |
| 7681 return (NULL); | |
| 7682 | |
| 7683 fail: | |
| 7684 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 7685 ddi_prop_remove_all(cdip); | |
| 7686 rval = ndi_devi_free(cdip); | |
| 7687 if (rval != NDI_SUCCESS) { | |
| 7688 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7689 "node removal failed %d", rval)); | |
| 7690 } | |
| 7691 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7692 "cannot create target node for device at port %d", | |
| 7693 sata_addr->cport); | |
| 7694 return (NULL); | |
| 7695 } | |
| 7696 | |
| 7697 | |
| 7698 | |
| 7699 /* | |
| 7700 * Re-probe sata port, check for a device and attach necessary info | |
| 7701 * structures when necessary. Identify Device data is fetched, if possible. | |
| 7702 * Assumption: sata address is already validated. | |
| 7703 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of | |
| 7704 * the presence of a device and its type. | |
| 7705 * SATA_FAILURE is returned if one of the operations failed. | |
| 7706 */ | |
| 7707 static int | |
| 7708 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) | |
| 7709 { | |
| 7710 sata_cport_info_t *cportinfo; | |
| 7711 sata_drive_info_t *sdinfo; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7712 boolean_t init_device = B_FALSE; |
| 1258 | 7713 int rval; |
| 7714 | |
| 7715 /* We only care about host sata cport for now */ | |
| 7716 cportinfo = SATA_CPORT_INFO(sata_hba_inst, | |
| 7717 sata_device->satadev_addr.cport); | |
| 7718 /* probe port */ | |
| 7719 mutex_enter(&cportinfo->cport_mutex); | |
| 7720 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; | |
| 7721 cportinfo->cport_state |= SATA_STATE_PROBING; | |
| 7722 mutex_exit(&cportinfo->cport_mutex); | |
| 7723 | |
| 7724 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7725 (SATA_DIP(sata_hba_inst), sata_device); | |
| 7726 | |
| 7727 mutex_enter(&cportinfo->cport_mutex); | |
| 7728 if (rval != SATA_SUCCESS) { | |
| 7729 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 7730 mutex_exit(&cportinfo->cport_mutex); | |
| 7731 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_hba_ioctl: " | |
| 7732 "connect: port probbing failed")); | |
| 7733 return (SATA_FAILURE); | |
| 7734 } | |
| 7735 | |
| 7736 /* | |
| 7737 * update sata port state and set device type | |
| 7738 */ | |
| 7739 sata_update_port_info(sata_hba_inst, sata_device); | |
| 7740 cportinfo->cport_state |= SATA_STATE_PROBED; | |
| 7741 | |
| 7742 /* | |
| 7743 * Sanity check - Port is active? Is the link active? | |
| 7744 * Is there any device attached? | |
| 7745 */ | |
| 7746 if ((cportinfo->cport_state & | |
| 7747 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || | |
| 7748 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != | |
| 7749 SATA_PORT_DEVLINK_UP) { | |
| 7750 /* | |
| 7751 * Port in non-usable state or no link active/no device. | |
| 7752 * Free info structure if necessary (direct attached drive | |
| 7753 * only, for now! | |
| 7754 */ | |
| 7755 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 7756 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 7757 /* Add here differentiation for device attached or not */ | |
| 7758 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 7759 mutex_exit(&cportinfo->cport_mutex); | |
| 7760 if (sdinfo != NULL) | |
| 7761 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 7762 return (SATA_SUCCESS); | |
| 7763 } | |
| 7764 | |
| 7765 cportinfo->cport_state |= SATA_STATE_READY; | |
| 7766 cportinfo->cport_dev_type = sata_device->satadev_type; | |
| 7767 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 7768 | |
| 7769 /* | |
| 7770 * If we are re-probing the port, there may be | |
| 7771 * sata_drive_info structure attached | |
| 7772 * (or sata_pm_info, if PMult is supported). | |
| 7773 */ | |
| 7774 if (sata_device->satadev_type == SATA_DTYPE_NONE) { | |
| 7775 /* | |
| 7776 * There is no device, so remove device info structure, | |
| 7777 * if necessary. Direct attached drive only! | |
| 7778 */ | |
| 7779 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 7780 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 7781 if (sdinfo != NULL) { | |
| 7782 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 7783 sata_log(sata_hba_inst, CE_WARN, | |
| 7784 "SATA device detached " | |
| 7785 "from port %d", cportinfo->cport_addr.cport); | |
| 7786 } | |
| 7787 mutex_exit(&cportinfo->cport_mutex); | |
| 7788 return (SATA_SUCCESS); | |
| 7789 } | |
| 7790 | |
| 7791 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { | |
| 7792 if (sdinfo == NULL) { | |
| 7793 /* | |
| 7794 * There is some device attached, but there is | |
| 7795 * no sata_drive_info structure - allocate one | |
| 7796 */ | |
| 7797 mutex_exit(&cportinfo->cport_mutex); | |
| 7798 sdinfo = kmem_zalloc( | |
| 7799 sizeof (sata_drive_info_t), KM_SLEEP); | |
| 7800 mutex_enter(&cportinfo->cport_mutex); | |
| 7801 /* | |
| 7802 * Recheck, if port state did not change when we | |
| 7803 * released mutex. | |
| 7804 */ | |
| 7805 if (cportinfo->cport_state & SATA_STATE_READY) { | |
| 7806 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; | |
| 7807 sdinfo->satadrv_addr = cportinfo->cport_addr; | |
| 7808 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; | |
| 7809 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 7810 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 7811 } else { | |
| 7812 /* | |
| 7813 * Port is not in ready state, we | |
| 7814 * cannot attach a device. | |
| 7815 */ | |
| 7816 mutex_exit(&cportinfo->cport_mutex); | |
| 7817 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 7818 return (SATA_SUCCESS); | |
| 7819 } | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7820 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7821 * Since we are adding device, presumably new one, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7822 * indicate that it should be initalized, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7823 * as well as some internal framework states). |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7824 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7825 init_device = B_TRUE; |
| 1258 | 7826 } |
| 7827 | |
| 7828 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7829 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; | |
| 7830 } else { | |
| 7831 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7832 mutex_exit(&cportinfo->cport_mutex); | |
| 7833 return (SATA_SUCCESS); | |
| 7834 } | |
| 7835 mutex_exit(&cportinfo->cport_mutex); | |
| 7836 /* | |
| 7837 * Figure out what kind of device we are really | |
| 7838 * dealing with. | |
| 7839 */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7840 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
|
7841 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7842 /* Set initial device features, if necessary */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7843 if (rval == SATA_SUCCESS && init_device == B_TRUE) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7844 if (sata_initialize_device(sata_hba_inst, sdinfo) != |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7845 SATA_SUCCESS) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7846 /* retry */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7847 (void) sata_initialize_device(sata_hba_inst, sdinfo); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7848 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7849 return (rval); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7850 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7851 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7852 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7853 * Initialize device |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7854 * Specified device is initialized to a default state. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7855 * 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
|
7856 * 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
|
7857 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7858 * Only SATA disks are initialized for now. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7859 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7860 * 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
|
7861 * SATA_FAILURE otherwise |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7862 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7863 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7864 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
|
7865 sata_drive_info_t *sdinfo) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7866 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7867 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7868 sata_save_drive_settings(sdinfo); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7869 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7870 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7871 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7872 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
|
7873 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7874 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7875 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7876 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7877 * Initialize write cache mode. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7878 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7879 * 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
|
7880 * static variable: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7881 * 1 - enable |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7882 * 0 - disable |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7883 * any other value - current drive setting |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7884 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7885 * 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
|
7886 * 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
|
7887 * 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
|
7888 * SATA_FAILURE otherwise. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7889 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7890 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7891 sata_init_write_cache_mode(sata_hba_inst_t *sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7892 sata_drive_info_t *sdinfo) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7893 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7894 if (sata_write_cache == 1) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7895 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7896 else if (sata_write_cache == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7897 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7898 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7899 * 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
|
7900 * a current setting of the drive's write cache is used. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7901 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7902 * Now set the write cache mode |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7903 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7904 return (sata_set_drive_features(sata_hba_inst, sdinfo, 0)); |
| 1258 | 7905 } |
| 7906 | |
| 7907 | |
| 7908 /* | |
| 7909 * Validate sata address. | |
| 7910 * Specified cport, pmport and qualifier has to match | |
| 7911 * passed sata_scsi configuration info. | |
| 7912 * The presence of an attached device is not verified. | |
| 7913 * | |
| 7914 * Returns 0 when address is valid, -1 otherwise. | |
| 7915 */ | |
| 7916 static int | |
| 7917 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, | |
| 7918 int pmport, int qual) | |
| 7919 { | |
| 7920 if (qual == SATA_ADDR_DCPORT && pmport != 0) | |
| 7921 goto invalid_address; | |
| 7922 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 7923 goto invalid_address; | |
| 7924 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && | |
| 7925 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || | |
| 7926 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || | |
| 7927 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) | |
| 7928 goto invalid_address; | |
| 7929 | |
| 7930 return (0); | |
| 7931 | |
| 7932 invalid_address: | |
| 7933 return (-1); | |
| 7934 | |
| 7935 } | |
| 7936 | |
| 7937 /* | |
| 7938 * Validate scsi address | |
| 7939 * SCSI target address is translated into SATA cport/pmport and compared | |
| 7940 * with a controller port/device configuration. LUN has to be 0. | |
| 7941 * Returns 0 if a scsi target refers to an attached device, | |
| 7942 * returns 1 if address is valid but device is not attached, | |
| 7943 * returns -1 if bad address or device is of an unsupported type. | |
| 7944 * Upon return sata_device argument is set. | |
| 7945 */ | |
| 7946 static int | |
| 7947 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, | |
| 7948 struct scsi_address *ap, sata_device_t *sata_device) | |
| 7949 { | |
| 7950 int cport, pmport, qual, rval; | |
| 7951 | |
| 7952 rval = -1; /* Invalid address */ | |
| 7953 if (ap->a_lun != 0) | |
| 7954 goto out; | |
| 7955 | |
| 7956 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); | |
| 7957 cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 7958 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); | |
| 7959 | |
| 7960 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) | |
| 7961 goto out; | |
| 7962 | |
| 7963 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == | |
| 7964 0) { | |
| 7965 | |
| 7966 sata_cport_info_t *cportinfo; | |
| 7967 sata_pmult_info_t *pmultinfo; | |
| 7968 sata_drive_info_t *sdinfo = NULL; | |
| 7969 | |
| 7970 rval = 1; /* Valid sata address */ | |
| 7971 | |
| 7972 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 7973 if (qual == SATA_ADDR_DCPORT) { | |
| 7974 if (cportinfo == NULL || | |
| 7975 cportinfo->cport_dev_type == SATA_DTYPE_NONE) | |
| 7976 goto out; | |
| 7977 | |
| 7978 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT || | |
| 7979 (cportinfo->cport_dev_type & | |
| 7980 SATA_VALID_DEV_TYPE) == 0) { | |
| 7981 rval = -1; | |
| 7982 goto out; | |
| 7983 } | |
| 7984 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 7985 | |
| 7986 } else if (qual == SATA_ADDR_DPMPORT) { | |
| 7987 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); | |
| 7988 if (pmultinfo == NULL) { | |
| 7989 rval = -1; | |
| 7990 goto out; | |
| 7991 } | |
| 7992 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == | |
| 7993 NULL || | |
| 7994 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, | |
| 7995 pmport) == SATA_DTYPE_NONE) | |
| 7996 goto out; | |
| 7997 | |
| 7998 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, | |
| 7999 pmport); | |
| 8000 } else { | |
| 8001 rval = -1; | |
| 8002 goto out; | |
| 8003 } | |
| 8004 if ((sdinfo == NULL) || | |
| 8005 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) | |
| 8006 goto out; | |
| 8007 | |
| 8008 sata_device->satadev_type = sdinfo->satadrv_type; | |
| 8009 sata_device->satadev_addr.qual = qual; | |
| 8010 sata_device->satadev_addr.cport = cport; | |
| 8011 sata_device->satadev_addr.pmport = pmport; | |
| 8012 sata_device->satadev_rev = SATA_DEVICE_REV_1; | |
| 8013 return (0); | |
| 8014 } | |
| 8015 out: | |
| 8016 if (rval == 1) { | |
| 8017 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 8018 "sata_validate_scsi_address: no valid target %x lun %x", | |
| 8019 ap->a_target, ap->a_lun); | |
| 8020 } | |
| 8021 return (rval); | |
| 8022 } | |
| 8023 | |
| 8024 /* | |
| 8025 * Find dip corresponding to passed device number | |
| 8026 * | |
| 8027 * Returns NULL if invalid device number is passed or device cannot be found, | |
| 8028 * Returns dip is device is found. | |
| 8029 */ | |
| 8030 static dev_info_t * | |
| 8031 sata_devt_to_devinfo(dev_t dev) | |
| 8032 { | |
| 8033 dev_info_t *dip; | |
| 8034 #ifndef __lock_lint | |
| 8035 struct devnames *dnp; | |
| 8036 major_t major = getmajor(dev); | |
| 8037 int instance = SATA_MINOR2INSTANCE(getminor(dev)); | |
| 8038 | |
| 8039 if (major >= devcnt) | |
| 8040 return (NULL); | |
| 8041 | |
| 8042 dnp = &devnamesp[major]; | |
| 8043 LOCK_DEV_OPS(&(dnp->dn_lock)); | |
| 8044 dip = dnp->dn_head; | |
| 8045 while (dip && (ddi_get_instance(dip) != instance)) { | |
| 8046 dip = ddi_get_next(dip); | |
| 8047 } | |
| 8048 UNLOCK_DEV_OPS(&(dnp->dn_lock)); | |
| 8049 #endif | |
| 8050 | |
| 8051 return (dip); | |
| 8052 } | |
| 8053 | |
| 8054 | |
| 8055 /* | |
| 8056 * Probe device. | |
| 8057 * This function issues Identify Device command and initialize local | |
| 8058 * sata_drive_info structure if the device can be identified. | |
| 8059 * The device type is determined by examining Identify Device | |
| 8060 * command response. | |
| 8061 * If the sata_hba_inst has linked drive info structure for this | |
| 8062 * device address, the Identify Device data is stored into sata_drive_info | |
| 8063 * structure linked to the port info structure. | |
| 8064 * | |
| 8065 * sata_device has to refer to the valid sata port(s) for HBA described | |
| 8066 * by sata_hba_inst structure. | |
| 8067 * | |
| 8068 * Returns: SATA_SUCCESS if device type was successfully probed and port-linked | |
| 8069 * drive info structure was updated; | |
| 8070 * SATA_FAILURE if there is no device, or device was not probed | |
| 8071 * successully. | |
| 8072 * If a device cannot be identified, sata_device's dev_state and dev_type | |
| 8073 * fields are set to unknown. | |
| 8074 * | |
| 8075 */ | |
| 8076 | |
| 8077 static int | |
| 8078 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) | |
| 8079 { | |
| 8080 sata_drive_info_t *sdinfo; | |
| 8081 sata_drive_info_t new_sdinfo; /* local drive info struct */ | |
| 8082 int retry_cnt; | |
| 8083 | |
| 8084 ASSERT((SATA_CPORT_STATE(sata_hba_inst, | |
| 8085 sata_device->satadev_addr.cport) & | |
| 8086 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); | |
| 8087 | |
| 8088 sata_device->satadev_type = SATA_DTYPE_NONE; | |
| 8089 | |
| 8090 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8091 sata_device->satadev_addr.cport))); | |
| 8092 | |
| 8093 /* Get pointer to port-linked sata device info structure */ | |
| 8094 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 8095 if (sdinfo != NULL) { | |
| 8096 sdinfo->satadrv_state &= | |
| 8097 ~(SATA_STATE_PROBED | SATA_STATE_READY); | |
| 8098 sdinfo->satadrv_state |= SATA_STATE_PROBING; | |
| 8099 } else { | |
| 8100 /* No device to probe */ | |
| 8101 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8102 sata_device->satadev_addr.cport))); | |
| 8103 sata_device->satadev_type = SATA_DTYPE_NONE; | |
| 8104 sata_device->satadev_state = SATA_STATE_UNKNOWN; | |
| 8105 return (SATA_FAILURE); | |
| 8106 } | |
| 8107 /* | |
| 8108 * Need to issue both types of identify device command and | |
| 8109 * determine device type by examining retreived data/status. | |
| 8110 * First, ATA Identify Device. | |
| 8111 */ | |
| 8112 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); | |
| 8113 new_sdinfo.satadrv_addr = sata_device->satadev_addr; | |
| 8114 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8115 sata_device->satadev_addr.cport))); | |
| 8116 for (retry_cnt = 0; retry_cnt <= SATA_DEVICE_IDENTIFY_RETRY; | |
| 8117 retry_cnt++) { | |
| 8118 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; | |
| 8119 if (sata_identify_device(sata_hba_inst, &new_sdinfo) == 0) { | |
| 8120 /* Got something responding to ATA Identify Device */ | |
| 8121 sata_device->satadev_type = new_sdinfo.satadrv_type; | |
| 8122 break; | |
| 8123 } | |
| 8124 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { | |
| 8125 /* | |
| 8126 * HBA supports ATAPI - try to issue Identify Packet | |
| 8127 * Device command. | |
| 8128 */ | |
| 8129 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD; | |
| 8130 if (sata_identify_device(sata_hba_inst, | |
| 8131 &new_sdinfo) == 0) { | |
| 8132 /* | |
| 8133 * Got something responding to Identify Packet | |
| 8134 * Device cmd. | |
| 8135 */ | |
| 8136 /* Set UDMA mode here as well ? - phase 2 */ | |
| 8137 sata_device->satadev_type = | |
| 8138 new_sdinfo.satadrv_type; | |
| 8139 break; | |
| 8140 } | |
| 8141 } | |
| 8142 } | |
| 8143 if (retry_cnt <= SATA_DEVICE_IDENTIFY_RETRY) { | |
| 8144 /* save device info, if possible */ | |
| 8145 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8146 sata_device->satadev_addr.cport))); | |
| 8147 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 8148 if (sdinfo == NULL) { | |
| 8149 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8150 sata_device->satadev_addr.cport))); | |
| 8151 return (SATA_FAILURE); | |
| 8152 } | |
| 8153 /* | |
| 8154 * Copy drive info into the port-linked drive info structure. | |
| 8155 */ | |
| 8156 *sdinfo = new_sdinfo; | |
| 8157 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; | |
| 8158 sdinfo->satadrv_state |= SATA_STATE_PROBED; | |
| 8159 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) | |
| 8160 SATA_CPORT_DEV_TYPE(sata_hba_inst, | |
| 8161 sata_device->satadev_addr.cport) = | |
| 8162 sdinfo->satadrv_type; | |
| 8163 else /* SATA_ADDR_DPMPORT */ | |
| 8164 SATA_PMPORT_DEV_TYPE(sata_hba_inst, | |
| 8165 sata_device->satadev_addr.cport, | |
| 8166 sata_device->satadev_addr.pmport) = | |
| 8167 sdinfo->satadrv_type; | |
| 8168 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8169 sata_device->satadev_addr.cport))); | |
| 8170 return (SATA_SUCCESS); | |
| 8171 } | |
| 8172 | |
| 8173 failure: | |
| 8174 /* | |
| 8175 * Looks like we cannot determine the device type. | |
| 8176 */ | |
| 8177 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8178 sata_device->satadev_addr.cport))); | |
| 8179 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 8180 if (sdinfo != NULL) { | |
| 8181 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; | |
| 8182 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8183 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; | |
| 8184 sdinfo->satadrv_state = SATA_STATE_PROBED; | |
| 8185 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) | |
| 8186 SATA_CPORT_DEV_TYPE(sata_hba_inst, | |
| 8187 sata_device->satadev_addr.cport) = | |
| 8188 SATA_DTYPE_UNKNOWN; | |
| 8189 else { | |
| 8190 /* SATA_ADDR_DPMPORT */ | |
| 8191 if ((SATA_PMULT_INFO(sata_hba_inst, | |
| 8192 sata_device->satadev_addr.cport) != NULL) && | |
| 8193 (SATA_PMPORT_INFO(sata_hba_inst, | |
| 8194 sata_device->satadev_addr.cport, | |
| 8195 sata_device->satadev_addr.pmport) != NULL)) | |
| 8196 SATA_PMPORT_DEV_TYPE(sata_hba_inst, | |
| 8197 sata_device->satadev_addr.cport, | |
| 8198 sata_device->satadev_addr.pmport) = | |
| 8199 SATA_DTYPE_UNKNOWN; | |
| 8200 } | |
| 8201 } | |
| 8202 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8203 sata_device->satadev_addr.cport))); | |
| 8204 return (SATA_FAILURE); | |
| 8205 } | |
| 8206 | |
| 8207 | |
| 8208 /* | |
| 8209 * Get pointer to sata_drive_info structure. | |
| 8210 * | |
| 8211 * The sata_device has to contain address (cport, pmport and qualifier) for | |
| 8212 * specified sata_scsi structure. | |
| 8213 * | |
| 8214 * Returns NULL if device address is not valid for this HBA configuration. | |
| 8215 * Otherwise, returns a pointer to sata_drive_info structure. | |
| 8216 * | |
| 8217 * This function should be called with a port mutex held. | |
| 8218 */ | |
| 8219 static sata_drive_info_t * | |
| 8220 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, | |
| 8221 sata_device_t *sata_device) | |
| 8222 { | |
| 8223 uint8_t cport = sata_device->satadev_addr.cport; | |
| 8224 uint8_t pmport = sata_device->satadev_addr.pmport; | |
| 8225 uint8_t qual = sata_device->satadev_addr.qual; | |
| 8226 | |
| 8227 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 8228 return (NULL); | |
| 8229 | |
| 8230 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & | |
| 8231 (SATA_STATE_PROBED | SATA_STATE_READY))) | |
| 8232 /* Port not probed yet */ | |
| 8233 return (NULL); | |
| 8234 | |
| 8235 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) | |
| 8236 return (NULL); | |
| 8237 | |
| 8238 if (qual == SATA_ADDR_DCPORT) { | |
| 8239 /* Request for a device on a controller port */ | |
| 8240 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == | |
| 8241 SATA_DTYPE_PMULT) | |
| 8242 /* Port multiplier attached */ | |
| 8243 return (NULL); | |
| 8244 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); | |
| 8245 } | |
| 8246 if (qual == SATA_ADDR_DPMPORT) { | |
| 8247 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != | |
| 8248 SATA_DTYPE_PMULT) | |
| 8249 return (NULL); | |
| 8250 | |
| 8251 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) | |
| 8252 return (NULL); | |
| 8253 | |
| 8254 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); | |
| 8255 } | |
| 8256 | |
| 8257 /* we should not get here */ | |
| 8258 return (NULL); | |
| 8259 } | |
| 8260 | |
| 8261 | |
| 8262 /* | |
| 8263 * sata_identify_device. | |
| 8264 * Send Identify Device command to SATA HBA driver. | |
| 8265 * If command executes successfully, update sata_drive_info structure pointed | |
| 8266 * to by sdinfo argument, including Identify Device data. | |
| 8267 * If command fails, invalidate data in sata_drive_info. | |
| 8268 * | |
| 8269 * Cannot be called from interrupt level. | |
| 8270 * | |
| 8271 * Returns 0 if device was identified as supported device, -1 otherwise. | |
| 8272 */ | |
| 8273 static int | |
| 8274 sata_identify_device(sata_hba_inst_t *sata_hba_inst, | |
| 8275 sata_drive_info_t *sdinfo) | |
| 8276 { | |
| 8277 uint16_t cfg_word; | |
| 8278 int i; | |
| 8279 | |
| 8280 /* fetch device identify data */ | |
| 8281 if (sata_fetch_device_identify_data(sata_hba_inst, sdinfo) != 0) | |
| 8282 goto fail_unknown; | |
| 8283 | |
| 8284 cfg_word = sdinfo->satadrv_id.ai_config; | |
| 8285 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK && | |
| 8286 (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) { | |
| 8287 /* Change device type to reflect Identify Device data */ | |
| 8288 if (((cfg_word & SATA_ATAPI_TYPE_MASK) == | |
| 8289 SATA_ATAPI_TYPE) && | |
| 8290 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) == | |
| 8291 SATA_ATAPI_CDROM_DEV)) { | |
| 8292 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; | |
| 8293 } else { | |
| 8294 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8295 } | |
| 8296 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD && | |
| 8297 (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) || | |
| 8298 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) { | |
| 8299 /* Change device type to reflect Identify Device data ! */ | |
| 8300 if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) == | |
| 8301 SATA_ATA_TYPE) { | |
| 8302 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; | |
| 8303 } else { | |
| 8304 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8305 } | |
| 8306 } | |
| 8307 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { | |
| 8308 if (sdinfo->satadrv_capacity == 0) { | |
| 8309 /* Non-LBA disk. Too bad... */ | |
| 8310 sata_log(sata_hba_inst, CE_WARN, | |
| 8311 "SATA disk device at port %d does not support LBA", | |
| 8312 sdinfo->satadrv_addr.cport); | |
| 8313 goto fail_unknown; | |
| 8314 } | |
| 8315 } | |
| 8316 /* Check for Ultra DMA modes 6 through 0 being supported */ | |
| 8317 for (i = 6; i >= 0; --i) { | |
| 8318 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) | |
| 8319 break; | |
| 8320 } | |
| 8321 /* | |
| 8322 * At least UDMA 4 mode has to be supported. If mode 4 or | |
| 8323 * higher are not supported by the device, fail this | |
| 8324 * device. | |
| 8325 */ | |
| 8326 if (i < 4) { | |
| 8327 /* No required Ultra DMA mode supported */ | |
| 8328 sata_log(sata_hba_inst, CE_WARN, | |
| 8329 "SATA disk device at port %d does not support UDMA " | |
| 8330 "mode 4 or higher", sdinfo->satadrv_addr.cport); | |
| 8331 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 8332 "mode 4 or higher required, %d supported", i)); | |
| 8333 goto fail_unknown; | |
| 8334 } | |
| 8335 | |
| 8336 return (0); | |
| 8337 | |
| 8338 fail_unknown: | |
| 8339 /* Invalidate sata_drive_info ? */ | |
| 8340 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8341 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 8342 return (-1); | |
| 8343 } | |
| 8344 | |
| 8345 /* | |
| 8346 * Log/display device information | |
| 8347 */ | |
| 8348 static void | |
| 8349 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, | |
| 8350 sata_drive_info_t *sdinfo) | |
| 8351 { | |
| 8352 int valid_version; | |
| 8353 char msg_buf[MAXPATHLEN]; | |
| 8354 | |
| 8355 /* Show HBA path */ | |
| 8356 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); | |
| 8357 | |
| 8358 cmn_err(CE_CONT, "?%s :\n", msg_buf); | |
| 8359 | |
| 8360 if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) { | |
| 8361 (void) sprintf(msg_buf, | |
| 8362 "Unsupported SATA device type (cfg 0x%x) at ", | |
| 8363 sdinfo->satadrv_id.ai_config); | |
| 8364 } else { | |
| 8365 (void) sprintf(msg_buf, "SATA %s device at", | |
| 8366 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 8367 "disk":"CD/DVD (ATAPI)"); | |
| 8368 } | |
| 8369 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) | |
| 8370 cmn_err(CE_CONT, "?\t%s port %d\n", | |
| 8371 msg_buf, sdinfo->satadrv_addr.cport); | |
| 8372 else | |
| 8373 cmn_err(CE_CONT, "?\t%s port %d pmport %d\n", | |
| 8374 msg_buf, sdinfo->satadrv_addr.cport, | |
| 8375 sdinfo->satadrv_addr.pmport); | |
| 8376 | |
| 8377 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, | |
| 8378 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 8379 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); | |
| 8380 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; | |
| 8381 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); | |
| 8382 | |
| 8383 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, | |
| 8384 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 8385 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 8386 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; | |
| 8387 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); | |
| 8388 | |
| 8389 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, | |
| 8390 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 8391 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 8392 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
|
8393 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); |
| 1258 | 8394 |
| 8395 #ifdef SATA_DEBUG | |
| 8396 if (sdinfo->satadrv_id.ai_majorversion != 0 && | |
| 8397 sdinfo->satadrv_id.ai_majorversion != 0xffff) { | |
| 8398 int i; | |
| 8399 for (i = 14; i >= 2; i--) { | |
| 8400 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { | |
| 8401 valid_version = i; | |
| 8402 break; | |
| 8403 } | |
| 8404 } | |
| 8405 cmn_err(CE_CONT, | |
| 8406 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", | |
| 8407 valid_version, | |
| 8408 sdinfo->satadrv_id.ai_majorversion, | |
| 8409 sdinfo->satadrv_id.ai_minorversion); | |
| 8410 } | |
| 8411 #endif | |
| 8412 /* Log some info */ | |
| 8413 cmn_err(CE_CONT, "?\tsupported features:\n"); | |
| 8414 msg_buf[0] = '\0'; | |
| 8415 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) | |
| 8416 (void) strlcat(msg_buf, "48-bit LBA", MAXPATHLEN); | |
| 8417 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) | |
| 8418 (void) strlcat(msg_buf, "28-bit LBA", MAXPATHLEN); | |
| 8419 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) | |
| 8420 (void) strlcat(msg_buf, ", DMA", MAXPATHLEN); | |
| 8421 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) | |
| 8422 (void) strlcat(msg_buf, ", Native Command Queueing", | |
| 8423 MAXPATHLEN); | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
8424 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
|
8425 (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
|
8426 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
|
8427 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
8428 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
8429 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
|
8430 (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
|
8431 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); |
| 1258 | 8432 cmn_err(CE_CONT, "?\t %s\n", msg_buf); |
| 8433 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) | |
| 8434 cmn_err(CE_CONT, "?\tSATA1 & SATA2 compatible\n"); | |
| 8435 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) | |
| 8436 cmn_err(CE_CONT, "?\tSATA1 compatible\n"); | |
| 2177 | 8437 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) { |
| 8438 cmn_err(CE_CONT, "?\tQueue depth %d\n", | |
| 8439 sdinfo->satadrv_queue_depth); | |
| 8440 } | |
| 1258 | 8441 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
8442 if (sdinfo->satadrv_features_support & |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
8443 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
8444 (void) sprintf(msg_buf, "\tqueue depth %d\n", |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
8445 sdinfo->satadrv_queue_depth); |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
8446 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
|
8447 } |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
8448 |
| 1258 | 8449 #ifdef __i386 |
| 8450 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", | |
| 8451 sdinfo->satadrv_capacity); | |
| 8452 #else | |
| 8453 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", | |
| 8454 sdinfo->satadrv_capacity); | |
| 8455 #endif | |
| 8456 cmn_err(CE_CONT, "?%s", msg_buf); | |
| 8457 } | |
| 8458 | |
| 8459 | |
| 8460 /* | |
| 8461 * sata_save_drive_settings extracts current setting of the device and stores | |
| 8462 * it for future reference, in case the device setup would need to be restored | |
| 8463 * after the device reset. | |
| 8464 * | |
| 8465 * At the moment only read ahead and write cache settings are saved, if the | |
| 8466 * device supports these features at all. | |
| 8467 */ | |
| 8468 static void | |
| 8469 sata_save_drive_settings(sata_drive_info_t *sdinfo) | |
| 8470 { | |
| 8471 if (!(sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 8472 !(sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 8473 /* None of the features is supported - do nothing */ | |
| 8474 return; | |
| 8475 } | |
| 8476 | |
| 8477 /* Current setting of Read Ahead (and Read Cache) */ | |
| 8478 if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD) | |
| 8479 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; | |
| 8480 else | |
| 8481 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; | |
| 8482 | |
| 8483 /* Current setting of Write Cache */ | |
| 8484 if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE) | |
| 8485 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; | |
| 8486 else | |
| 8487 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; | |
| 8488 } | |
| 8489 | |
| 8490 | |
| 8491 /* | |
| 8492 * sata_check_capacity function determines a disk capacity | |
| 8493 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. | |
| 8494 * | |
| 8495 * NOTE: CHS mode is not supported! If a device does not support LBA, | |
| 8496 * this function is not called. | |
| 8497 * | |
| 8498 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 | |
| 8499 */ | |
| 8500 static uint64_t | |
| 8501 sata_check_capacity(sata_drive_info_t *sdinfo) | |
| 8502 { | |
| 8503 uint64_t capacity = 0; | |
| 8504 int i; | |
| 8505 | |
| 8506 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || | |
| 8507 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) | |
| 8508 /* Capacity valid only for LBA-addressable disk devices */ | |
| 8509 return (0); | |
| 8510 | |
| 8511 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && | |
| 8512 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && | |
| 8513 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { | |
| 8514 /* LBA48 mode supported and enabled */ | |
| 8515 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | | |
| 8516 SATA_DEV_F_LBA28; | |
| 8517 for (i = 3; i >= 0; --i) { | |
| 8518 capacity <<= 16; | |
| 8519 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; | |
| 8520 } | |
| 8521 } else { | |
| 8522 capacity = sdinfo->satadrv_id.ai_addrsec[1]; | |
| 8523 capacity <<= 16; | |
| 8524 capacity += sdinfo->satadrv_id.ai_addrsec[0]; | |
| 8525 if (capacity >= 0x1000000) | |
| 8526 /* LBA28 mode */ | |
| 8527 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; | |
| 8528 } | |
| 8529 return (capacity); | |
| 8530 } | |
| 8531 | |
| 8532 | |
| 8533 /* | |
| 8534 * Allocate consistent buffer for DMA transfer | |
| 8535 * | |
| 8536 * Cannot be called from interrupt level or with mutex held - it may sleep. | |
| 8537 * | |
| 8538 * Returns pointer to allocated buffer structure, or NULL if allocation failed. | |
| 8539 */ | |
| 8540 static struct buf * | |
| 8541 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) | |
| 8542 { | |
| 8543 struct scsi_address ap; | |
| 8544 struct buf *bp; | |
| 8545 ddi_dma_attr_t cur_dma_attr; | |
| 8546 | |
| 8547 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 8548 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; | |
| 8549 ap.a_target = SATA_TO_SCSI_TARGET( | |
| 8550 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, | |
| 8551 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, | |
| 8552 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); | |
| 8553 ap.a_lun = 0; | |
| 8554 | |
| 8555 bp = scsi_alloc_consistent_buf(&ap, NULL, len, | |
| 8556 B_READ, SLEEP_FUNC, NULL); | |
| 8557 | |
| 8558 if (bp != NULL) { | |
| 8559 /* Allocate DMA resources for this buffer */ | |
| 8560 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; | |
| 8561 /* | |
| 8562 * We use a local version of the dma_attr, to account | |
| 8563 * for a device addressing limitations. | |
| 8564 * sata_adjust_dma_attr() will handle sdinfo == NULL which | |
| 8565 * will cause dma attributes to be adjusted to a lowest | |
| 8566 * acceptable level. | |
| 8567 */ | |
| 8568 sata_adjust_dma_attr(NULL, | |
| 8569 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); | |
| 8570 | |
| 8571 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, | |
| 8572 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { | |
| 8573 scsi_free_consistent_buf(bp); | |
| 8574 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 8575 bp = NULL; | |
| 8576 } | |
| 8577 } | |
| 8578 return (bp); | |
| 8579 } | |
| 8580 | |
| 8581 /* | |
| 8582 * Release local buffer (consistent buffer for DMA transfer) allocated | |
| 8583 * via sata_alloc_local_buffer(). | |
| 8584 */ | |
| 8585 static void | |
| 8586 sata_free_local_buffer(sata_pkt_txlate_t *spx) | |
| 8587 { | |
| 8588 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 8589 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
| 8590 ASSERT(spx->txlt_dma_cookie_list_len != 0); | |
| 8591 ASSERT(spx->txlt_buf_dma_handle != NULL); | |
| 8592 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); | |
| 8593 | |
| 8594 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; | |
| 8595 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; | |
| 8596 | |
| 8597 /* Free DMA resources */ | |
| 8598 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); | |
| 8599 ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 8600 spx->txlt_buf_dma_handle = 0; | |
| 8601 | |
| 8602 kmem_free(spx->txlt_dma_cookie_list, | |
| 8603 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); | |
| 8604 spx->txlt_dma_cookie_list = NULL; | |
| 8605 spx->txlt_dma_cookie_list_len = 0; | |
| 8606 | |
| 8607 /* Free buffer */ | |
| 8608 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); | |
| 8609 } | |
| 8610 | |
| 8611 | |
| 8612 | |
| 8613 | |
| 8614 /* | |
| 8615 * Allocate sata_pkt | |
| 8616 * Pkt structure version and embedded strcutures version are initialized. | |
| 8617 * sata_pkt and sata_pkt_txlate structures are cross-linked. | |
| 8618 * | |
| 8619 * Since this may be called in interrupt context by sata_scsi_init_pkt, | |
| 8620 * callback argument determines if it can sleep or not. | |
| 8621 * Hence, it should not be called from interrupt context. | |
| 8622 * | |
| 8623 * If successful, non-NULL pointer to a sata pkt is returned. | |
| 8624 * Upon failure, NULL pointer is returned. | |
| 8625 */ | |
| 8626 static sata_pkt_t * | |
| 8627 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) | |
| 8628 { | |
| 8629 sata_pkt_t *spkt; | |
| 8630 int kmsflag; | |
| 8631 | |
| 8632 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; | |
| 8633 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); | |
| 8634 if (spkt == NULL) { | |
| 8635 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8636 "sata_pkt_alloc: failed")); | |
| 8637 return (NULL); | |
| 8638 } | |
| 8639 spkt->satapkt_rev = SATA_PKT_REV; | |
| 8640 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; | |
| 8641 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; | |
| 8642 spkt->satapkt_framework_private = spx; | |
| 8643 spx->txlt_sata_pkt = spkt; | |
| 8644 return (spkt); | |
| 8645 } | |
| 8646 | |
| 8647 /* | |
| 8648 * Free sata pkt allocated via sata_pkt_alloc() | |
| 8649 */ | |
| 8650 static void | |
| 8651 sata_pkt_free(sata_pkt_txlate_t *spx) | |
| 8652 { | |
| 8653 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 8654 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); | |
| 8655 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); | |
| 8656 spx->txlt_sata_pkt = NULL; | |
| 8657 } | |
| 8658 | |
| 8659 | |
| 8660 /* | |
| 8661 * Adjust DMA attributes. | |
| 8662 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary | |
| 8663 * from 8 bits to 16 bits, depending on a command being used. | |
| 8664 * Limiting max block count arbitrarily to 256 for all read/write | |
| 8665 * commands may affects performance, so check both the device and | |
| 8666 * controller capability before adjusting dma attributes. | |
| 8667 * For ATAPI CD/DVD dma granularity has to be adjusted as well, | |
| 8668 * because these devices support block size of 2k rather | |
| 8669 * then 512 bytes. | |
| 8670 */ | |
| 8671 void | |
| 8672 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, | |
| 8673 ddi_dma_attr_t *adj_dma_attr) | |
| 8674 { | |
| 8675 uint32_t count_max; | |
| 8676 | |
| 8677 /* Copy original attributes */ | |
| 8678 *adj_dma_attr = *dma_attr; | |
| 8679 | |
| 8680 /* | |
| 8681 * Things to consider: device addressing capability, | |
| 8682 * "excessive" controller DMA capabilities. | |
| 8683 * If a device is being probed/initialized, there are | |
| 8684 * no device info - use default limits then. | |
| 8685 */ | |
| 8686 if (sdinfo == NULL) { | |
| 8687 count_max = dma_attr->dma_attr_granular * 0x100; | |
| 8688 if (dma_attr->dma_attr_count_max > count_max) | |
| 8689 adj_dma_attr->dma_attr_count_max = count_max; | |
| 8690 if (dma_attr->dma_attr_maxxfer > count_max) | |
| 8691 adj_dma_attr->dma_attr_maxxfer = count_max; | |
| 8692 return; | |
| 8693 } | |
| 8694 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 8695 /* arbitrarily modify controller dma granularity */ | |
| 8696 adj_dma_attr->dma_attr_granular = SATA_ATAPI_SECTOR_SIZE; | |
| 8697 } | |
| 8698 | |
| 8699 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { | |
| 8700 /* | |
| 8701 * 16-bit sector count may be used - we rely on | |
| 8702 * the assumption that only read and write cmds | |
| 8703 * will request more than 256 sectors worth of data | |
| 8704 */ | |
| 8705 count_max = adj_dma_attr->dma_attr_granular * 0x10000; | |
| 8706 } else { | |
| 8707 /* | |
| 8708 * 8-bit sector count will be used - default limits | |
| 8709 * for dma attributes | |
| 8710 */ | |
| 8711 count_max = adj_dma_attr->dma_attr_granular * 0x100; | |
| 8712 } | |
| 8713 | |
| 8714 | |
| 8715 /* | |
| 8716 * Adjust controler dma attributes, if necessary | |
| 8717 */ | |
| 8718 if (dma_attr->dma_attr_count_max > count_max) | |
| 8719 adj_dma_attr->dma_attr_count_max = count_max; | |
| 8720 if (dma_attr->dma_attr_maxxfer > count_max) | |
| 8721 adj_dma_attr->dma_attr_maxxfer = count_max; | |
| 8722 } | |
| 8723 | |
| 8724 | |
| 8725 /* | |
| 8726 * Allocate DMA resources for the buffer | |
| 8727 * This function handles initial DMA resource allocation as well as | |
| 8728 * DMA window shift and may be called repeatedly for the same DMA window | |
| 8729 * until all DMA cookies in the DMA window are processed. | |
| 8730 * | |
| 8731 * Returns DDI_SUCCESS upon successful operation, | |
| 8732 * returns failure code returned by failing commands or DDI_FAILURE when | |
| 8733 * internal cleanup failed. | |
| 8734 */ | |
| 8735 static int | |
| 8736 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, | |
| 8737 int (*callback)(caddr_t), caddr_t arg, | |
| 8738 ddi_dma_attr_t *cur_dma_attr) | |
| 8739 { | |
| 8740 int rval; | |
| 8741 ddi_dma_cookie_t cookie; | |
| 8742 off_t offset; | |
| 8743 size_t size; | |
| 8744 int max_sg_len, req_sg_len, i; | |
| 8745 uint_t dma_flags; | |
| 8746 struct buf *bp; | |
| 8747 uint64_t max_txfer_len; | |
| 8748 uint64_t cur_txfer_len; | |
| 8749 | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8750 |
| 1258 | 8751 ASSERT(spx->txlt_sata_pkt != NULL); |
| 8752 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 8753 ASSERT(bp != NULL); | |
| 8754 | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
8755 |
| 1258 | 8756 if (spx->txlt_buf_dma_handle == NULL) { |
| 8757 /* | |
| 8758 * No DMA resources allocated so far - this is a first call | |
| 8759 * for this sata pkt. | |
| 8760 */ | |
| 8761 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), | |
| 8762 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); | |
| 8763 | |
| 8764 if (rval != DDI_SUCCESS) { | |
| 8765 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8766 "sata_dma_buf_setup: no buf DMA resources %x", | |
| 8767 rval)); | |
| 8768 return (rval); | |
| 8769 } | |
| 8770 | |
| 8771 if (bp->b_flags & B_READ) | |
| 8772 dma_flags = DDI_DMA_READ; | |
| 8773 else | |
| 8774 dma_flags = DDI_DMA_WRITE; | |
| 8775 | |
| 8776 if (flags & PKT_CONSISTENT) | |
| 8777 dma_flags |= DDI_DMA_CONSISTENT; | |
| 8778 | |
| 8779 if (flags & PKT_DMA_PARTIAL) | |
| 8780 dma_flags |= DDI_DMA_PARTIAL; | |
| 8781 | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8782 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8783 * Check buffer alignment and size against dma attributes |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8784 * Consider dma_attr_align only. There may be requests |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8785 * with the size lower then device granularity, but they |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8786 * 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
|
8787 * is necessary. The dma_attr_minxfer theoretically should |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8788 * be considered, but no HBA driver is checking it. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8789 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8790 if (IS_P2ALIGNED(bp->b_un.b_addr, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8791 cur_dma_attr->dma_attr_align)) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8792 rval = ddi_dma_buf_bind_handle( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8793 spx->txlt_buf_dma_handle, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8794 bp, dma_flags, callback, arg, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8795 &cookie, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8796 &spx->txlt_curwin_num_dma_cookies); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8797 } else { /* Buffer is not aligned */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8798 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8799 int (*ddicallback)(caddr_t); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8800 size_t bufsz; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8801 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8802 /* Check id sleeping is allowed */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8803 ddicallback = (callback == NULL_FUNC) ? |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8804 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8805 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8806 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8807 "mis-aligned buffer: addr=0x%p, cnt=%lu", |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8808 (void *)bp->b_un.b_addr, bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8809 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8810 if (bp->b_flags & (B_PAGEIO|B_PHYS)) |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8811 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8812 * CPU will need to access data in the buffer |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8813 * (for copying) so map it. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8814 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8815 bp_mapin(bp); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8816 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8817 ASSERT(spx->txlt_tmp_buf == NULL); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8818 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8819 /* Buffer may be padded by ddi_dma_mem_alloc()! */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8820 rval = ddi_dma_mem_alloc( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8821 spx->txlt_buf_dma_handle, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8822 bp->b_bcount, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8823 &sata_acc_attr, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8824 DDI_DMA_STREAMING, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8825 ddicallback, NULL, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8826 &spx->txlt_tmp_buf, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8827 &bufsz, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8828 &spx->txlt_tmp_buf_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8829 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8830 if (rval != DDI_SUCCESS) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8831 /* DMA mapping failed */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8832 (void) ddi_dma_free_handle( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8833 &spx->txlt_buf_dma_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8834 spx->txlt_buf_dma_handle = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8835 #ifdef SATA_DEBUG |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8836 mbuffail_count++; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8837 #endif |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8838 SATADBG1(SATA_DBG_DMA_SETUP, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8839 spx->txlt_sata_hba_inst, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8840 "sata_dma_buf_setup: " |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8841 "buf dma mem alloc failed %x\n", rval); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8842 return (rval); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8843 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8844 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8845 cur_dma_attr->dma_attr_align)); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8846 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8847 #ifdef SATA_DEBUG |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8848 mbuf_count++; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8849 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8850 if (bp->b_bcount != bufsz) |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8851 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8852 * This will require special handling, because |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8853 * DMA cookies will be based on the temporary |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8854 * buffer size, not the original buffer |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8855 * b_bcount, so the residue may have to |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8856 * be counted differently. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8857 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8858 SATADBG2(SATA_DBG_DMA_SETUP, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8859 spx->txlt_sata_hba_inst, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8860 "sata_dma_buf_setup: bp size %x != " |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8861 "bufsz %x\n", bp->b_bcount, bufsz); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8862 #endif |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8863 if (dma_flags & DDI_DMA_WRITE) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8864 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8865 * Write operation - copy data into |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8866 * an aligned temporary buffer. Buffer will be |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8867 * synced for device by ddi_dma_addr_bind_handle |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8868 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8869 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
|
8870 bp->b_bcount); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8871 } |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8872 |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8873 rval = ddi_dma_addr_bind_handle( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8874 spx->txlt_buf_dma_handle, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8875 NULL, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8876 spx->txlt_tmp_buf, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8877 bufsz, dma_flags, ddicallback, 0, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8878 &cookie, &spx->txlt_curwin_num_dma_cookies); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8879 } |
| 1258 | 8880 |
| 8881 switch (rval) { | |
| 8882 case DDI_DMA_PARTIAL_MAP: | |
| 8883 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 8884 "sata_dma_buf_setup: DMA Partial Map\n", NULL); | |
| 8885 /* | |
| 8886 * Partial DMA mapping. | |
| 8887 * Retrieve number of DMA windows for this request. | |
| 8888 */ | |
| 8889 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, | |
| 8890 &spx->txlt_num_dma_win) != DDI_SUCCESS) { | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8891 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8892 ddi_dma_mem_free( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8893 &spx->txlt_tmp_buf_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8894 spx->txlt_tmp_buf = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8895 } |
| 1258 | 8896 (void) ddi_dma_unbind_handle( |
| 8897 spx->txlt_buf_dma_handle); | |
| 8898 (void) ddi_dma_free_handle( | |
| 8899 &spx->txlt_buf_dma_handle); | |
| 8900 spx->txlt_buf_dma_handle = NULL; | |
| 8901 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8902 "sata_dma_buf_setup: numwin failed\n")); | |
| 8903 return (DDI_FAILURE); | |
| 8904 } | |
| 8905 spx->txlt_cur_dma_win = 0; | |
| 8906 break; | |
| 8907 | |
| 8908 case DDI_DMA_MAPPED: | |
| 8909 /* DMA fully mapped */ | |
| 8910 spx->txlt_num_dma_win = 1; | |
| 8911 spx->txlt_cur_dma_win = 0; | |
| 8912 break; | |
| 8913 | |
| 8914 default: | |
| 8915 /* DMA mapping failed */ | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8916 if (spx->txlt_tmp_buf != NULL) { |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8917 ddi_dma_mem_free( |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8918 &spx->txlt_tmp_buf_handle); |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8919 spx->txlt_tmp_buf = NULL; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8920 } |
| 1258 | 8921 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); |
| 8922 spx->txlt_buf_dma_handle = NULL; | |
| 8923 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8924 "sata_dma_buf_setup: buf dma handle binding " | |
| 8925 "failed %x\n", rval)); | |
| 8926 return (rval); | |
| 8927 } | |
| 8928 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 8929 spx->txlt_dma_cookie_list = NULL; | |
| 8930 } else { | |
| 8931 /* | |
| 8932 * DMA setup is reused. Check if we need to process more | |
| 8933 * cookies in current window, or to get next window, if any. | |
| 8934 */ | |
| 8935 | |
| 8936 ASSERT(spx->txlt_curwin_processed_dma_cookies <= | |
| 8937 spx->txlt_curwin_num_dma_cookies); | |
| 8938 | |
| 8939 if (spx->txlt_curwin_processed_dma_cookies == | |
| 8940 spx->txlt_curwin_num_dma_cookies) { | |
| 8941 /* | |
| 8942 * All cookies from current DMA window were processed. | |
| 8943 * Get next DMA window. | |
| 8944 */ | |
| 8945 spx->txlt_cur_dma_win++; | |
| 8946 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { | |
| 8947 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, | |
| 8948 spx->txlt_cur_dma_win, &offset, &size, | |
| 8949 &cookie, | |
| 8950 &spx->txlt_curwin_num_dma_cookies); | |
| 8951 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 8952 | |
| 8953 } else { | |
| 8954 /* No more windows! End of request! */ | |
| 8955 /* What to do? - panic for now */ | |
| 8956 ASSERT(spx->txlt_cur_dma_win >= | |
| 8957 spx->txlt_num_dma_win); | |
| 8958 | |
| 8959 spx->txlt_curwin_num_dma_cookies = 0; | |
| 8960 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 8961 spx->txlt_sata_pkt-> | |
| 8962 satapkt_cmd.satacmd_num_dma_cookies = 0; | |
| 8963 return (DDI_SUCCESS); | |
| 8964 } | |
| 8965 } | |
| 8966 } | |
| 8967 /* There better be at least one DMA cookie */ | |
| 8968 ASSERT((spx->txlt_curwin_num_dma_cookies - | |
| 8969 spx->txlt_curwin_processed_dma_cookies) > 0); | |
| 8970 | |
| 8971 if (spx->txlt_curwin_processed_dma_cookies == 0) { | |
| 8972 /* | |
| 8973 * Processing a new DMA window - set-up dma cookies list. | |
| 8974 * We may reuse previously allocated cookie array if it is | |
| 8975 * possible. | |
| 8976 */ | |
| 8977 if (spx->txlt_dma_cookie_list != NULL && | |
| 8978 spx->txlt_dma_cookie_list_len < | |
| 8979 spx->txlt_curwin_num_dma_cookies) { | |
| 8980 /* | |
| 8981 * New DMA window contains more cookies than | |
| 8982 * the previous one. We need larger cookie list - free | |
| 8983 * the old one. | |
| 8984 */ | |
| 8985 (void) kmem_free(spx->txlt_dma_cookie_list, | |
| 8986 spx->txlt_dma_cookie_list_len * | |
| 8987 sizeof (ddi_dma_cookie_t)); | |
| 8988 spx->txlt_dma_cookie_list = NULL; | |
| 8989 spx->txlt_dma_cookie_list_len = 0; | |
| 8990 } | |
| 8991 if (spx->txlt_dma_cookie_list == NULL) { | |
| 8992 /* Allocate new dma cookie array */ | |
| 8993 spx->txlt_dma_cookie_list = kmem_zalloc( | |
| 8994 sizeof (ddi_dma_cookie_t) * | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8995 spx->txlt_curwin_num_dma_cookies, |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
8996 callback == NULL_FUNC ? KM_NOSLEEP : KM_SLEEP); |
| 1258 | 8997 spx->txlt_dma_cookie_list_len = |
| 8998 spx->txlt_curwin_num_dma_cookies; | |
| 8999 } | |
| 9000 /* | |
| 9001 * Copy all DMA cookies into local list, so we will know their | |
| 9002 * dma_size in advance of setting the sata_pkt. | |
| 9003 * One cookie was already fetched, so copy it. | |
| 9004 */ | |
| 9005 *(&spx->txlt_dma_cookie_list[0]) = cookie; | |
| 9006 for (i = 1; i < spx->txlt_curwin_num_dma_cookies; i++) { | |
| 9007 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, &cookie); | |
| 9008 *(&spx->txlt_dma_cookie_list[i]) = cookie; | |
| 9009 } | |
| 9010 } else { | |
| 9011 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 9012 "sata_dma_buf_setup: sliding within DMA window, " | |
| 9013 "cur cookie %d, total cookies %d\n", | |
| 9014 spx->txlt_curwin_processed_dma_cookies, | |
| 9015 spx->txlt_curwin_num_dma_cookies); | |
| 9016 } | |
| 9017 | |
| 9018 /* | |
| 9019 * Set-up sata_pkt cookie list. | |
| 9020 * No single cookie transfer size would exceed max transfer size of | |
| 9021 * an ATA command used for addressed device (tha adjustment of the dma | |
| 9022 * attributes took care of this). But there may be more | |
| 9023 * then one cookie, so the cmd cookie list has to be | |
| 9024 * constrained by both a maximum scatter gather list length and | |
| 9025 * a maximum transfer size restriction of an ATA command. | |
| 9026 */ | |
| 9027 | |
| 9028 max_sg_len = cur_dma_attr->dma_attr_sgllen; | |
| 9029 req_sg_len = MIN(max_sg_len, | |
| 9030 (spx->txlt_curwin_num_dma_cookies - | |
| 9031 spx->txlt_curwin_processed_dma_cookies)); | |
| 9032 | |
| 9033 ASSERT(req_sg_len > 0); | |
| 9034 | |
| 9035 max_txfer_len = MAX((cur_dma_attr->dma_attr_granular * 0x100), | |
| 9036 cur_dma_attr->dma_attr_maxxfer); | |
| 9037 | |
| 9038 /* One cookie should be always available */ | |
| 9039 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = | |
| 9040 &spx->txlt_dma_cookie_list[spx->txlt_curwin_processed_dma_cookies]; | |
| 9041 | |
| 9042 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; | |
| 9043 | |
| 9044 cur_txfer_len = | |
| 9045 (uint64_t)spx->txlt_dma_cookie_list[ | |
| 9046 spx->txlt_curwin_processed_dma_cookies].dmac_size; | |
| 9047 | |
| 9048 spx->txlt_curwin_processed_dma_cookies++; | |
| 9049 | |
| 9050 ASSERT(cur_txfer_len <= max_txfer_len); | |
| 9051 | |
| 9052 /* Add more cookies to the scatter-gather list */ | |
| 9053 for (i = 1; i < req_sg_len; i++) { | |
| 9054 if (cur_txfer_len < max_txfer_len) { | |
| 9055 /* | |
| 9056 * Check if the next cookie could be used by | |
| 9057 * this sata_pkt. | |
| 9058 */ | |
| 9059 if ((cur_txfer_len + | |
| 9060 spx->txlt_dma_cookie_list[ | |
| 9061 spx->txlt_curwin_processed_dma_cookies]. | |
| 9062 dmac_size) <= max_txfer_len) { | |
| 9063 /* Yes, transfer lenght is within bounds */ | |
| 9064 spx->txlt_sata_pkt-> | |
| 9065 satapkt_cmd.satacmd_num_dma_cookies++; | |
| 9066 cur_txfer_len += | |
| 9067 spx->txlt_dma_cookie_list[ | |
| 9068 spx->txlt_curwin_processed_dma_cookies]. | |
| 9069 dmac_size; | |
| 9070 spx->txlt_curwin_processed_dma_cookies++; | |
| 9071 } else { | |
| 9072 /* No, transfer would exceed max lenght. */ | |
| 9073 SATADBG3(SATA_DBG_DMA_SETUP, | |
| 9074 spx->txlt_sata_hba_inst, | |
| 9075 "ncookies %d, size 0x%lx, " | |
| 9076 "max_size 0x%lx\n", | |
| 9077 spx->txlt_sata_pkt-> | |
| 9078 satapkt_cmd.satacmd_num_dma_cookies, | |
| 9079 cur_txfer_len, max_txfer_len); | |
| 9080 break; | |
| 9081 } | |
| 9082 } else { | |
| 9083 /* Cmd max transfer length reached */ | |
| 9084 SATADBG3(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 9085 "Max transfer length? " | |
| 9086 "ncookies %d, size 0x%lx, max_size 0x%lx\n", | |
| 9087 spx->txlt_sata_pkt-> | |
| 9088 satapkt_cmd.satacmd_num_dma_cookies, | |
| 9089 cur_txfer_len, max_txfer_len); | |
| 9090 break; | |
| 9091 } | |
| 9092 } | |
| 9093 | |
| 9094 ASSERT(cur_txfer_len != 0); | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9095 if (cur_txfer_len <= bp->b_bcount) |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9096 spx->txlt_total_residue -= cur_txfer_len; |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9097 else |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9098 /* |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9099 * Temporary DMA buffer has been padded by |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9100 * ddi_dma_mem_alloc()! |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9101 * This requires special handling, because DMA cookies are |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9102 * 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
|
9103 * 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
|
9104 * 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
|
9105 * the requested number of bytes. |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9106 */ |
|
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9107 spx->txlt_total_residue -= bp->b_bcount; |
| 1258 | 9108 |
| 9109 return (DDI_SUCCESS); | |
| 9110 } | |
| 9111 | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9112 |
| 1258 | 9113 /* |
| 9114 * Fetch Device Identify data. | |
| 9115 * Send DEVICE IDENTIFY command to a device and get the device identify data. | |
| 9116 * The device_info structure has to be set to device type (for selecting proper | |
| 9117 * device identify command). | |
| 9118 * | |
| 9119 * Returns 0 if success, -1 otherwise. | |
| 9120 * | |
| 9121 * Cannot be called in an interrupt context. | |
| 9122 */ | |
| 9123 | |
| 9124 static int | |
| 9125 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, | |
| 9126 sata_drive_info_t *sdinfo) | |
| 9127 { | |
| 9128 struct buf *bp; | |
| 9129 sata_pkt_t *spkt; | |
| 9130 sata_cmd_t *scmd; | |
| 9131 sata_pkt_txlate_t *spx; | |
| 9132 int rval; | |
| 9133 | |
| 9134 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); | |
| 9135 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 9136 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ | |
| 9137 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); | |
| 9138 if (spkt == NULL) { | |
| 9139 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 9140 return (-1); | |
| 9141 } | |
| 9142 /* address is needed now */ | |
| 9143 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 9144 | |
| 9145 /* | |
| 9146 * Allocate buffer for Identify Data return data | |
| 9147 */ | |
| 9148 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); | |
| 9149 if (bp == NULL) { | |
| 9150 sata_pkt_free(spx); | |
| 9151 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 9152 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9153 "sata_fetch_device_identify_data: " | |
| 9154 "cannot allocate buffer for ID")); | |
| 9155 return (-1); | |
| 9156 } | |
| 9157 | |
| 9158 /* Fill sata_pkt */ | |
| 9159 sdinfo->satadrv_state = SATA_STATE_PROBING; | |
| 9160 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 9161 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; | |
| 9162 /* Synchronous mode, no callback */ | |
| 9163 spkt->satapkt_comp = NULL; | |
| 9164 /* Timeout 30s */ | |
| 9165 spkt->satapkt_time = sata_default_pkt_time; | |
| 9166 | |
| 9167 scmd = &spkt->satapkt_cmd; | |
| 9168 scmd->satacmd_bp = bp; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9169 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
|
9170 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; |
| 1258 | 9171 |
| 9172 /* Build Identify Device cmd in the sata_pkt */ | |
| 9173 scmd->satacmd_addr_type = 0; /* N/A */ | |
| 9174 scmd->satacmd_sec_count_lsb = 0; /* N/A */ | |
| 9175 scmd->satacmd_lba_low_lsb = 0; /* N/A */ | |
| 9176 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ | |
| 9177 scmd->satacmd_lba_high_lsb = 0; /* N/A */ | |
| 9178 scmd->satacmd_features_reg = 0; /* N/A */ | |
| 9179 scmd->satacmd_device_reg = 0; /* Always device 0 */ | |
| 9180 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 9181 /* Identify Packet Device cmd */ | |
| 9182 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; | |
| 9183 } else { | |
| 9184 /* Identify Device cmd - mandatory for all other devices */ | |
| 9185 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; | |
| 9186 } | |
| 9187 | |
| 9188 /* Send pkt to SATA HBA driver */ | |
| 9189 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != | |
| 9190 SATA_TRAN_ACCEPTED || | |
| 9191 spkt->satapkt_reason != SATA_PKT_COMPLETED) { | |
| 9192 /* | |
| 9193 * Woops, no Identify Data. | |
| 9194 * Invalidate sata_drive_info ? | |
| 9195 */ | |
| 9196 rval = -1; | |
| 9197 } else { | |
| 9198 /* Update sata_drive_info */ | |
| 9199 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, | |
| 9200 DDI_DMA_SYNC_FORKERNEL); | |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
9201 ASSERT(rval == DDI_SUCCESS); |
| 1258 | 9202 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, |
| 9203 sizeof (sata_id_t)); | |
| 9204 | |
| 9205 sdinfo->satadrv_features_support = 0; | |
| 9206 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { | |
| 9207 /* | |
| 9208 * Retrieve capacity (disks only) and addressing mode | |
| 9209 */ | |
| 9210 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); | |
| 9211 } else { | |
| 9212 /* | |
| 9213 * For ATAPI devices one has to issue Get Capacity cmd | |
| 9214 * (not needed at the moment) | |
| 9215 */ | |
| 9216 sdinfo->satadrv_capacity = 0; | |
| 9217 } | |
| 9218 /* Setup supported features flags */ | |
| 9219 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) | |
| 9220 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; | |
| 9221 | |
| 9222 /* Check for NCQ support */ | |
| 9223 if (sdinfo->satadrv_id.ai_satacap != 0 && | |
| 9224 sdinfo->satadrv_id.ai_satacap != 0xffff) { | |
| 9225 /* SATA compliance */ | |
| 9226 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) | |
| 9227 sdinfo->satadrv_features_support |= | |
| 9228 SATA_DEV_F_NCQ; | |
| 9229 if (sdinfo->satadrv_id.ai_satacap & | |
| 9230 (SATA_1_SPEED | SATA_2_SPEED)) { | |
| 9231 if (sdinfo->satadrv_id.ai_satacap & | |
| 9232 SATA_2_SPEED) | |
| 9233 sdinfo->satadrv_features_support |= | |
| 9234 SATA_DEV_F_SATA2; | |
| 9235 if (sdinfo->satadrv_id.ai_satacap & | |
| 9236 SATA_1_SPEED) | |
| 9237 sdinfo->satadrv_features_support |= | |
| 9238 SATA_DEV_F_SATA1; | |
| 9239 } else { | |
| 9240 sdinfo->satadrv_features_support |= | |
| 9241 SATA_DEV_F_SATA1; | |
| 9242 } | |
| 9243 } | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
9244 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
|
9245 (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
|
9246 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; |
| 1258 | 9247 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9248 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
|
9249 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9250 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9251 ++sdinfo->satadrv_queue_depth; |
|
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
9252 |
| 1258 | 9253 rval = 0; |
| 9254 } | |
| 9255 fail: | |
| 9256 /* Free allocated resources */ | |
| 9257 sata_free_local_buffer(spx); | |
| 9258 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 9259 sata_pkt_free(spx); | |
| 9260 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 9261 | |
| 9262 return (rval); | |
| 9263 } | |
| 9264 | |
| 9265 | |
| 9266 /* | |
| 9267 * SATA spec requires that the device supports at least UDMA 4 mode and | |
| 9268 * UDMA mode is selected. | |
| 9269 * Some devices (bridged devices) may not come-up with default UDMA mode | |
| 9270 * set correctly, so this function is setting it. | |
| 9271 * | |
| 9272 * Returns SATA_SUCCESS if proper UDMA mode is selected. | |
| 9273 * Returns SATA_FAILURE if proper UDMA mode could not be selected. | |
| 9274 */ | |
| 9275 static int | |
| 9276 sata_set_udma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) | |
| 9277 { | |
| 9278 sata_pkt_t *spkt; | |
| 9279 sata_cmd_t *scmd; | |
| 9280 sata_pkt_txlate_t *spx; | |
| 9281 int result = SATA_SUCCESS; | |
| 9282 int i, mode; | |
| 9283 | |
| 9284 ASSERT(sdinfo != NULL); | |
| 9285 ASSERT(sata_hba_inst != NULL); | |
| 9286 | |
| 9287 /* Find highest Ultra DMA mode supported */ | |
| 9288 for (mode = 6; mode >= 0; --mode) { | |
| 9289 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) | |
| 9290 break; | |
| 9291 } | |
| 9292 if (mode < 4) | |
| 9293 return (SATA_FAILURE); | |
| 9294 | |
| 9295 /* Find UDMA mode currently selected */ | |
| 9296 for (i = 6; i >= 0; --i) { | |
| 9297 if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8))) | |
| 9298 break; | |
| 9299 } | |
| 9300 | |
| 9301 if (i < mode) { | |
| 9302 /* Set UDMA mode via SET FEATURES COMMAND */ | |
| 9303 /* Prepare packet for SET FEATURES COMMAND */ | |
| 9304 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); | |
| 9305 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 9306 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ | |
| 9307 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); | |
| 9308 if (spkt == NULL) { | |
| 9309 result = SATA_FAILURE; | |
| 9310 goto failure; | |
| 9311 } | |
| 9312 /* Fill sata_pkt */ | |
| 9313 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 9314 /* Timeout 30s */ | |
| 9315 spkt->satapkt_time = sata_default_pkt_time; | |
| 9316 /* Synchronous mode, no callback, interrupts */ | |
| 9317 spkt->satapkt_op_mode = | |
| 9318 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; | |
| 9319 spkt->satapkt_comp = NULL; | |
| 9320 scmd = &spkt->satapkt_cmd; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9321 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
|
9322 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; |
| 1258 | 9323 scmd->satacmd_addr_type = 0; |
| 9324 scmd->satacmd_device_reg = 0; | |
| 9325 scmd->satacmd_status_reg = 0; | |
| 9326 scmd->satacmd_error_reg = 0; | |
| 9327 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; | |
| 9328 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; | |
| 9329 scmd->satacmd_sec_count_lsb = | |
| 9330 SATAC_TRANSFER_MODE_ULTRA_DMA | mode; | |
| 9331 | |
| 9332 /* Transfer command to HBA */ | |
| 9333 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), | |
| 9334 spkt) != SATA_TRAN_ACCEPTED || | |
| 9335 spkt->satapkt_reason != SATA_PKT_COMPLETED) { | |
| 9336 /* Pkt execution failed */ | |
| 9337 result = SATA_FAILURE; | |
| 9338 } | |
| 9339 failure: | |
| 9340 if (result == SATA_FAILURE) | |
| 9341 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9342 "sata_set_udma_mode: could not set UDMA " | |
| 9343 "mode %", mode)); | |
| 9344 | |
| 9345 /* Free allocated resources */ | |
| 9346 if (spkt != NULL) | |
| 9347 sata_pkt_free(spx); | |
| 9348 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 9349 } | |
| 9350 return (result); | |
| 9351 } | |
| 9352 | |
| 9353 | |
| 9354 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9355 * Set device caching mode. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9356 * One of the following operations should be specified: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9357 * SATAC_SF_ENABLE_READ_AHEAD |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9358 * SATAC_SF_DISABLE_READ_AHEAD |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9359 * SATAC_SF_ENABLE_WRITE_CACHE |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9360 * SATAC_SF_DISABLE_WRITE_CACHE |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9361 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9362 * If operation fails, system log messgage is emitted. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9363 * 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
|
9364 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9365 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9366 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9367 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
|
9368 int cache_op) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9369 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9370 sata_pkt_t *spkt; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9371 sata_cmd_t *scmd; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9372 sata_pkt_txlate_t *spx; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9373 int rval = SATA_SUCCESS; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9374 char *infop; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9375 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9376 ASSERT(sdinfo != NULL); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9377 ASSERT(sata_hba_inst != NULL); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9378 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9379 cache_op == SATAC_SF_DISABLE_READ_AHEAD || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9380 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9381 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9382 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9383 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9384 /* Prepare packet for SET FEATURES COMMAND */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9385 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
|
9386 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9387 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
|
9388 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9389 if (spkt == NULL) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9390 rval = SATA_FAILURE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9391 goto failure; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9392 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9393 /* Fill sata_pkt */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9394 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9395 /* Timeout 30s */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9396 spkt->satapkt_time = sata_default_pkt_time; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9397 /* Synchronous mode, no callback, interrupts */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9398 spkt->satapkt_op_mode = |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9399 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9400 spkt->satapkt_comp = NULL; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9401 scmd = &spkt->satapkt_cmd; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9402 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
|
9403 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
|
9404 scmd->satacmd_addr_type = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9405 scmd->satacmd_device_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9406 scmd->satacmd_status_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9407 scmd->satacmd_error_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9408 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9409 scmd->satacmd_features_reg = cache_op; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9410 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9411 /* Transfer command to HBA */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9412 if (((*SATA_START_FUNC(sata_hba_inst))( |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9413 SATA_DIP(sata_hba_inst), spkt) != 0) || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9414 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9415 /* Pkt execution failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9416 switch (cache_op) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9417 case SATAC_SF_ENABLE_READ_AHEAD: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9418 infop = "enabling read ahead failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9419 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9420 case SATAC_SF_DISABLE_READ_AHEAD: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9421 infop = "disabling read ahead failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9422 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9423 case SATAC_SF_ENABLE_WRITE_CACHE: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9424 infop = "enabling write cache failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9425 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9426 case SATAC_SF_DISABLE_WRITE_CACHE: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9427 infop = "disabling write cache failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9428 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9429 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9430 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
|
9431 rval = SATA_FAILURE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9432 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9433 failure: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9434 /* Free allocated resources */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9435 if (spkt != NULL) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9436 sata_pkt_free(spx); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9437 (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
|
9438 return (rval); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9439 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9440 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9441 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9442 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9443 /* |
| 1258 | 9444 * Update port SCR block |
| 9445 */ | |
| 9446 static void | |
| 9447 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device) | |
| 9448 { | |
| 9449 port_scr->sstatus = device->satadev_scr.sstatus; | |
| 9450 port_scr->serror = device->satadev_scr.serror; | |
| 9451 port_scr->scontrol = device->satadev_scr.scontrol; | |
| 9452 port_scr->sactive = device->satadev_scr.sactive; | |
| 9453 port_scr->snotific = device->satadev_scr.snotific; | |
| 9454 } | |
| 9455 | |
| 9456 /* | |
| 9457 * Update state and copy port ss* values from passed sata_device structure. | |
| 9458 * sata_address is validated - if not valid, nothing is changed in sata_scsi | |
| 9459 * configuration struct. | |
| 9460 * | |
| 9461 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function | |
| 9462 * regardless of the state in device argument. | |
| 9463 * | |
| 9464 * Port mutex should be held while calling this function. | |
| 9465 */ | |
| 9466 static void | |
| 9467 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, | |
| 9468 sata_device_t *sata_device) | |
| 9469 { | |
| 9470 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, | |
| 9471 sata_device->satadev_addr.cport))); | |
| 9472 | |
| 9473 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || | |
| 9474 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { | |
| 9475 | |
| 9476 sata_cport_info_t *cportinfo; | |
| 9477 | |
| 9478 if (SATA_NUM_CPORTS(sata_hba_inst) <= | |
| 9479 sata_device->satadev_addr.cport) | |
| 9480 return; | |
| 9481 | |
| 9482 cportinfo = SATA_CPORT_INFO(sata_hba_inst, | |
| 9483 sata_device->satadev_addr.cport); | |
| 9484 sata_update_port_scr(&cportinfo->cport_scr, sata_device); | |
| 9485 | |
| 9486 /* Preserve SATA_PSTATE_SHUTDOWN flag */ | |
| 9487 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | | |
| 9488 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); | |
| 9489 cportinfo->cport_state |= | |
| 9490 sata_device->satadev_state & SATA_PSTATE_VALID; | |
| 9491 } else { | |
| 9492 sata_pmport_info_t *pmportinfo; | |
| 9493 | |
| 9494 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) || | |
| 9495 (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || | |
| 9496 SATA_NUM_PMPORTS(sata_hba_inst, | |
| 9497 sata_device->satadev_addr.cport) < | |
| 9498 sata_device->satadev_addr.pmport) | |
| 9499 return; | |
| 9500 | |
| 9501 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, | |
| 9502 sata_device->satadev_addr.cport, | |
| 9503 sata_device->satadev_addr.pmport); | |
| 9504 sata_update_port_scr(&pmportinfo->pmport_scr, sata_device); | |
| 9505 | |
| 9506 /* Preserve SATA_PSTATE_SHUTDOWN flag */ | |
| 9507 pmportinfo->pmport_state &= | |
| 9508 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | | |
| 9509 SATA_PSTATE_FAILED); | |
| 9510 pmportinfo->pmport_state |= | |
| 9511 sata_device->satadev_state & SATA_PSTATE_VALID; | |
| 9512 } | |
| 9513 } | |
| 9514 | |
| 9515 | |
| 9516 | |
| 9517 /* | |
| 9518 * Extract SATA port specification from an IOCTL argument. | |
| 9519 * | |
| 9520 * This function return the port the user land send us as is, unless it | |
| 9521 * cannot retrieve port spec, then -1 is returned. | |
| 9522 * | |
| 9523 * Note: Only cport - no port multiplier port. | |
| 9524 */ | |
| 9525 static int32_t | |
| 9526 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) | |
| 9527 { | |
| 9528 int32_t port; | |
| 9529 | |
| 9530 /* Extract port number from nvpair in dca structure */ | |
| 9531 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { | |
| 9532 SATA_LOG_D((sata_hba_inst, CE_NOTE, | |
| 9533 "sata_get_port_num: invalid port spec 0x%x in ioctl", | |
| 9534 port)); | |
| 9535 port = -1; | |
| 9536 } | |
| 9537 | |
| 9538 return (port); | |
| 9539 } | |
| 9540 | |
| 9541 /* | |
| 9542 * Get dev_info_t pointer to the device node pointed to by port argument. | |
| 9543 * NOTE: target argument is a value used in ioctls to identify | |
| 9544 * the AP - it is not a sata_address. | |
| 9545 * It is a combination of cport, pmport and address qualifier, encodded same | |
| 9546 * way as a scsi target number. | |
| 9547 * At this moment it carries only cport number. | |
| 9548 * | |
| 9549 * No PMult hotplug support. | |
| 9550 * | |
| 9551 * Returns dev_info_t pointer if target device was found, NULL otherwise. | |
| 9552 */ | |
| 9553 | |
| 9554 static dev_info_t * | |
| 9555 sata_get_target_dip(dev_info_t *dip, int32_t port) | |
| 9556 { | |
| 9557 dev_info_t *cdip = NULL; | |
| 9558 int target, tgt; | |
| 9559 int ncport; | |
| 9560 int circ; | |
| 9561 | |
| 9562 ncport = port & SATA_CFGA_CPORT_MASK; | |
| 9563 target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT); | |
| 9564 | |
| 9565 ndi_devi_enter(dip, &circ); | |
| 9566 for (cdip = ddi_get_child(dip); cdip != NULL; ) { | |
| 9567 dev_info_t *next = ddi_get_next_sibling(cdip); | |
| 9568 | |
| 9569 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, | |
| 9570 DDI_PROP_DONTPASS, "target", -1); | |
| 9571 if (tgt == -1) { | |
| 9572 /* | |
| 9573 * This is actually an error condition, but not | |
| 9574 * a fatal one. Just continue the search. | |
| 9575 */ | |
| 9576 cdip = next; | |
| 9577 continue; | |
| 9578 } | |
| 9579 | |
| 9580 if (tgt == target) | |
| 9581 break; | |
| 9582 | |
| 9583 cdip = next; | |
| 9584 } | |
| 9585 ndi_devi_exit(dip, circ); | |
| 9586 | |
| 9587 return (cdip); | |
| 9588 } | |
| 9589 | |
| 9590 | |
| 9591 /* | |
| 9592 * sata_cfgadm_state: | |
| 9593 * Use the sata port state and state of the target node to figure out | |
| 9594 * the cfgadm_state. | |
| 9595 * | |
| 9596 * The port argument is a value with encoded cport, | |
| 9597 * pmport and address qualifier, in the same manner as a scsi target number. | |
| 9598 * SCSI_TO_SATA_CPORT macro extracts cport number, | |
| 9599 * SCSI_TO_SATA_PMPORT extracts pmport number and | |
| 9600 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. | |
| 9601 * | |
| 9602 * For now, support is for cports only - no pmultiplier ports. | |
| 9603 */ | |
| 9604 | |
| 9605 static void | |
| 9606 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, | |
| 9607 devctl_ap_state_t *ap_state) | |
| 9608 { | |
| 9609 uint16_t cport; | |
| 9610 int port_state; | |
| 9611 | |
| 9612 /* Cport only */ | |
| 9613 cport = SCSI_TO_SATA_CPORT(port); | |
| 9614 | |
| 9615 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); | |
| 9616 if (port_state & SATA_PSTATE_SHUTDOWN || | |
| 9617 port_state & SATA_PSTATE_FAILED) { | |
| 9618 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; | |
| 9619 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9620 if (port_state & SATA_PSTATE_FAILED) | |
| 9621 ap_state->ap_condition = AP_COND_FAILED; | |
| 9622 else | |
| 9623 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9624 | |
| 9625 return; | |
| 9626 } | |
| 9627 | |
| 9628 /* Need to check pmult device port here as well, when supported */ | |
| 9629 | |
| 9630 /* Port is enabled and ready */ | |
| 9631 | |
| 9632 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { | |
| 9633 case SATA_DTYPE_NONE: | |
| 9634 { | |
| 9635 /* No device attached */ | |
| 9636 ap_state->ap_rstate = AP_RSTATE_EMPTY; | |
| 9637 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9638 ap_state->ap_condition = AP_COND_OK; | |
| 9639 break; | |
| 9640 } | |
| 9641 case SATA_DTYPE_UNKNOWN: | |
| 9642 case SATA_DTYPE_ATAPINONCD: | |
| 9643 case SATA_DTYPE_PMULT: /* Until PMult is supported */ | |
| 9644 { | |
| 9645 /* Unknown device attached */ | |
| 9646 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 9647 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9648 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9649 break; | |
| 9650 } | |
| 9651 case SATA_DTYPE_ATADISK: | |
| 9652 case SATA_DTYPE_ATAPICD: | |
| 9653 { | |
| 9654 dev_info_t *tdip = NULL; | |
| 9655 dev_info_t *dip = NULL; | |
| 9656 int circ; | |
| 9657 | |
| 9658 dip = SATA_DIP(sata_hba_inst); | |
| 9659 tdip = sata_get_target_dip(dip, port); | |
| 9660 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 9661 if (tdip != NULL) { | |
| 9662 ndi_devi_enter(dip, &circ); | |
| 9663 mutex_enter(&(DEVI(tdip)->devi_lock)); | |
| 9664 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || | |
| 9665 (DEVI_IS_DEVICE_DOWN(tdip))) { | |
| 9666 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9667 } else { | |
| 9668 ap_state->ap_ostate = AP_OSTATE_CONFIGURED; | |
| 9669 } | |
| 9670 ap_state->ap_condition = AP_COND_OK; | |
| 9671 mutex_exit(&(DEVI(tdip)->devi_lock)); | |
| 9672 ndi_devi_exit(dip, circ); | |
| 9673 } else { | |
| 9674 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9675 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9676 } | |
| 9677 break; | |
| 9678 } | |
| 9679 default: | |
| 9680 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 9681 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9682 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9683 /* | |
| 9684 * This is actually internal error condition (non fatal), | |
| 9685 * beacuse we already checked all defined device types. | |
| 9686 */ | |
| 9687 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9688 "sata_cfgadm_state: Internal error: " | |
| 9689 "unknown device type")); | |
| 9690 break; | |
| 9691 } | |
| 9692 } | |
| 9693 | |
| 9694 /* | |
| 9695 * Start or terminate the thread, depending on flag arg and current state | |
| 9696 */ | |
| 9697 static void | |
| 9698 sata_event_thread_control(int startstop) | |
| 9699 { | |
| 9700 static int sata_event_thread_terminating = 0; | |
| 9701 static int sata_event_thread_starting = 0; | |
| 9702 int i; | |
| 9703 | |
| 9704 mutex_enter(&sata_event_mutex); | |
| 9705 | |
| 9706 if (startstop == 0 && (sata_event_thread_starting == 1 || | |
| 9707 sata_event_thread_terminating == 1)) { | |
| 9708 mutex_exit(&sata_event_mutex); | |
| 9709 return; | |
| 9710 } | |
| 9711 if (startstop == 1 && sata_event_thread_starting == 1) { | |
| 9712 mutex_exit(&sata_event_mutex); | |
| 9713 return; | |
| 9714 } | |
| 9715 if (startstop == 1 && sata_event_thread_terminating == 1) { | |
| 9716 sata_event_thread_starting = 1; | |
| 9717 /* wait til terminate operation completes */ | |
| 9718 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; | |
| 9719 while (sata_event_thread_terminating == 1) { | |
| 9720 if (i-- <= 0) { | |
| 9721 sata_event_thread_starting = 0; | |
| 9722 mutex_exit(&sata_event_mutex); | |
| 9723 #ifdef SATA_DEBUG | |
| 9724 cmn_err(CE_WARN, "sata_event_thread_control: " | |
| 9725 "timeout waiting for thread to terminate"); | |
| 9726 #endif | |
| 9727 return; | |
| 9728 } | |
| 9729 mutex_exit(&sata_event_mutex); | |
| 9730 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); | |
| 9731 mutex_enter(&sata_event_mutex); | |
| 9732 } | |
| 9733 } | |
| 9734 if (startstop == 1) { | |
| 9735 if (sata_event_thread == NULL) { | |
| 9736 sata_event_thread = thread_create(NULL, 0, | |
| 9737 (void (*)())sata_event_daemon, | |
| 9738 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); | |
| 9739 } | |
| 9740 sata_event_thread_starting = 0; | |
| 9741 mutex_exit(&sata_event_mutex); | |
| 9742 return; | |
| 9743 } | |
| 9744 | |
| 9745 /* | |
| 9746 * If we got here, thread may need to be terminated | |
| 9747 */ | |
| 9748 if (sata_event_thread != NULL) { | |
| 9749 int i; | |
| 9750 /* Signal event thread to go away */ | |
| 9751 sata_event_thread_terminating = 1; | |
| 9752 sata_event_thread_terminate = 1; | |
| 9753 cv_signal(&sata_event_cv); | |
| 9754 /* | |
| 9755 * Wait til daemon terminates. | |
| 9756 */ | |
| 9757 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; | |
| 9758 while (sata_event_thread_terminate == 1) { | |
| 9759 mutex_exit(&sata_event_mutex); | |
| 9760 if (i-- <= 0) { | |
| 9761 /* Daemon did not go away !!! */ | |
| 9762 #ifdef SATA_DEBUG | |
| 9763 cmn_err(CE_WARN, "sata_event_thread_control: " | |
| 9764 "cannot terminate event daemon thread"); | |
| 9765 #endif | |
| 9766 mutex_enter(&sata_event_mutex); | |
| 9767 break; | |
| 9768 } | |
| 9769 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); | |
| 9770 mutex_enter(&sata_event_mutex); | |
| 9771 } | |
| 9772 sata_event_thread_terminating = 0; | |
| 9773 } | |
| 9774 ASSERT(sata_event_thread_terminating == 0); | |
| 9775 ASSERT(sata_event_thread_starting == 0); | |
| 9776 mutex_exit(&sata_event_mutex); | |
| 9777 } | |
| 9778 | |
| 9779 | |
| 9780 /* | |
| 9781 * Log sata message | |
| 9782 * dev pathname msg line preceeds the logged message. | |
| 9783 */ | |
| 9784 | |
| 9785 static void | |
| 9786 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) | |
| 9787 { | |
| 9788 char pathname[128]; | |
| 9789 dev_info_t *dip; | |
| 9790 va_list ap; | |
| 9791 | |
| 9792 mutex_enter(&sata_log_mutex); | |
| 9793 | |
| 9794 va_start(ap, fmt); | |
| 9795 (void) vsprintf(sata_log_buf, fmt, ap); | |
| 9796 va_end(ap); | |
| 9797 | |
| 9798 if (sata_hba_inst != NULL) { | |
| 9799 dip = SATA_DIP(sata_hba_inst); | |
| 9800 (void) ddi_pathname(dip, pathname); | |
| 9801 } else { | |
| 9802 pathname[0] = 0; | |
| 9803 } | |
| 9804 if (level == CE_CONT) { | |
| 9805 if (sata_debug_flags == 0) | |
| 9806 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); | |
| 9807 else | |
| 9808 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); | |
| 9809 } else | |
| 9810 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); | |
| 9811 | |
| 9812 mutex_exit(&sata_log_mutex); | |
| 9813 } | |
| 9814 | |
| 9815 | |
| 9816 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ | |
| 9817 | |
| 9818 /* | |
| 9819 * SATA HBA event notification function. | |
| 9820 * Events reported by SATA HBA drivers per HBA instance relate to a change in | |
| 9821 * a port and/or device state or a controller itself. | |
| 9822 * Events for different addresses/addr types cannot be combined. | |
| 9823 * A warning message is generated for each event type. | |
| 9824 * Events are not processed by this function, so only the | |
| 9825 * event flag(s)is set for an affected entity and the event thread is | |
| 9826 * waken up. Event daemon thread processes all events. | |
| 9827 * | |
| 9828 * NOTE: Since more than one event may be reported at the same time, one | |
| 9829 * cannot determine a sequence of events when opposite event are reported, eg. | |
| 9830 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing | |
| 9831 * is taking precedence over reported events, i.e. may cause ignoring some | |
| 9832 * events. | |
| 9833 */ | |
| 9834 #define SATA_EVENT_MAX_MSG_LENGTH 79 | |
| 9835 | |
| 9836 void | |
| 9837 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) | |
| 9838 { | |
| 9839 sata_hba_inst_t *sata_hba_inst = NULL; | |
| 9840 sata_address_t *saddr; | |
| 9841 sata_drive_info_t *sdinfo; | |
| 9842 sata_port_stats_t *pstats; | |
| 9843 int cport, pmport; | |
| 9844 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; | |
| 9845 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; | |
| 9846 char *lcp; | |
| 9847 static char *err_msg_evnt_1 = | |
| 9848 "sata_hba_event_notify: invalid port event 0x%x "; | |
| 9849 static char *err_msg_evnt_2 = | |
| 9850 "sata_hba_event_notify: invalid device event 0x%x "; | |
| 9851 int linkevent; | |
| 9852 | |
| 9853 /* | |
| 9854 * There is a possibility that an event will be generated on HBA | |
| 9855 * that has not completed attachment or is detaching. | |
| 9856 * HBA driver should prevent this, but just in case it does not, | |
| 9857 * we need to ignore events for such HBA. | |
| 9858 */ | |
| 9859 mutex_enter(&sata_mutex); | |
| 9860 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 9861 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 9862 if (SATA_DIP(sata_hba_inst) == dip) | |
| 9863 if (sata_hba_inst->satahba_attached == 1) | |
| 9864 break; | |
| 9865 } | |
| 9866 mutex_exit(&sata_mutex); | |
| 9867 if (sata_hba_inst == NULL) | |
| 9868 /* HBA not attached */ | |
| 9869 return; | |
| 9870 | |
| 9871 ASSERT(sata_device != NULL); | |
| 9872 | |
| 9873 /* | |
| 9874 * Validate address before - do not proceed with invalid address. | |
| 9875 */ | |
| 9876 saddr = &sata_device->satadev_addr; | |
| 9877 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 9878 return; | |
| 9879 if (saddr->qual == SATA_ADDR_PMPORT || | |
| 9880 saddr->qual == SATA_ADDR_DPMPORT) | |
| 9881 /* Port Multiplier not supported yet */ | |
| 9882 return; | |
| 9883 | |
| 9884 cport = saddr->cport; | |
| 9885 pmport = saddr->pmport; | |
| 9886 | |
| 9887 buf1[0] = buf2[0] = '\0'; | |
| 9888 | |
| 9889 /* | |
| 9890 * Events refer to devices, ports and controllers - each has | |
| 9891 * unique address. Events for different addresses cannot be combined. | |
| 9892 */ | |
| 9893 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { | |
| 9894 | |
| 9895 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9896 | |
| 9897 /* qualify this event(s) */ | |
| 9898 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { | |
| 9899 /* Invalid event for the device port */ | |
| 9900 (void) sprintf(buf2, err_msg_evnt_1, | |
| 9901 event & SATA_EVNT_PORT_EVENTS); | |
| 9902 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9903 goto event_info; | |
| 9904 } | |
| 9905 if (saddr->qual == SATA_ADDR_CPORT) { | |
| 9906 /* Controller's device port event */ | |
| 9907 | |
| 9908 (SATA_CPORT_INFO(sata_hba_inst, cport))-> | |
| 9909 cport_event_flags |= | |
| 9910 event & SATA_EVNT_PORT_EVENTS; | |
| 9911 pstats = | |
| 9912 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> | |
| 9913 cport_stats; | |
| 9914 } else { | |
| 9915 /* Port multiplier's device port event */ | |
| 9916 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> | |
| 9917 pmport_event_flags |= | |
| 9918 event & SATA_EVNT_PORT_EVENTS; | |
| 9919 pstats = | |
| 9920 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> | |
| 9921 pmport_stats; | |
| 9922 } | |
| 9923 | |
| 9924 /* | |
| 9925 * Add to statistics and log the message. We have to do it | |
| 9926 * here rather than in the event daemon, because there may be | |
| 9927 * multiple events occuring before they are processed. | |
| 9928 */ | |
| 9929 linkevent = event & | |
| 9930 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); | |
| 9931 if (linkevent) { | |
| 9932 if (linkevent == (SATA_EVNT_LINK_LOST | | |
| 9933 SATA_EVNT_LINK_ESTABLISHED)) { | |
| 9934 /* This is likely event combination */ | |
| 9935 (void) strlcat(buf1, "link lost/established, ", | |
| 9936 SATA_EVENT_MAX_MSG_LENGTH); | |
| 9937 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9938 if (pstats->link_lost < 0xffffffffffffffffULL) |
| 1258 | 9939 pstats->link_lost++; |
| 9940 if (pstats->link_established < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9941 0xffffffffffffffffULL) |
| 1258 | 9942 pstats->link_established++; |
| 9943 linkevent = 0; | |
| 9944 } else if (linkevent & SATA_EVNT_LINK_LOST) { | |
| 9945 (void) strlcat(buf1, "link lost, ", | |
| 9946 SATA_EVENT_MAX_MSG_LENGTH); | |
| 9947 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9948 if (pstats->link_lost < 0xffffffffffffffffULL) |
| 1258 | 9949 pstats->link_lost++; |
| 9950 } else { | |
| 9951 (void) strlcat(buf1, "link established, ", | |
| 9952 SATA_EVENT_MAX_MSG_LENGTH); | |
| 9953 if (pstats->link_established < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9954 0xffffffffffffffffULL) |
| 1258 | 9955 pstats->link_established++; |
| 9956 } | |
| 9957 } | |
| 9958 if (event & SATA_EVNT_DEVICE_ATTACHED) { | |
| 9959 (void) strlcat(buf1, "device attached, ", | |
| 9960 SATA_EVENT_MAX_MSG_LENGTH); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9961 if (pstats->device_attached < 0xffffffffffffffffULL) |
| 1258 | 9962 pstats->device_attached++; |
| 9963 } | |
| 9964 if (event & SATA_EVNT_DEVICE_DETACHED) { | |
| 9965 (void) strlcat(buf1, "device detached, ", | |
| 9966 SATA_EVENT_MAX_MSG_LENGTH); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9967 if (pstats->device_detached < 0xffffffffffffffffULL) |
| 1258 | 9968 pstats->device_detached++; |
| 9969 } | |
| 9970 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { | |
| 9971 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 9972 "port %d power level changed", cport); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9973 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) |
| 1258 | 9974 pstats->port_pwr_changed++; |
| 9975 } | |
| 9976 | |
| 9977 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { | |
| 9978 /* There should be no other events for this address */ | |
| 9979 (void) sprintf(buf2, err_msg_evnt_1, | |
| 9980 event & ~SATA_EVNT_PORT_EVENTS); | |
| 9981 } | |
| 9982 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9983 | |
| 9984 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { | |
| 9985 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9986 | |
| 9987 /* qualify this event */ | |
| 9988 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { | |
| 9989 /* Invalid event for a device */ | |
| 9990 (void) sprintf(buf2, err_msg_evnt_2, | |
| 9991 event & SATA_EVNT_DEVICE_RESET); | |
| 9992 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9993 goto event_info; | |
| 9994 } | |
| 9995 /* drive event */ | |
| 9996 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 9997 if (sdinfo != NULL) { | |
| 9998 if (event & SATA_EVNT_DEVICE_RESET) { | |
| 9999 (void) strlcat(buf1, "device reset, ", | |
| 10000 SATA_EVENT_MAX_MSG_LENGTH); | |
| 10001 if (sdinfo->satadrv_stats.drive_reset < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10002 0xffffffffffffffffULL) |
| 1258 | 10003 sdinfo->satadrv_stats.drive_reset++; |
| 10004 sdinfo->satadrv_event_flags |= | |
| 10005 SATA_EVNT_DEVICE_RESET; | |
| 10006 } | |
| 10007 } | |
| 10008 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { | |
| 10009 /* Invalid event for a device */ | |
| 10010 (void) sprintf(buf2, err_msg_evnt_2, | |
| 10011 event & ~SATA_EVNT_DRIVE_EVENTS); | |
| 10012 } | |
| 10013 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 10014 } else { | |
| 10015 if (saddr->qual != SATA_ADDR_NULL) { | |
| 10016 /* Wrong address qualifier */ | |
| 10017 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10018 "sata_hba_event_notify: invalid address 0x%x", | |
| 10019 *(uint32_t *)saddr)); | |
| 10020 return; | |
| 10021 } | |
| 10022 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || | |
| 10023 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { | |
| 10024 /* Invalid event for the controller */ | |
| 10025 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10026 "sata_hba_event_notify: invalid event 0x%x for " | |
| 10027 "controller", | |
| 10028 event & SATA_EVNT_CONTROLLER_EVENTS)); | |
| 10029 return; | |
| 10030 } | |
| 10031 buf1[0] = '\0'; | |
| 10032 /* This may be a frequent and not interesting event */ | |
| 10033 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 10034 "controller power level changed\n", NULL); | |
| 10035 | |
| 10036 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10037 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
|
10038 0xffffffffffffffffULL) |
| 1258 | 10039 sata_hba_inst->satahba_stats.ctrl_pwr_change++; |
| 10040 | |
| 10041 sata_hba_inst->satahba_event_flags |= | |
| 10042 SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 10043 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10044 } | |
| 10045 /* | |
| 10046 * If we got here, there is something to do with this HBA | |
| 10047 * instance. | |
| 10048 */ | |
| 10049 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10050 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 10051 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10052 mutex_enter(&sata_mutex); | |
| 10053 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ | |
| 10054 mutex_exit(&sata_mutex); | |
| 10055 | |
| 10056 /* Tickle event thread */ | |
| 10057 mutex_enter(&sata_event_mutex); | |
| 10058 if (sata_event_thread_active == 0) | |
| 10059 cv_signal(&sata_event_cv); | |
| 10060 mutex_exit(&sata_event_mutex); | |
| 10061 | |
| 10062 event_info: | |
| 10063 if (buf1[0] != '\0') { | |
| 10064 lcp = strrchr(buf1, ','); | |
| 10065 if (lcp != NULL) | |
| 10066 *lcp = '\0'; | |
| 10067 } | |
| 10068 if (saddr->qual == SATA_ADDR_CPORT || | |
| 10069 saddr->qual == SATA_ADDR_DCPORT) { | |
| 10070 if (buf1[0] != '\0') { | |
| 10071 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", | |
| 10072 cport, buf1); | |
| 10073 } | |
| 10074 if (buf2[0] != '\0') { | |
| 10075 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", | |
| 10076 cport, buf2); | |
| 10077 } | |
| 10078 } else if (saddr->qual == SATA_ADDR_PMPORT || | |
| 10079 saddr->qual == SATA_ADDR_DPMPORT) { | |
| 10080 if (buf1[0] != '\0') { | |
| 10081 sata_log(sata_hba_inst, CE_NOTE, | |
| 10082 "port %d pmport %d: %s\n", cport, pmport, buf1); | |
| 10083 } | |
| 10084 if (buf2[0] != '\0') { | |
| 10085 sata_log(sata_hba_inst, CE_NOTE, | |
| 10086 "port %d pmport %d: %s\n", cport, pmport, buf2); | |
| 10087 } | |
| 10088 } | |
| 10089 } | |
| 10090 | |
| 10091 | |
| 10092 /* | |
| 10093 * Event processing thread. | |
| 10094 * Arg is a pointer to the sata_hba_list pointer. | |
| 10095 * It is not really needed, because sata_hba_list is global and static | |
| 10096 */ | |
| 10097 static void | |
| 10098 sata_event_daemon(void *arg) | |
| 10099 { | |
| 10100 #ifndef __lock_lint | |
| 10101 _NOTE(ARGUNUSED(arg)) | |
| 10102 #endif | |
| 10103 sata_hba_inst_t *sata_hba_inst; | |
| 10104 clock_t lbolt; | |
| 10105 | |
| 10106 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 10107 "SATA event daemon started\n", NULL); | |
| 10108 loop: | |
| 10109 /* | |
| 10110 * Process events here. Walk through all registered HBAs | |
| 10111 */ | |
| 10112 mutex_enter(&sata_mutex); | |
| 10113 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 10114 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 10115 ASSERT(sata_hba_inst != NULL); | |
| 10116 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10117 if (sata_hba_inst->satahba_attached != 1 || | |
| 10118 (sata_hba_inst->satahba_event_flags & | |
| 10119 SATA_EVNT_SKIP) != 0) { | |
| 10120 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10121 continue; | |
| 10122 } | |
| 10123 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { | |
| 10124 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; | |
| 10125 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10126 mutex_exit(&sata_mutex); | |
| 10127 /* Got the controller with pending event */ | |
| 10128 sata_process_controller_events(sata_hba_inst); | |
| 10129 /* | |
| 10130 * Since global mutex was released, there is a | |
| 10131 * possibility that HBA list has changed, so start | |
| 10132 * over from the top. Just processed controller | |
| 10133 * will be passed-over because of the SKIP flag. | |
| 10134 */ | |
| 10135 goto loop; | |
| 10136 } | |
| 10137 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10138 } | |
| 10139 /* Clear SKIP flag in all controllers */ | |
| 10140 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 10141 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 10142 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10143 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; | |
| 10144 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10145 } | |
| 10146 mutex_exit(&sata_mutex); | |
| 10147 | |
| 10148 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 10149 "SATA EVENT DAEMON suspending itself", NULL); | |
| 10150 | |
| 10151 #ifdef SATA_DEBUG | |
| 10152 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { | |
| 10153 sata_log(sata_hba_inst, CE_WARN, | |
| 10154 "SATA EVENTS PROCESSING DISABLED\n"); | |
| 10155 thread_exit(); /* Daemon will not run again */ | |
| 10156 } | |
| 10157 #endif | |
| 10158 mutex_enter(&sata_event_mutex); | |
| 10159 sata_event_thread_active = 0; | |
| 10160 mutex_exit(&sata_event_mutex); | |
| 10161 /* | |
| 10162 * Go to sleep/suspend itself and wake up either because new event or | |
| 10163 * wait timeout. Exit if there is a termination request (driver | |
| 10164 * unload). | |
| 10165 */ | |
| 10166 do { | |
| 10167 lbolt = ddi_get_lbolt(); | |
| 10168 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); | |
| 10169 mutex_enter(&sata_event_mutex); | |
| 10170 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt); | |
| 10171 | |
| 10172 if (sata_event_thread_active != 0) { | |
| 10173 mutex_exit(&sata_event_mutex); | |
| 10174 continue; | |
| 10175 } | |
| 10176 | |
| 10177 /* Check if it is time to go away */ | |
| 10178 if (sata_event_thread_terminate == 1) { | |
| 10179 /* | |
| 10180 * It is up to the thread setting above flag to make | |
| 10181 * sure that this thread is not killed prematurely. | |
| 10182 */ | |
| 10183 sata_event_thread_terminate = 0; | |
| 10184 sata_event_thread = NULL; | |
| 10185 mutex_exit(&sata_event_mutex); | |
| 10186 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 10187 "SATA_EVENT_DAEMON_TERMINATING", NULL); | |
| 10188 thread_exit(); { _NOTE(NOT_REACHED) } | |
| 10189 } | |
| 10190 mutex_exit(&sata_event_mutex); | |
| 10191 } while (!(sata_event_pending & SATA_EVNT_MAIN)); | |
| 10192 | |
| 10193 mutex_enter(&sata_event_mutex); | |
| 10194 sata_event_thread_active = 1; | |
| 10195 mutex_exit(&sata_event_mutex); | |
| 10196 | |
| 10197 mutex_enter(&sata_mutex); | |
| 10198 sata_event_pending &= ~SATA_EVNT_MAIN; | |
| 10199 mutex_exit(&sata_mutex); | |
| 10200 | |
| 10201 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 10202 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); | |
| 10203 | |
| 10204 goto loop; | |
| 10205 } | |
| 10206 | |
| 10207 /* | |
| 10208 * Specific HBA instance event processing. | |
| 10209 * | |
| 10210 * NOTE: At the moment, device event processing is limited to hard disks | |
| 10211 * only. | |
| 10212 * cports only are supported - no pmports. | |
| 10213 */ | |
| 10214 static void | |
| 10215 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) | |
| 10216 { | |
| 10217 int ncport; | |
| 10218 uint32_t event_flags; | |
| 10219 sata_address_t *saddr; | |
| 10220 | |
| 10221 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, | |
| 10222 "Processing controller %d event(s)", | |
| 10223 ddi_get_instance(SATA_DIP(sata_hba_inst))); | |
| 10224 | |
| 10225 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10226 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; | |
| 10227 event_flags = sata_hba_inst->satahba_event_flags; | |
| 10228 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10229 /* | |
| 10230 * Process controller power change first | |
| 10231 * HERE | |
| 10232 */ | |
| 10233 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) | |
| 10234 sata_process_cntrl_pwr_level_change(sata_hba_inst); | |
| 10235 | |
| 10236 /* | |
| 10237 * Search through ports/devices to identify affected port/device. | |
| 10238 * We may have to process events for more than one port/device. | |
| 10239 */ | |
| 10240 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 10241 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10242 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 10243 cport_event_flags; | |
| 10244 /* Check if port was locked by IOCTL processing */ | |
| 10245 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { | |
| 10246 /* | |
| 10247 * We ignore port events because port is busy | |
| 10248 * with AP control processing. Set again | |
| 10249 * controller and main event flag, so that | |
| 10250 * events may be processed by the next daemon | |
| 10251 * run. | |
| 10252 */ | |
| 10253 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10254 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10255 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 10256 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10257 mutex_enter(&sata_mutex); | |
| 10258 sata_event_pending |= SATA_EVNT_MAIN; | |
| 10259 mutex_exit(&sata_mutex); | |
| 10260 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, | |
| 10261 "Event processing postponed until " | |
| 10262 "AP control processing completes", | |
| 10263 NULL); | |
| 10264 /* Check other ports */ | |
| 10265 continue; | |
| 10266 } else { | |
| 10267 /* | |
| 10268 * Set BSY flag so that AP control would not | |
| 10269 * interfere with events processing for | |
| 10270 * this port. | |
| 10271 */ | |
| 10272 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 10273 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; | |
| 10274 } | |
| 10275 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10276 | |
| 10277 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; | |
| 10278 | |
| 10279 if ((event_flags & | |
| 10280 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { | |
| 10281 /* | |
| 10282 * Got port event. | |
| 10283 * We need some hierarchy of event processing as they | |
| 10284 * are affecting each other: | |
| 10285 * 1. port failed | |
| 10286 * 2. device detached/attached | |
| 10287 * 3. link events - link events may trigger device | |
| 10288 * detached or device attached events in some | |
| 10289 * circumstances. | |
| 10290 * 4. port power level changed | |
| 10291 */ | |
| 10292 if (event_flags & SATA_EVNT_PORT_FAILED) { | |
| 10293 sata_process_port_failed_event(sata_hba_inst, | |
| 10294 saddr); | |
| 10295 } | |
| 10296 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { | |
| 10297 sata_process_device_detached(sata_hba_inst, | |
| 10298 saddr); | |
| 10299 } | |
| 10300 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { | |
| 10301 sata_process_device_attached(sata_hba_inst, | |
| 10302 saddr); | |
| 10303 } | |
| 10304 if (event_flags & | |
| 10305 (SATA_EVNT_LINK_ESTABLISHED | | |
| 10306 SATA_EVNT_LINK_LOST)) { | |
| 10307 sata_process_port_link_events(sata_hba_inst, | |
| 10308 saddr); | |
| 10309 } | |
| 10310 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { | |
| 10311 sata_process_port_pwr_change(sata_hba_inst, | |
| 10312 saddr); | |
| 10313 } | |
| 10314 } | |
| 10315 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != | |
| 10316 SATA_DTYPE_NONE) { | |
| 10317 /* May have device event */ | |
| 10318 sata_process_device_reset(sata_hba_inst, saddr); | |
| 10319 } | |
| 10320 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10321 /* Release PORT_BUSY flag */ | |
| 10322 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 10323 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; | |
| 10324 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10325 | |
| 10326 } /* End of loop through the controller SATA ports */ | |
| 10327 } | |
| 10328 | |
| 10329 /* | |
| 10330 * Process HBA power level change reported by HBA driver. | |
| 10331 * Not implemented at this time - event is ignored. | |
| 10332 */ | |
| 10333 static void | |
| 10334 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) | |
| 10335 { | |
| 10336 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10337 "Processing controller power level change", NULL); | |
| 10338 | |
| 10339 /* Ignoring it for now */ | |
| 10340 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10341 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 10342 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10343 } | |
| 10344 | |
| 10345 /* | |
| 10346 * Process port power level change reported by HBA driver. | |
| 10347 * Not implemented at this time - event is ignored. | |
| 10348 */ | |
| 10349 static void | |
| 10350 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, | |
| 10351 sata_address_t *saddr) | |
| 10352 { | |
| 10353 sata_cport_info_t *cportinfo; | |
| 10354 | |
| 10355 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10356 "Processing port power level change", NULL); | |
| 10357 | |
| 10358 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10359 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10360 /* Reset event flag */ | |
| 10361 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 10362 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10363 } | |
| 10364 | |
| 10365 /* | |
| 10366 * Process port failure reported by HBA driver. | |
| 10367 * cports support only - no pmports. | |
| 10368 */ | |
| 10369 static void | |
| 10370 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, | |
| 10371 sata_address_t *saddr) | |
| 10372 { | |
| 10373 sata_cport_info_t *cportinfo; | |
| 10374 | |
| 10375 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10376 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10377 /* Reset event flag first */ | |
| 10378 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; | |
| 10379 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ | |
| 10380 if ((cportinfo->cport_state & | |
| 10381 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { | |
| 10382 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10383 cport_mutex); | |
| 10384 return; | |
| 10385 } | |
| 10386 /* Fail the port */ | |
| 10387 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10388 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10389 sata_log(sata_hba_inst, CE_WARN, "port %d failed", saddr->cport); | |
| 10390 } | |
| 10391 | |
| 10392 /* | |
| 10393 * Device Reset Event processing. | |
| 10394 * The seqeunce is managed by 3 stage flags: | |
| 10395 * - reset event reported, | |
| 10396 * - reset event being processed, | |
| 10397 * - request to clear device reset state. | |
| 10398 */ | |
| 10399 static void | |
| 10400 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, | |
| 10401 sata_address_t *saddr) | |
| 10402 { | |
| 10403 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ | |
| 10404 sata_drive_info_t *sdinfo; | |
| 10405 sata_cport_info_t *cportinfo; | |
| 10406 sata_device_t sata_device; | |
| 10407 int rval; | |
| 10408 | |
| 10409 /* We only care about host sata cport for now */ | |
| 10410 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10411 | |
| 10412 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10413 | |
| 10414 /* If the port is in SHUTDOWN or FAILED state, ignore reset event. */ | |
| 10415 if ((cportinfo->cport_state & | |
| 10416 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10417 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10418 cport_mutex); | |
| 10419 return; | |
| 10420 } | |
| 10421 | |
| 10422 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & | |
| 10423 SATA_VALID_DEV_TYPE) == 0) { | |
| 10424 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10425 cport_mutex); | |
| 10426 return; | |
| 10427 } | |
| 10428 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); | |
| 10429 if (sdinfo == NULL) { | |
| 10430 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10431 cport_mutex); | |
| 10432 return; | |
| 10433 } | |
| 10434 | |
| 10435 if ((sdinfo->satadrv_event_flags & SATA_EVNT_DEVICE_RESET) == 0) { | |
| 10436 /* Nothing to do */ | |
| 10437 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10438 cport_mutex); | |
| 10439 return; | |
| 10440 } | |
| 10441 | |
| 10442 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10443 "Processing port %d device reset", saddr->cport); | |
| 10444 | |
| 10445 if (sdinfo->satadrv_event_flags & SATA_EVNT_INPROC_DEVICE_RESET) { | |
| 10446 /* Something is weird - new device reset event */ | |
| 10447 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10448 "Overlapping device reset events!", NULL); | |
| 10449 /* Just leave */ | |
| 10450 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10451 cport_mutex); | |
| 10452 return; | |
| 10453 } | |
| 10454 | |
| 10455 /* Clear event flag */ | |
| 10456 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; | |
| 10457 | |
| 10458 /* It seems that we always need to check the port state first */ | |
| 10459 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10460 sata_device.satadev_addr = *saddr; | |
| 10461 /* | |
| 10462 * We have to exit mutex, because the HBA probe port function may | |
| 10463 * block on its own mutex. | |
| 10464 */ | |
| 10465 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10466 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10467 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10468 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10469 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 10470 if (rval != SATA_SUCCESS) { | |
| 10471 /* Something went wrong? Fail the port */ | |
| 10472 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10473 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10474 cport_mutex); | |
| 10475 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed", | |
| 10476 saddr->cport)); | |
| 10477 return; | |
| 10478 } | |
| 10479 if ((sata_device.satadev_scr.sstatus & | |
| 10480 SATA_PORT_DEVLINK_UP_MASK) != | |
| 10481 SATA_PORT_DEVLINK_UP || | |
| 10482 sata_device.satadev_type == SATA_DTYPE_NONE) { | |
| 10483 /* | |
| 10484 * No device to process, anymore. Some other event processing | |
| 10485 * would or have already performed port info cleanup. | |
| 10486 * To be safe (HBA may need it), request clearing device | |
| 10487 * reset condition. | |
| 10488 */ | |
| 10489 sdinfo->satadrv_event_flags = 0; | |
| 10490 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 10491 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10492 cport_mutex); | |
| 10493 return; | |
| 10494 } | |
| 10495 | |
| 10496 /* Mark device reset processing as active */ | |
| 10497 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; | |
| 10498 | |
| 10499 old_sdinfo = *sdinfo; /* local copy of the drive info */ | |
| 10500 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10501 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10502 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == |
| 1258 | 10503 SATA_FAILURE) { |
| 10504 /* | |
| 10505 * Restoring drive setting failed. | |
| 10506 * Probe the port first, to check if the port state has changed | |
| 10507 */ | |
| 10508 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10509 sata_device.satadev_addr = *saddr; | |
| 10510 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 10511 /* probe port */ | |
| 10512 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10513 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10514 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10515 cport_mutex); | |
| 10516 if (rval == SATA_SUCCESS && | |
| 10517 (sata_device.satadev_state & | |
| 10518 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && | |
| 10519 (sata_device.satadev_scr.sstatus & | |
| 10520 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && | |
| 10521 (sata_device.satadev_type & SATA_DTYPE_ATADISK) != 0) { | |
| 10522 /* | |
| 10523 * We may retry this a bit later - reinstate reset | |
| 10524 * condition | |
| 10525 */ | |
| 10526 if ((cportinfo->cport_dev_type & | |
| 10527 SATA_VALID_DEV_TYPE) != 0 && | |
| 10528 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10529 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10530 sdinfo->satadrv_event_flags |= | |
| 10531 SATA_EVNT_DEVICE_RESET; | |
| 10532 sdinfo->satadrv_event_flags &= | |
| 10533 ~SATA_EVNT_INPROC_DEVICE_RESET; | |
| 10534 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 10535 saddr->cport)->cport_mutex); | |
| 10536 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10537 sata_hba_inst->satahba_event_flags |= | |
| 10538 SATA_EVNT_MAIN; | |
| 10539 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10540 return; | |
| 10541 } | |
| 10542 } else { | |
| 10543 /* | |
| 10544 * No point of retrying - some other event processing | |
| 10545 * would or already did port info cleanup. | |
| 10546 * To be safe (HBA may need it), | |
| 10547 * request clearing device reset condition. | |
| 10548 */ | |
| 10549 sdinfo->satadrv_event_flags = 0; | |
| 10550 sdinfo->satadrv_event_flags |= | |
| 10551 SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 10552 } | |
| 10553 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10554 cport_mutex); | |
| 10555 return; | |
| 10556 } | |
| 10557 | |
| 10558 /* | |
| 10559 * Raise the flag indicating that the next sata command could | |
| 10560 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device | |
| 10561 * reset is reported. | |
| 10562 */ | |
| 10563 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10564 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 && | |
| 10565 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10566 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10567 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; | |
| 10568 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 10569 } | |
| 10570 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10571 } | |
| 10572 | |
| 10573 | |
| 10574 /* | |
| 10575 * Port Link Events processing. | |
| 10576 * Every link established event may involve device reset (due to | |
| 10577 * COMRESET signal, equivalent of the hard reset) so arbitrarily | |
| 10578 * set device reset event for an attached device (if any). | |
| 10579 * If the port is in SHUTDOWN or FAILED state, ignore link events. | |
| 10580 * | |
| 10581 * The link established event processing varies, depending on the state | |
| 10582 * of the target node, HBA hotplugging capabilities, state of the port. | |
| 10583 * If the link is not active, the link established event is ignored. | |
| 10584 * If HBA cannot detect device attachment and there is no target node, | |
| 10585 * the link established event triggers device attach event processing. | |
| 10586 * Else, link established event triggers device reset event processing. | |
| 10587 * | |
| 10588 * The link lost event processing varies, depending on a HBA hotplugging | |
| 10589 * capability and the state of the port (link active or not active). | |
| 10590 * If the link is active, the lost link event is ignored. | |
| 10591 * If HBA cannot detect device removal, the lost link event triggers | |
| 10592 * device detached event processing after link lost timeout. | |
| 10593 * Else, the event is ignored. | |
| 10594 * | |
| 10595 * NOTE: Only cports are processed for now, i.e. no port multiplier ports | |
| 10596 */ | |
| 10597 static void | |
| 10598 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, | |
| 10599 sata_address_t *saddr) | |
| 10600 { | |
| 10601 sata_device_t sata_device; | |
| 10602 sata_cport_info_t *cportinfo; | |
| 10603 sata_drive_info_t *sdinfo; | |
| 10604 int event_flags; | |
| 10605 int rval; | |
| 10606 | |
| 10607 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10608 "Processing port %d link event(s)", saddr->cport); | |
| 10609 | |
| 10610 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10611 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10612 event_flags = cportinfo->cport_event_flags; | |
| 10613 | |
| 10614 /* Reset event flags first */ | |
| 10615 cportinfo->cport_event_flags &= | |
| 10616 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); | |
| 10617 | |
| 10618 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ | |
| 10619 if ((cportinfo->cport_state & | |
| 10620 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10621 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10622 cport_mutex); | |
| 10623 return; | |
| 10624 } | |
| 10625 | |
| 10626 /* | |
| 10627 * For the sanity sake get current port state. | |
| 10628 * Set device address only. Other sata_device fields should be | |
| 10629 * set by HBA driver. | |
| 10630 */ | |
| 10631 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10632 sata_device.satadev_addr = *saddr; | |
| 10633 /* | |
| 10634 * We have to exit mutex, because the HBA probe port function may | |
| 10635 * block on its own mutex. | |
| 10636 */ | |
| 10637 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10638 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10639 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10640 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10641 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 10642 if (rval != SATA_SUCCESS) { | |
| 10643 /* Something went wrong? Fail the port */ | |
| 10644 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10645 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10646 cport_mutex); | |
| 10647 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed", | |
| 10648 saddr->cport)); | |
| 10649 /* | |
| 10650 * We may want to release device info structure, but | |
| 10651 * it is not necessary. | |
| 10652 */ | |
| 10653 return; | |
| 10654 } else { | |
| 10655 /* port probed successfully */ | |
| 10656 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; | |
| 10657 } | |
| 10658 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { | |
| 10659 | |
| 10660 if ((sata_device.satadev_scr.sstatus & | |
| 10661 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { | |
| 10662 /* Ignore event */ | |
| 10663 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10664 "Ignoring port %d link established event - " | |
| 10665 "link down", | |
| 10666 saddr->cport); | |
| 10667 goto linklost; | |
| 10668 } | |
| 10669 | |
| 10670 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10671 "Processing port %d link established event", | |
| 10672 saddr->cport); | |
| 10673 | |
| 10674 /* | |
| 10675 * For the sanity sake check if a device is attached - check | |
| 10676 * return state of a port probing. | |
| 10677 */ | |
| 10678 if (sata_device.satadev_type != SATA_DTYPE_NONE && | |
| 10679 sata_device.satadev_type != SATA_DTYPE_PMULT) { | |
| 10680 /* | |
| 10681 * HBA port probe indicated that there is a device | |
| 10682 * attached. Check if the framework had device info | |
| 10683 * structure attached for this device. | |
| 10684 */ | |
| 10685 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 10686 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != | |
| 10687 NULL); | |
| 10688 | |
| 10689 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10690 if ((sdinfo->satadrv_type & | |
| 10691 SATA_VALID_DEV_TYPE) != 0) { | |
| 10692 /* | |
| 10693 * Dev info structure is present. | |
| 10694 * If dev_type is set to known type in | |
| 10695 * the framework's drive info struct | |
| 10696 * then the device existed before and | |
| 10697 * the link was probably lost | |
| 10698 * momentarily - in such case | |
| 10699 * we may want to check device | |
| 10700 * identity. | |
| 10701 * Identity check is not supported now. | |
| 10702 * | |
| 10703 * Link established event | |
| 10704 * triggers device reset event. | |
| 10705 */ | |
| 10706 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 10707 satadrv_event_flags |= | |
| 10708 SATA_EVNT_DEVICE_RESET; | |
| 10709 } | |
| 10710 } else if (cportinfo->cport_dev_type == | |
| 10711 SATA_DTYPE_NONE) { | |
| 10712 /* | |
| 10713 * We got new device attached! If HBA does not | |
| 10714 * generate device attached events, trigger it | |
| 10715 * here. | |
| 10716 */ | |
| 10717 if (!(SATA_FEATURES(sata_hba_inst) & | |
| 10718 SATA_CTLF_HOTPLUG)) { | |
| 10719 cportinfo->cport_event_flags |= | |
| 10720 SATA_EVNT_DEVICE_ATTACHED; | |
| 10721 } | |
| 10722 } | |
| 10723 /* Reset link lost timeout */ | |
| 10724 cportinfo->cport_link_lost_time = 0; | |
| 10725 } | |
| 10726 } | |
| 10727 linklost: | |
| 10728 if (event_flags & SATA_EVNT_LINK_LOST) { | |
| 10729 if ((sata_device.satadev_scr.sstatus & | |
| 10730 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { | |
| 10731 /* Ignore event */ | |
| 10732 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10733 "Ignoring port %d link lost event - link is up", | |
| 10734 saddr->cport); | |
| 10735 goto done; | |
| 10736 } | |
| 10737 #ifdef SATA_DEBUG | |
| 10738 if (cportinfo->cport_link_lost_time == 0) { | |
| 10739 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10740 "Processing port %d link lost event", | |
| 10741 saddr->cport); | |
| 10742 } | |
| 10743 #endif | |
| 10744 /* | |
| 10745 * When HBA cannot generate device attached/detached events, | |
| 10746 * we need to track link lost time and eventually generate | |
| 10747 * device detach event. | |
| 10748 */ | |
| 10749 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { | |
| 10750 /* We are tracking link lost time */ | |
| 10751 if (cportinfo->cport_link_lost_time == 0) { | |
| 10752 /* save current time (lbolt value) */ | |
| 10753 cportinfo->cport_link_lost_time = | |
| 10754 ddi_get_lbolt(); | |
| 10755 /* just keep link lost event */ | |
| 10756 cportinfo->cport_event_flags |= | |
| 10757 SATA_EVNT_LINK_LOST; | |
| 10758 } else { | |
| 10759 clock_t cur_time = ddi_get_lbolt(); | |
| 10760 if ((cur_time - | |
| 10761 cportinfo->cport_link_lost_time) >= | |
| 10762 drv_usectohz( | |
| 10763 SATA_EVNT_LINK_LOST_TIMEOUT)) { | |
| 10764 /* trigger device detach event */ | |
| 10765 cportinfo->cport_event_flags |= | |
| 10766 SATA_EVNT_DEVICE_DETACHED; | |
| 10767 cportinfo->cport_link_lost_time = 0; | |
| 10768 SATADBG1(SATA_DBG_EVENTS, | |
| 10769 sata_hba_inst, | |
| 10770 "Triggering port %d " | |
| 10771 "device detached event", | |
| 10772 saddr->cport); | |
| 10773 } else { | |
| 10774 /* keep link lost event */ | |
| 10775 cportinfo->cport_event_flags |= | |
| 10776 SATA_EVNT_LINK_LOST; | |
| 10777 } | |
| 10778 } | |
| 10779 } | |
| 10780 /* | |
| 10781 * We could change port state to disable/delay access to | |
| 10782 * the attached device until the link is recovered. | |
| 10783 */ | |
| 10784 } | |
| 10785 done: | |
| 10786 event_flags = cportinfo->cport_event_flags; | |
| 10787 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10788 if (event_flags != 0) { | |
| 10789 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10790 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 10791 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10792 mutex_enter(&sata_mutex); | |
| 10793 sata_event_pending |= SATA_EVNT_MAIN; | |
| 10794 mutex_exit(&sata_mutex); | |
| 10795 } | |
| 10796 } | |
| 10797 | |
| 10798 /* | |
| 10799 * Device Detached Event processing. | |
| 10800 * Port is probed to find if a device is really gone. If so, | |
| 10801 * the device info structure is detached from the SATA port info structure | |
| 10802 * and released. | |
| 10803 * Port status is updated. | |
| 10804 * | |
| 10805 * NOTE: Process cports event only, no port multiplier ports. | |
| 10806 */ | |
| 10807 static void | |
| 10808 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, | |
| 10809 sata_address_t *saddr) | |
| 10810 { | |
| 10811 sata_cport_info_t *cportinfo; | |
| 10812 sata_drive_info_t *sdevinfo; | |
| 10813 sata_device_t sata_device; | |
| 10814 dev_info_t *tdip; | |
| 10815 int rval; | |
| 10816 | |
| 10817 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10818 "Processing port %d device detached", saddr->cport); | |
| 10819 | |
| 10820 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10821 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10822 /* Clear event flag */ | |
| 10823 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; | |
| 10824 | |
| 10825 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ | |
| 10826 if ((cportinfo->cport_state & | |
| 10827 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10828 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10829 cport_mutex); | |
| 10830 return; | |
| 10831 } | |
| 10832 /* For sanity, re-probe the port */ | |
| 10833 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10834 sata_device.satadev_addr = *saddr; | |
| 10835 | |
| 10836 /* | |
| 10837 * We have to exit mutex, because the HBA probe port function may | |
| 10838 * block on its own mutex. | |
| 10839 */ | |
| 10840 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10841 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10842 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10843 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10844 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 10845 if (rval != SATA_SUCCESS) { | |
| 10846 /* Something went wrong? Fail the port */ | |
| 10847 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10848 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10849 cport_mutex); | |
| 10850 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed", | |
| 10851 saddr->cport)); | |
| 10852 /* | |
| 10853 * We may want to release device info structure, but | |
| 10854 * it is not necessary. | |
| 10855 */ | |
| 10856 return; | |
| 10857 } else { | |
| 10858 /* port probed successfully */ | |
| 10859 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; | |
| 10860 } | |
| 10861 /* | |
| 10862 * Check if a device is still attached. For sanity, check also | |
| 10863 * link status - if no link, there is no device. | |
| 10864 */ | |
| 10865 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == | |
| 10866 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != | |
| 10867 SATA_DTYPE_NONE) { | |
| 10868 /* | |
| 10869 * Device is still attached - ignore detach event. | |
| 10870 */ | |
| 10871 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10872 cport_mutex); | |
| 10873 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10874 "Ignoring detach - device still attached to port %d", | |
| 10875 sata_device.satadev_addr.cport); | |
| 10876 return; | |
| 10877 } | |
| 10878 /* | |
| 10879 * We need to detach and release device info structure here | |
| 10880 */ | |
| 10881 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10882 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10883 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 10884 (void) kmem_free((void *)sdevinfo, | |
| 10885 sizeof (sata_drive_info_t)); | |
| 10886 } | |
| 10887 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 10888 /* | |
| 10889 * Device cannot be reached anymore, even if the target node may be | |
| 10890 * still present. | |
| 10891 */ | |
| 10892 | |
| 10893 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10894 sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d", | |
| 10895 sata_device.satadev_addr.cport); | |
| 10896 | |
| 10897 /* | |
| 10898 * Try to offline a device and remove target node if it still exists | |
| 10899 */ | |
| 10900 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); | |
| 10901 if (tdip != NULL) { | |
| 10902 /* | |
| 10903 * target node exist - unconfigure device first, then remove | |
| 10904 * the node | |
| 10905 */ | |
| 10906 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { | |
| 10907 /* | |
| 10908 * PROBLEM - no device, but target node remained | |
| 10909 * This happens when the file was open or node was | |
| 10910 * waiting for resources. | |
| 10911 */ | |
| 10912 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10913 "sata_process_device_detached: " | |
| 10914 "Failed to unconfigure removed device.")); | |
| 10915 } | |
| 10916 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { | |
| 10917 /* | |
| 10918 * PROBLEM - no device, but target node remained | |
| 10919 * This happens when the file was open or node was | |
| 10920 * waiting for resources. | |
| 10921 */ | |
| 10922 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10923 "sata_process_device_detached: " | |
| 10924 "Failed to remove target node for " | |
| 10925 "removed device.")); | |
| 10926 } | |
| 10927 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10928 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10929 * 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
|
10930 * with the hint: SE_HINT_REMOVE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10931 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10932 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); |
| 1258 | 10933 } |
| 10934 | |
| 10935 | |
| 10936 /* | |
| 10937 * Device Attached Event processing. | |
| 10938 * Port state is checked to verify that a device is really attached. If so, | |
| 10939 * the device info structure is created and attached to the SATA port info | |
| 10940 * structure. | |
| 10941 * | |
| 10942 * This function cannot be called in interrupt context (it may sleep). | |
| 10943 * | |
| 10944 * NOTE: Process cports event only, no port multiplier ports. | |
| 10945 */ | |
| 10946 static void | |
| 10947 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, | |
| 10948 sata_address_t *saddr) | |
| 10949 { | |
| 10950 sata_cport_info_t *cportinfo; | |
| 10951 sata_drive_info_t *sdevinfo; | |
| 10952 sata_device_t sata_device; | |
| 10953 dev_info_t *tdip; | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10954 int rval; |
| 1258 | 10955 |
| 10956 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10957 "Processing port %d device attached", saddr->cport); | |
| 10958 | |
| 10959 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10960 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10961 | |
| 10962 /* Clear event flag first */ | |
| 10963 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; | |
| 10964 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ | |
| 10965 if ((cportinfo->cport_state & | |
| 10966 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10967 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10968 cport_mutex); | |
| 10969 return; | |
| 10970 } | |
| 10971 | |
| 10972 /* | |
| 10973 * If the sata_drive_info structure is found attached to the port info, | |
| 10974 * something went wrong in the event reporting and processing sequence. | |
| 10975 * To recover, arbitrarily release device info structure and issue | |
| 10976 * a warning. | |
| 10977 */ | |
| 10978 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10979 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10980 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 10981 (void) kmem_free((void *)sdevinfo, | |
| 10982 sizeof (sata_drive_info_t)); | |
| 10983 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10984 "Arbitrarily detaching old device info.")); | |
| 10985 } | |
| 10986 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
|
10987 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10988 /* For sanity, re-probe the port */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10989 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
|
10990 sata_device.satadev_addr = *saddr; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10991 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10992 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10993 * 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
|
10994 * block on its own mutex. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10995 */ |
| 1258 | 10996 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
|
10997 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
|
10998 (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
|
10999 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
|
11000 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
|
11001 if (rval != SATA_SUCCESS) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11002 /* Something went wrong? Fail the port */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11003 cportinfo->cport_state = SATA_PSTATE_FAILED; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11004 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
|
11005 cport_mutex); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11006 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed", |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11007 saddr->cport)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11008 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11009 } else { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11010 /* port probed successfully */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11011 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
|
11012 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11013 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11014 * 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
|
11015 * 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
|
11016 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11017 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
|
11018 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
|
11019 SATA_DTYPE_NONE) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11020 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11021 * No device - ignore attach event. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11022 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11023 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
|
11024 cport_mutex); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11025 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
|
11026 "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
|
11027 sata_device.satadev_addr.cport); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11028 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11029 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11030 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11031 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
|
11032 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11033 * 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
|
11034 * with the hint: SE_HINT_INSERT |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11035 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11036 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
|
11037 |
| 1258 | 11038 /* |
| 11039 * Make sure that there is no target node for that device. | |
| 11040 * If so, release it. It should not happen, unless we had problem | |
| 11041 * removing the node when device was detached. | |
| 11042 */ | |
| 11043 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); | |
| 11044 if (tdip != NULL) { | |
| 11045 | |
| 11046 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 11047 "sata_process_device_attached: " | |
| 11048 "old device target node exists!!!")); | |
| 11049 /* | |
| 11050 * target node exist - unconfigure device first, then remove | |
| 11051 * the node | |
| 11052 */ | |
| 11053 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { | |
| 11054 /* | |
| 11055 * PROBLEM - no device, but target node remained | |
| 11056 * This happens when the file was open or node was | |
| 11057 * waiting for resources. | |
| 11058 */ | |
| 11059 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 11060 "sata_process_device_attached: " | |
| 11061 "Failed to unconfigure old target node!")); | |
| 11062 } | |
| 11063 /* Following call will retry node offlining and removing it */ | |
| 11064 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { | |
| 11065 /* PROBLEM - no device, but target node remained */ | |
| 11066 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 11067 "sata_process_device_attached: " | |
| 11068 "Failed to remove old target node!")); | |
| 11069 /* | |
| 11070 * It is not clear, what should be done here. | |
| 11071 * For now, we will not attach a new device | |
| 11072 */ | |
| 11073 return; | |
| 11074 } | |
| 11075 } | |
| 11076 | |
| 11077 /* | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11078 * Reprobing port will take care of the creation of the device info |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11079 * structure and determination of the device type. |
| 1258 | 11080 */ |
| 11081 sata_device.satadev_addr = *saddr; | |
| 11082 (void) sata_reprobe_port(sata_hba_inst, &sata_device); | |
| 11083 /* | |
| 11084 * If device was successfully attached, an explicit | |
| 11085 * 'configure' command is needed to configure it. | |
| 11086 */ | |
| 11087 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11088 if ((cportinfo->cport_state & SATA_STATE_READY) && | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11089 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11090 sata_log(sata_hba_inst, CE_WARN, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11091 "SATA device attached at port %d", saddr->cport); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11092 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11093 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11094 sata_drive_info_t new_sdinfo; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11095 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11096 /* Log device info data */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11097 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(cportinfo)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11098 sata_show_drive_info(sata_hba_inst, &new_sdinfo); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11099 } |
| 1258 | 11100 } |
| 11101 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 11102 } | |
| 11103 | |
| 11104 | |
| 11105 /* | |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
11106 * 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
|
11107 * 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
|
11108 * it restores device features setting to the previously saved state. |
| 1258 | 11109 * Device Identify data has to be current. |
| 11110 * At the moment only read ahead and write cache settings are considered. | |
| 11111 * | |
| 11112 * This function cannot be called in the interrupt context (it may sleep). | |
| 11113 * | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11114 * 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
|
11115 * to be updated after features are set. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11116 * |
| 1258 | 11117 * 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
|
11118 * Returns FALSE if device features could not be set . |
| 1258 | 11119 * |
| 11120 * Note: This function may fail the port, making it inaccessible. | |
| 11121 * Explicit port disconnect/connect or physical device | |
| 11122 * detach/attach is required to re-evaluate it's state afterwards | |
| 11123 */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11124 |
| 1258 | 11125 static int |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11126 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
|
11127 sata_drive_info_t *sdinfo, int restore) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11128 { |
| 1258 | 11129 int rval = SATA_SUCCESS; |
| 11130 sata_drive_info_t new_sdinfo; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11131 char *finfo = "sata_set_drive_features: cannot"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11132 char *finfox; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11133 int cache_op; |
| 1258 | 11134 |
| 11135 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); | |
| 11136 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; | |
| 11137 new_sdinfo.satadrv_type = sdinfo->satadrv_type; | |
| 11138 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { | |
| 11139 /* | |
| 11140 * Cannot get device identification - retry later | |
| 11141 */ | |
| 11142 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
|
11143 "%s fetch device identify data\n", finfo)); |
| 1258 | 11144 return (SATA_FAILURE); |
| 11145 } | |
| 11146 /* Arbitrarily set UDMA mode */ | |
| 11147 if (sata_set_udma_mode(sata_hba_inst, &new_sdinfo) != SATA_SUCCESS) { | |
| 11148 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
|
11149 "%s set UDMA mode\n", finfo)); |
| 1258 | 11150 return (SATA_FAILURE); |
| 11151 } | |
| 11152 | |
| 11153 if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 11154 !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 11155 /* None of the features is supported - do nothing */ | |
| 11156 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11157 "settable features not supported\n", NULL); |
| 1258 | 11158 return (SATA_SUCCESS); |
| 11159 } | |
| 11160 | |
| 11161 if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && | |
| 11162 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && | |
| 11163 ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && | |
| 11164 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { | |
| 11165 /* Nothing to do */ | |
| 11166 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11167 "no device features to set\n", NULL); |
| 1258 | 11168 return (SATA_SUCCESS); |
| 11169 } | |
| 11170 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11171 finfox = (restore != 0) ? " restore device features" : |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11172 " initialize device features\n"; |
| 1258 | 11173 |
| 11174 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && | |
| 11175 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) { | |
| 11176 if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) | |
| 11177 /* Enable read ahead / read cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11178 cache_op = SATAC_SF_ENABLE_READ_AHEAD; |
| 1258 | 11179 else |
| 11180 /* Disable read ahead / read cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11181 cache_op = SATAC_SF_DISABLE_READ_AHEAD; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11182 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11183 /* Try to set read cache mode */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11184 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
|
11185 cache_op) != SATA_SUCCESS) { |
| 1258 | 11186 /* Pkt execution failed */ |
| 11187 rval = SATA_FAILURE; | |
| 11188 } | |
| 11189 } | |
| 11190 | |
| 11191 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && | |
| 11192 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { | |
| 11193 if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) | |
| 11194 /* Enable write cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11195 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; |
| 1258 | 11196 else |
| 11197 /* Disable write cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11198 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11199 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11200 /* Try to set write cache mode */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11201 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
|
11202 cache_op) != SATA_SUCCESS) { |
| 1258 | 11203 /* Pkt execution failed */ |
| 11204 rval = SATA_FAILURE; | |
| 11205 } | |
| 11206 } | |
| 11207 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11208 if (rval == SATA_FAILURE) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11209 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
11210 "%s %s", finfo, finfox)); |
| 1258 | 11211 |
| 11212 /* | |
| 11213 * We need to fetch Device Identify data again | |
| 11214 */ | |
| 11215 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { | |
| 11216 /* | |
| 11217 * Cannot get device identification - retry later | |
| 11218 */ | |
| 11219 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
|
11220 "%s cannot re-fetch device identify data\n")); |
| 1258 | 11221 rval = SATA_FAILURE; |
| 11222 } | |
| 11223 /* Copy device sata info. */ | |
| 11224 sdinfo->satadrv_id = new_sdinfo.satadrv_id; | |
| 11225 | |
| 11226 return (rval); | |
| 11227 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11228 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11229 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11230 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11231 * |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
11232 * 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
|
11233 * unable to determine. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11234 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11235 * Cannot be called in an interrupt context. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11236 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11237 * Called by sata_build_lsense_page_2f() |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11238 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11239 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11240 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11241 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
|
11242 sata_drive_info_t *sdinfo) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11243 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11244 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11245 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11246 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11247 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11248 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11249 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
|
11250 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11251 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
|
11252 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11253 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11254 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11255 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11256 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11257 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11258 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11259 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11260 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11261 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11262 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11263 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
|
11264 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11265 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11266 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11267 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11268 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11269 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11270 scmd->satacmd_flags.sata_special_regs = B_TRUE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11271 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
|
11272 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11273 /* Set up which registers need to be returned */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11274 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
|
11275 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
|
11276 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11277 /* 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
|
11278 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11279 scmd->satacmd_sec_count_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11280 scmd->satacmd_lba_low_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11281 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
|
11282 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
|
11283 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11284 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11285 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11286 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11287 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11288 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11289 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11290 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11291 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
|
11292 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11293 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11294 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11295 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11296 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11297 * Whoops, no SMART RETURN STATUS |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11298 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11299 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11300 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11301 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11302 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11303 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11304 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11305 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11306 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11307 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11308 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11309 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11310 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11311 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
|
11312 (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
|
11313 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11314 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
|
11315 (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
|
11316 rval = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11317 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11318 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11319 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11320 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11321 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11322 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11323 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11324 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11325 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11326 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11327 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11328 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11329 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11330 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11331 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11332 * Returns 0 if succeeded, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11333 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11334 * Cannot be called in an interrupt context. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11335 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11336 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11337 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11338 sata_fetch_smart_data( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11339 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11340 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11341 struct smart_data *smart_data) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11342 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11343 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11344 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11345 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11346 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11347 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11348 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11349 ASSERT(sizeof (struct smart_data) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11350 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11351 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11352 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
|
11353 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11354 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
|
11355 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11356 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11357 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11358 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11359 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11360 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11361 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11362 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11363 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11364 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11365 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11366 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
|
11367 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11368 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11369 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11370 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11371 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11372 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11373 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
|
11374 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11375 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11376 * Allocate buffer for SMART data |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11377 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11378 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11379 sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11380 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11381 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11382 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11383 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11384 "sata_fetch_smart_data: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11385 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11386 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11387 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11388 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11389 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11390 /* 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
|
11391 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11392 scmd->satacmd_sec_count_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11393 scmd->satacmd_lba_low_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11394 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
|
11395 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
|
11396 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11397 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11398 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11399 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11400 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11401 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11402 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11403 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
|
11404 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11405 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11406 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11407 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11408 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11409 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11410 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11411 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11412 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11413 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11414 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11415 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11416 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11417 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
11418 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11419 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
|
11420 sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11421 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11422 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11423 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11424 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11425 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11426 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
|
11427 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11428 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11429 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11430 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11431 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11432 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11433 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11434 * Used by LOG SENSE page 0x10 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11435 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11436 * return 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11437 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11438 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11439 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11440 sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11441 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11442 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11443 struct smart_ext_selftest_log *ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11444 uint16_t block_num) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11445 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11446 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11447 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11448 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11449 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11450 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11451 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11452 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11453 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11454 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11455 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
|
11456 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11457 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
|
11458 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11459 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11460 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11461 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11462 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11463 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11464 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11465 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11466 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11467 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11468 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11469 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
|
11470 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11471 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11472 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11473 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11474 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11475 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11476 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
|
11477 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11478 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11479 * Allocate buffer for SMART extended self-test log |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11480 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11481 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11482 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11483 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11484 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11485 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11486 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11487 "sata_ext_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11488 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11489 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11490 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11491 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11492 /* 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
|
11493 scmd->satacmd_addr_type = ATA_ADDR_LBA48; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11494 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
|
11495 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
|
11496 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
|
11497 scmd->satacmd_lba_low_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11498 scmd->satacmd_lba_mid_lsb = block_num & 0xff; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11499 scmd->satacmd_lba_mid_msb = block_num >> 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11500 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11501 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11502 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11503 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11504 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11505 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11506 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11507 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
|
11508 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11509 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11510 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11511 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11512 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11513 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11514 * Whoops, no SMART selftest log info available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11515 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11516 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11517 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11518 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11519 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11520 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11521 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11522 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11523 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
11524 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11525 bcopy(scmd->satacmd_bp->b_un.b_addr, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11526 (uint8_t *)ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11527 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11528 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11529 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11530 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11531 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11532 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11533 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11534 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
|
11535 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11536 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11537 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11538 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11539 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11540 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11541 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11542 * Returns 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11543 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11544 * 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
|
11545 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11546 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11547 sata_smart_selftest_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11548 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11549 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11550 struct smart_selftest_log *selftest_log) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11551 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11552 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11553 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11554 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11555 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11556 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11557 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11558 ASSERT(sizeof (struct smart_selftest_log) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11559 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11560 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11561 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
|
11562 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11563 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
|
11564 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11565 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11566 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11567 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11568 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11569 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11570 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11571 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11572 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11573 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11574 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11575 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
|
11576 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11577 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11578 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11579 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11580 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11581 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11582 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
|
11583 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11584 /* |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
11585 * Allocate buffer for SMART SELFTEST LOG |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11586 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11587 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11588 sizeof (struct smart_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11589 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11590 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11591 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11592 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11593 "sata_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11594 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11595 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11596 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11597 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
11598 /* 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
|
11599 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11600 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
|
11601 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
|
11602 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
|
11603 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
|
11604 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11605 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11606 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11607 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11608 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11609 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11610 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11611 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
|
11612 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11613 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11614 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11615 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11616 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11617 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11618 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11619 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11620 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11621 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11622 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11623 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11624 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11625 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
11626 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11627 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
|
11628 sizeof (struct smart_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11629 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11630 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11631 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11632 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11633 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11634 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11635 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
|
11636 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11637 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11638 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11639 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11640 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11641 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11642 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11643 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11644 * Returns 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11645 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11646 * 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
|
11647 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11648 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11649 sata_smart_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11650 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11651 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11652 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
|
11653 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
|
11654 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
|
11655 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11656 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11657 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11658 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11659 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11660 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11661 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
|
11662 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11663 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
|
11664 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11665 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11666 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11667 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11668 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11669 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11670 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11671 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11672 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11673 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11674 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11675 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
|
11676 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11677 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11678 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11679 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11680 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11681 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11682 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
|
11683 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11684 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11685 * Allocate buffer for SMART READ LOG |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11686 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11687 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
|
11688 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11689 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11690 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11691 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11692 "sata_smart_read_log: " "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11693 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11694 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11695 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
11696 /* 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
|
11697 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11698 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
|
11699 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
|
11700 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
|
11701 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
|
11702 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11703 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11704 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11705 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11706 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11707 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11708 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11709 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11710 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
|
11711 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11712 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11713 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11714 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11715 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11716 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11717 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11718 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11719 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11720 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11721 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11722 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11723 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11724 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11725 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11726 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
11727 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11728 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
|
11729 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11730 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11731 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11732 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11733 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11734 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11735 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
|
11736 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11737 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11738 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11739 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11740 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11741 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11742 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11743 * Used by LOG SENSE page 0x10 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11744 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11745 * return 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11746 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11747 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11748 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11749 sata_read_log_ext_directory( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11750 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11751 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11752 struct read_log_ext_directory *logdir) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11753 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11754 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11755 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11756 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11757 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11758 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11759 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11760 ASSERT(sizeof (struct read_log_ext_directory) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11761 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11762 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11763 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
|
11764 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11765 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
|
11766 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11767 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11768 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11769 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11770 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11771 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11772 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11773 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11774 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
|
11775 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11776 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11777 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11778 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11779 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11780 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11781 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
|
11782 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11783 /* |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
11784 * 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
|
11785 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11786 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11787 sizeof (struct read_log_ext_directory)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11788 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11789 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11790 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11791 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11792 "sata_read_log_ext_directory: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11793 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11794 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11795 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11796 |
|
2553
624f674f2ad8
6430966 SATA NCQ support is needed in SATA framework and hba drivers
ls24207
parents:
2539
diff
changeset
|
11797 /* 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
|
11798 scmd->satacmd_addr_type = ATA_ADDR_LBA48; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11799 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
|
11800 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
|
11801 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
|
11802 scmd->satacmd_lba_low_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11803 scmd->satacmd_lba_mid_lsb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11804 scmd->satacmd_lba_mid_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11805 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11806 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11807 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11808 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11809 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11810 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11811 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11812 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
|
11813 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11814 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11815 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11816 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11817 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11818 * Whoops, no SMART selftest log info available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11819 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11820 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11821 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11822 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11823 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11824 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11825 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11826 DDI_DMA_SYNC_FORKERNEL); |
|
2539
2a06303a9684
6430355 sata framework needs to handle misaligned data buffers
pawelw
parents:
2177
diff
changeset
|
11827 ASSERT(rval == DDI_SUCCESS); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11828 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
|
11829 sizeof (struct read_log_ext_directory)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11830 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11831 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11832 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11833 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11834 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11835 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11836 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
|
11837 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11838 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11839 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11840 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11841 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11842 |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11843 static void |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11844 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
|
11845 int hint) |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11846 { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11847 char ap[MAXPATHLEN]; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11848 nvlist_t *ev_attr_list = NULL; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11849 int err; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11850 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11851 /* Allocate and build sysevent attribute list */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11852 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
|
11853 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11854 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
|
11855 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11856 "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
|
11857 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11858 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11859 /* Add hint attribute */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11860 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
|
11861 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11862 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
|
11863 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11864 "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
|
11865 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11866 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11867 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11868 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11869 * Add AP attribute. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11870 * 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
|
11871 * a target number. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11872 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11873 (void) snprintf(ap, MAXPATHLEN, "/devices"); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11874 (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
|
11875 (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
|
11876 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
|
11877 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11878 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
|
11879 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11880 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
|
11881 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11882 "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
|
11883 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11884 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11885 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11886 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11887 /* Generate/log sysevent */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11888 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
|
11889 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
|
11890 if (err != DDI_SUCCESS) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11891 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
|
11892 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11893 "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
|
11894 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11895 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11896 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11897 } |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11898 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11899 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11900 * 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
|
11901 * information to SCSI information returned in the SCSI |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11902 * packet. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11903 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11904 static void |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11905 sata_xlate_errors(sata_pkt_txlate_t *spx) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11906 { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11907 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11908 struct scsi_extended_sense *sense; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11909 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11910 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11911 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11912 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11913 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11914 switch (spx->txlt_sata_pkt->satapkt_reason) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11915 case SATA_PKT_PORT_ERROR: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11916 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11917 * 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
|
11918 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11919 sense->es_key = KEY_HARDWARE_ERROR; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11920 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11921 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11922 case SATA_PKT_DEV_ERROR: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11923 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
|
11924 SATA_STATUS_ERR) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11925 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11926 * determine dev error reason from error |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11927 * reg content |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11928 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11929 sata_decode_device_error(spx, sense); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11930 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11931 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11932 /* No extended sense key - no info available */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11933 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11934 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11935 case SATA_PKT_TIMEOUT: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11936 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11937 * scsipkt->pkt_reason = CMD_TIMEOUT; This causes problems. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11938 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11939 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11940 /* No extended sense key */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11941 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11942 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11943 case SATA_PKT_ABORTED: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11944 scsipkt->pkt_reason = CMD_ABORTED; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11945 /* No extended sense key */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11946 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11947 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11948 case SATA_PKT_RESET: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11949 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11950 * 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
|
11951 * a host, or due to error recovery |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11952 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11953 scsipkt->pkt_reason = CMD_RESET; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11954 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11955 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11956 default: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11957 scsipkt->pkt_reason = CMD_TRAN_ERR; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11958 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11959 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11960 } |