Mercurial > illumos > illumos-gate
annotate usr/src/uts/common/io/sata/impl/sata.c @ 1940:c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
6412375 Need to add support for tagged queuing in the marvell88sx driver
6412380 sata framework doesn't always utilize correct queuing mode
6412384 queue depth is incorrect for SATA controllers
6412386 Some SATA disks do no use the 19th entry in the self test log
6412390 SATA LOG SENSE results can be incorrect
6412398 allow scatter/gather list length for marvell88sx to be tunable
6420987 sata_hba_ioctl() may hold mutex upon exit
| author | ls24207 |
|---|---|
| date | Fri, 05 May 2006 13:30:06 -0700 |
| parents | 1005b1d56b1c |
| children | 01f4efa62f05 |
| 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 | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
66 int sata_func_enable = SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING; |
| 1258 | 67 |
| 68 #ifdef SATA_DEBUG | |
| 69 #define SATA_LOG_D(args) sata_log args | |
| 70 #else | |
| 71 #define SATA_LOG_D(arg) | |
| 72 #endif | |
| 73 | |
| 74 | |
| 75 /* | |
| 76 * SATA cb_ops functions | |
| 77 */ | |
| 78 static int sata_hba_open(dev_t *, int, int, cred_t *); | |
| 79 static int sata_hba_close(dev_t, int, int, cred_t *); | |
| 80 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); | |
| 81 | |
| 82 /* | |
| 83 * SCSA required entry points | |
| 84 */ | |
| 85 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, | |
| 86 scsi_hba_tran_t *, struct scsi_device *); | |
| 87 static int sata_scsi_tgt_probe(struct scsi_device *, | |
| 88 int (*callback)(void)); | |
| 89 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, | |
| 90 scsi_hba_tran_t *, struct scsi_device *); | |
| 91 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); | |
| 92 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); | |
| 93 static int sata_scsi_reset(struct scsi_address *, int); | |
| 94 static int sata_scsi_getcap(struct scsi_address *, char *, int); | |
| 95 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); | |
| 96 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, | |
| 97 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), | |
| 98 caddr_t); | |
| 99 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); | |
| 100 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); | |
| 101 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); | |
| 102 | |
| 103 | |
| 104 /* | |
| 105 * Local functions | |
| 106 */ | |
| 107 static void sata_remove_hba_instance(dev_info_t *); | |
| 108 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); | |
| 109 static void sata_probe_ports(sata_hba_inst_t *); | |
| 110 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *); | |
| 111 static void sata_make_device_nodes(dev_info_t *, sata_hba_inst_t *); | |
| 112 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, | |
| 113 sata_address_t *); | |
| 114 static int sata_validate_scsi_address(sata_hba_inst_t *, | |
| 115 struct scsi_address *, sata_device_t *); | |
| 116 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); | |
| 117 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); | |
| 118 static void sata_pkt_free(sata_pkt_txlate_t *); | |
| 119 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), | |
| 120 caddr_t, ddi_dma_attr_t *); | |
| 121 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); | |
| 122 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, | |
| 123 sata_device_t *); | |
| 124 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); | |
| 125 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); | |
| 126 static void sata_free_local_buffer(sata_pkt_txlate_t *); | |
| 127 static uint64_t sata_check_capacity(sata_drive_info_t *); | |
| 128 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, | |
| 129 ddi_dma_attr_t *); | |
| 130 static int sata_fetch_device_identify_data(sata_hba_inst_t *, | |
| 131 sata_drive_info_t *); | |
| 132 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); | |
| 133 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); | |
| 134 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
|
135 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
|
136 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
|
137 sata_drive_info_t *, int flag); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
138 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
|
139 sata_drive_info_t *sdinfo); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
140 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); |
| 1258 | 141 |
| 142 /* Event processing functions */ | |
| 143 static void sata_event_daemon(void *); | |
| 144 static void sata_event_thread_control(int); | |
| 145 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); | |
| 146 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); | |
| 147 static void sata_process_port_failed_event(sata_hba_inst_t *, | |
| 148 sata_address_t *); | |
| 149 static void sata_process_port_link_events(sata_hba_inst_t *, | |
| 150 sata_address_t *); | |
| 151 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); | |
| 152 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); | |
| 153 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); | |
| 154 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); | |
| 155 | |
| 156 /* Local functions for ioctl */ | |
| 157 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); | |
| 158 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, | |
| 159 devctl_ap_state_t *); | |
| 160 static dev_info_t *sata_get_target_dip(dev_info_t *, int32_t); | |
| 161 static dev_info_t *sata_devt_to_devinfo(dev_t); | |
| 162 | |
| 163 /* Local translation functions */ | |
| 164 static int sata_txlt_inquiry(sata_pkt_txlate_t *); | |
| 165 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); | |
| 166 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); | |
| 167 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); | |
| 168 static int sata_txlt_request_sense(sata_pkt_txlate_t *); | |
| 169 static int sata_txlt_read(sata_pkt_txlate_t *); | |
| 170 static int sata_txlt_write(sata_pkt_txlate_t *); | |
| 171 static int sata_txlt_atapi(sata_pkt_txlate_t *); | |
| 172 static int sata_txlt_log_sense(sata_pkt_txlate_t *); | |
| 173 static int sata_txlt_log_select(sata_pkt_txlate_t *); | |
| 174 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); | |
| 175 static int sata_txlt_mode_select(sata_pkt_txlate_t *); | |
| 176 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); | |
| 177 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); | |
| 178 | |
| 179 static int sata_hba_start(sata_pkt_txlate_t *, int *); | |
| 180 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); | |
| 181 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); | |
| 182 static void sata_txlt_rw_completion(sata_pkt_t *); | |
| 183 static void sata_txlt_atapi_completion(sata_pkt_t *); | |
| 184 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); | |
| 185 | |
| 186 static struct scsi_extended_sense *sata_immediate_error_response( | |
| 187 sata_pkt_txlate_t *, int); | |
| 188 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); | |
| 189 | |
| 190 /* Local functions */ | |
| 191 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, | |
| 192 uint8_t *); | |
| 193 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); | |
| 194 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); | |
| 195 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); | |
| 196 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); | |
| 197 static int sata_mode_select_page_8(sata_pkt_txlate_t *, | |
| 198 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
|
199 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
|
200 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
|
201 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
|
202 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
|
203 sata_hba_inst_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
204 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
|
205 sata_hba_inst_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
206 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
|
207 sata_hba_inst_t *); |
| 1258 | 208 static void sata_save_drive_settings(sata_drive_info_t *); |
| 209 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); | |
| 210 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
|
211 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
|
212 sata_drive_info_t *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
213 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
|
214 struct smart_data *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
215 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
|
216 sata_drive_info_t *, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
217 struct smart_selftest_log *); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
218 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
|
219 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
|
220 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
|
221 uint8_t *, uint8_t, uint8_t); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
222 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
|
223 struct read_log_ext_directory *); |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
224 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
|
225 static void sata_xlate_errors(sata_pkt_txlate_t *); |
| 1258 | 226 |
| 227 /* | |
| 228 * SATA Framework will ignore SATA HBA driver cb_ops structure and | |
| 229 * register following one with SCSA framework. | |
| 230 * Open & close are provided, so scsi framework will not use its own | |
| 231 */ | |
| 232 static struct cb_ops sata_cb_ops = { | |
| 233 sata_hba_open, /* open */ | |
| 234 sata_hba_close, /* close */ | |
| 235 nodev, /* strategy */ | |
| 236 nodev, /* print */ | |
| 237 nodev, /* dump */ | |
| 238 nodev, /* read */ | |
| 239 nodev, /* write */ | |
| 240 sata_hba_ioctl, /* ioctl */ | |
| 241 nodev, /* devmap */ | |
| 242 nodev, /* mmap */ | |
| 243 nodev, /* segmap */ | |
| 244 nochpoll, /* chpoll */ | |
| 245 ddi_prop_op, /* cb_prop_op */ | |
| 246 0, /* streamtab */ | |
| 247 D_NEW | D_MP, /* cb_flag */ | |
| 248 CB_REV, /* rev */ | |
| 249 nodev, /* aread */ | |
| 250 nodev /* awrite */ | |
| 251 }; | |
| 252 | |
| 253 | |
| 254 extern struct mod_ops mod_miscops; | |
| 255 extern uchar_t scsi_cdb_size[]; | |
| 256 | |
| 257 static struct modlmisc modlmisc = { | |
| 258 &mod_miscops, /* Type of module */ | |
| 259 "Generic SATA Driver v%I%" /* module name */ | |
| 260 }; | |
| 261 | |
| 262 | |
| 263 static struct modlinkage modlinkage = { | |
| 264 MODREV_1, | |
| 265 (void *)&modlmisc, | |
| 266 NULL | |
| 267 }; | |
| 268 | |
| 269 /* | |
| 270 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, | |
| 271 * i.e. when scsi_pkt has not timeout specified. | |
| 272 */ | |
| 273 static int sata_default_pkt_time = 60; /* 60 seconds */ | |
| 274 | |
| 275 /* | |
| 276 * Mutexes protecting structures in multithreaded operations. | |
| 277 * Because events are relatively rare, a single global mutex protecting | |
| 278 * data structures should be sufficient. To increase performance, add | |
| 279 * separate mutex per each sata port and use global mutex only to protect | |
| 280 * common data structures. | |
| 281 */ | |
| 282 static kmutex_t sata_mutex; /* protects sata_hba_list */ | |
| 283 static kmutex_t sata_log_mutex; /* protects log */ | |
| 284 | |
| 285 static char sata_log_buf[256]; | |
| 286 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
287 /* Default write cache setting */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
288 int sata_write_cache = 1; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
289 |
| 1258 | 290 /* |
| 291 * Linked list of HBA instances | |
| 292 */ | |
| 293 static sata_hba_inst_t *sata_hba_list = NULL; | |
| 294 static sata_hba_inst_t *sata_hba_list_tail = NULL; | |
| 295 /* | |
| 296 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran | |
| 297 * structure and in sata soft state. | |
| 298 */ | |
| 299 | |
| 300 /* | |
| 301 * Event daemon related variables | |
| 302 */ | |
| 303 static kmutex_t sata_event_mutex; | |
| 304 static kcondvar_t sata_event_cv; | |
| 305 static kthread_t *sata_event_thread = NULL; | |
| 306 static int sata_event_thread_terminate = 0; | |
| 307 static int sata_event_pending = 0; | |
| 308 static int sata_event_thread_active = 0; | |
| 309 extern pri_t minclsyspri; | |
| 310 | |
| 311 /* Warlock directives */ | |
| 312 | |
| 313 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) | |
| 314 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) | |
| 315 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) | |
| 316 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) | |
| 317 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) | |
| 318 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) | |
| 319 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) | |
| 320 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) | |
| 321 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) | |
| 322 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) | |
| 323 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) | |
| 324 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) | |
| 325 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ | |
| 326 sata_hba_inst::satahba_scsi_tran)) | |
| 327 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) | |
| 328 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) | |
| 329 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) | |
| 330 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) | |
| 331 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, | |
| 332 sata_hba_inst::satahba_event_flags)) | |
| 333 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 334 sata_cport_info::cport_devp)) | |
| 335 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) | |
| 336 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) | |
| 337 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 338 sata_cport_info::cport_dev_type)) | |
| 339 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) | |
| 340 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ | |
| 341 sata_cport_info::cport_state)) | |
| 342 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) | |
| 343 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) | |
| 344 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) | |
| 345 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) | |
| 346 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) | |
| 347 | |
| 348 /* End of warlock directives */ | |
| 349 | |
| 350 /* ************** loadable module configuration functions ************** */ | |
| 351 | |
| 352 int | |
| 353 _init() | |
| 354 { | |
| 355 int rval; | |
| 356 | |
| 357 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 358 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 359 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 360 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); | |
| 361 if ((rval = mod_install(&modlinkage)) != 0) { | |
| 362 #ifdef SATA_DEBUG | |
| 363 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); | |
| 364 #endif | |
| 365 mutex_destroy(&sata_log_mutex); | |
| 366 cv_destroy(&sata_event_cv); | |
| 367 mutex_destroy(&sata_event_mutex); | |
| 368 mutex_destroy(&sata_mutex); | |
| 369 } | |
| 370 return (rval); | |
| 371 } | |
| 372 | |
| 373 int | |
| 374 _fini() | |
| 375 { | |
| 376 int rval; | |
| 377 | |
| 378 if ((rval = mod_remove(&modlinkage)) != 0) | |
| 379 return (rval); | |
| 380 | |
| 381 mutex_destroy(&sata_log_mutex); | |
| 382 cv_destroy(&sata_event_cv); | |
| 383 mutex_destroy(&sata_event_mutex); | |
| 384 mutex_destroy(&sata_mutex); | |
| 385 return (rval); | |
| 386 } | |
| 387 | |
| 388 int | |
| 389 _info(struct modinfo *modinfop) | |
| 390 { | |
| 391 return (mod_info(&modlinkage, modinfop)); | |
| 392 } | |
| 393 | |
| 394 | |
| 395 | |
| 396 /* ********************* SATA HBA entry points ********************* */ | |
| 397 | |
| 398 | |
| 399 /* | |
| 400 * Called by SATA HBA from _init(). | |
| 401 * Registers HBA driver instance/sata framework pair with scsi framework, by | |
| 402 * calling scsi_hba_init(). | |
| 403 * | |
| 404 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used | |
| 405 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver | |
| 406 * cb_ops pointer in SATA HBA driver dev_ops structure. | |
| 407 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. | |
| 408 * | |
| 409 * Return status of the scsi_hba_init() is returned to a calling SATA HBA | |
| 410 * driver. | |
| 411 */ | |
| 412 int | |
| 413 sata_hba_init(struct modlinkage *modlp) | |
| 414 { | |
| 415 int rval; | |
| 416 struct dev_ops *hba_ops; | |
| 417 | |
| 418 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 419 "sata_hba_init: name %s \n", | |
| 420 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); | |
| 421 /* | |
| 422 * Fill-up cb_ops and dev_ops when necessary | |
| 423 */ | |
| 424 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; | |
| 425 /* | |
| 426 * Provide pointer to SATA dev_ops | |
| 427 */ | |
| 428 hba_ops->devo_cb_ops = &sata_cb_ops; | |
| 429 | |
| 430 /* | |
| 431 * Register SATA HBA with SCSI framework | |
| 432 */ | |
| 433 if ((rval = scsi_hba_init(modlp)) != 0) { | |
| 434 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 435 "sata_hba_init: scsi hba init failed\n", NULL); | |
| 436 return (rval); | |
| 437 } | |
| 438 | |
| 439 return (0); | |
| 440 } | |
| 441 | |
| 442 | |
| 443 /* HBA attach stages */ | |
| 444 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 | |
| 445 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 | |
| 446 #define HBA_ATTACH_STAGE_SETUP 4 | |
| 447 #define HBA_ATTACH_STAGE_LINKED 8 | |
| 448 | |
| 449 | |
| 450 /* | |
| 451 * | |
| 452 * Called from SATA HBA driver's attach routine to attach an instance of | |
| 453 * the HBA. | |
| 454 * | |
| 455 * For DDI_ATTACH command: | |
| 456 * sata_hba_inst structure is allocated here and initialized with pointers to | |
| 457 * SATA framework implementation of required scsi tran functions. | |
| 458 * The scsi_tran's tran_hba_private field is used by SATA Framework to point | |
| 459 * to the soft structure (sata_hba_inst) allocated by SATA framework for | |
| 460 * SATA HBA instance related data. | |
| 461 * The scsi_tran's tran_hba_private field is used by SATA framework to | |
| 462 * store a pointer to per-HBA-instance of sata_hba_inst structure. | |
| 463 * The sata_hba_inst structure is cross-linked to scsi tran structure. | |
| 464 * Among other info, a pointer to sata_hba_tran structure is stored in | |
| 465 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are | |
| 466 * linked together into the list, pointed to by sata_hba_list. | |
| 467 * On the first HBA instance attach the sata event thread is initialized. | |
| 468 * Attachment points are created for all SATA ports of the HBA being attached. | |
| 469 * All HBA instance's SATA ports are probed and type of plugged devices is | |
| 470 * determined. For each device of a supported type, a target node is created. | |
| 471 * | |
| 472 * DDI_SUCCESS is returned when attachment process is successful, | |
| 473 * DDI_FAILURE is returned otherwise. | |
| 474 * | |
| 475 * For DDI_RESUME command: | |
| 476 * Not implemented at this time (postponed until phase 2 of the development). | |
| 477 */ | |
| 478 int | |
| 479 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, | |
| 480 ddi_attach_cmd_t cmd) | |
| 481 { | |
| 482 sata_hba_inst_t *sata_hba_inst; | |
| 483 scsi_hba_tran_t *scsi_tran = NULL; | |
| 484 int hba_attach_state = 0; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
485 char taskq_name[MAXPATHLEN]; |
| 1258 | 486 |
| 487 SATADBG3(SATA_DBG_HBA_IF, NULL, | |
| 488 "sata_hba_attach: node %s (%s%d)\n", | |
| 489 ddi_node_name(dip), ddi_driver_name(dip), | |
| 490 ddi_get_instance(dip)); | |
| 491 | |
| 492 if (cmd == DDI_RESUME) { | |
| 493 /* | |
| 494 * Postponed until phase 2 of the development | |
| 495 */ | |
| 496 return (DDI_FAILURE); | |
| 497 } | |
| 498 | |
| 499 if (cmd != DDI_ATTACH) { | |
| 500 return (DDI_FAILURE); | |
| 501 } | |
| 502 | |
| 503 /* cmd == DDI_ATTACH */ | |
| 504 | |
| 505 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { | |
| 506 SATA_LOG_D((NULL, CE_WARN, | |
| 507 "sata_hba_attach: invalid sata_hba_tran")); | |
| 508 return (DDI_FAILURE); | |
| 509 } | |
| 510 /* | |
| 511 * Allocate and initialize SCSI tran structure. | |
| 512 * SATA copy of tran_bus_config is provided to create port nodes. | |
| 513 */ | |
| 514 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); | |
| 515 if (scsi_tran == NULL) | |
| 516 return (DDI_FAILURE); | |
| 517 /* | |
| 518 * Allocate soft structure for SATA HBA instance. | |
| 519 * There is a separate softstate for each HBA instance. | |
| 520 */ | |
| 521 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); | |
| 522 ASSERT(sata_hba_inst != NULL); /* this should not fail */ | |
| 523 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 524 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; | |
| 525 | |
| 526 /* | |
| 527 * scsi_trans's tran_hba_private is used by SATA Framework to point to | |
| 528 * soft structure allocated by SATA framework for | |
| 529 * SATA HBA instance related data. | |
| 530 */ | |
| 531 scsi_tran->tran_hba_private = sata_hba_inst; | |
| 532 scsi_tran->tran_tgt_private = NULL; | |
| 533 | |
| 534 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; | |
| 535 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; | |
| 536 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; | |
| 537 | |
| 538 scsi_tran->tran_start = sata_scsi_start; | |
| 539 scsi_tran->tran_reset = sata_scsi_reset; | |
| 540 scsi_tran->tran_abort = sata_scsi_abort; | |
| 541 scsi_tran->tran_getcap = sata_scsi_getcap; | |
| 542 scsi_tran->tran_setcap = sata_scsi_setcap; | |
| 543 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; | |
| 544 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; | |
| 545 | |
| 546 scsi_tran->tran_dmafree = sata_scsi_dmafree; | |
| 547 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; | |
| 548 | |
| 549 scsi_tran->tran_reset_notify = NULL; | |
| 550 scsi_tran->tran_get_bus_addr = NULL; | |
| 551 scsi_tran->tran_quiesce = NULL; | |
| 552 scsi_tran->tran_unquiesce = NULL; | |
| 553 scsi_tran->tran_bus_reset = NULL; | |
| 554 | |
| 555 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, | |
| 556 scsi_tran, 0) != DDI_SUCCESS) { | |
| 557 #ifdef SATA_DEBUG | |
| 558 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", | |
| 559 ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 560 #endif | |
| 561 goto fail; | |
| 562 } | |
| 563 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; | |
| 564 | |
| 565 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { | |
| 566 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, | |
| 567 "sata", 1) != DDI_PROP_SUCCESS) { | |
| 568 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " | |
| 569 "failed to create hba sata prop")); | |
| 570 goto fail; | |
| 571 } | |
| 572 } | |
| 573 | |
| 574 /* | |
| 575 * Save pointers in hba instance soft state. | |
| 576 */ | |
| 577 sata_hba_inst->satahba_scsi_tran = scsi_tran; | |
| 578 sata_hba_inst->satahba_tran = sata_tran; | |
| 579 sata_hba_inst->satahba_dip = dip; | |
| 580 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
581 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
582 * 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
|
583 * 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
|
584 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
585 taskq_name[0] = '\0'; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
586 (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
|
587 sizeof (taskq_name)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
588 (void) snprintf(taskq_name + strlen(taskq_name), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
589 sizeof (taskq_name) - strlen(taskq_name), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
590 "-%d", DEVI(dip)->devi_instance); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
591 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
|
592 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
|
593 TASKQ_DYNAMIC); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
594 |
| 1258 | 595 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; |
| 596 | |
| 597 /* | |
| 598 * Create events thread if not created yet. | |
| 599 */ | |
| 600 sata_event_thread_control(1); | |
| 601 | |
| 602 /* | |
| 603 * Link this hba instance into the list. | |
| 604 */ | |
| 605 mutex_enter(&sata_mutex); | |
| 606 | |
| 607 | |
| 608 sata_hba_inst->satahba_next = NULL; | |
| 609 sata_hba_inst->satahba_prev = sata_hba_list_tail; | |
| 610 if (sata_hba_list == NULL) { | |
| 611 sata_hba_list = sata_hba_inst; | |
| 612 } | |
| 613 if (sata_hba_list_tail != NULL) { | |
| 614 sata_hba_list_tail->satahba_next = sata_hba_inst; | |
| 615 } | |
| 616 sata_hba_list_tail = sata_hba_inst; | |
| 617 mutex_exit(&sata_mutex); | |
| 618 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; | |
| 619 | |
| 620 /* | |
| 621 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl | |
| 622 * SATA HBA driver should not use its own open/close entry points. | |
| 623 * | |
| 624 * Make sure that instance number doesn't overflow | |
| 625 * when forming minor numbers. | |
| 626 */ | |
| 627 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); | |
| 628 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, | |
| 629 INST2DEVCTL(ddi_get_instance(dip)), | |
| 630 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { | |
| 631 #ifdef SATA_DEBUG | |
| 632 cmn_err(CE_WARN, "sata_hba_attach: " | |
| 633 "cannot create devctl minor node"); | |
| 634 #endif | |
| 635 goto fail; | |
| 636 } | |
| 637 | |
| 638 | |
| 639 /* | |
| 640 * Set-up kstats here, if necessary. | |
| 641 * (postponed until phase 2 of the development). | |
| 642 */ | |
| 643 | |
| 644 | |
| 645 /* | |
| 646 * Probe controller ports. This operation will describe a current | |
| 647 * controller/port/multipliers/device configuration and will create | |
| 648 * attachment points. | |
| 649 * We may end-up with just a controller with no devices attached. | |
| 650 */ | |
| 651 sata_probe_ports(sata_hba_inst); | |
| 652 | |
| 653 /* | |
| 654 * Create child nodes for all possible target devices currently | |
| 655 * attached to controller's ports and port multiplier device ports. | |
| 656 */ | |
| 657 sata_make_device_nodes(sata_tran->sata_tran_hba_dip, sata_hba_inst); | |
| 658 | |
| 659 sata_hba_inst->satahba_attached = 1; | |
| 660 return (DDI_SUCCESS); | |
| 661 | |
| 662 fail: | |
| 663 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { | |
| 664 (void) sata_remove_hba_instance(dip); | |
| 665 if (sata_hba_list == NULL) | |
| 666 sata_event_thread_control(0); | |
| 667 } | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
668 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
669 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { |
| 1258 | 670 (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
|
671 taskq_destroy(sata_hba_inst->satahba_taskq); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
672 } |
| 1258 | 673 |
| 674 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) | |
| 675 (void) scsi_hba_detach(dip); | |
| 676 | |
| 677 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { | |
| 678 mutex_destroy(&sata_hba_inst->satahba_mutex); | |
| 679 kmem_free((void *)sata_hba_inst, | |
| 680 sizeof (struct sata_hba_inst)); | |
| 681 scsi_hba_tran_free(scsi_tran); | |
| 682 } | |
| 683 | |
| 684 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", | |
| 685 ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 686 | |
| 687 return (DDI_FAILURE); | |
| 688 } | |
| 689 | |
| 690 | |
| 691 /* | |
| 692 * Called by SATA HBA from to detach an instance of the driver. | |
| 693 * | |
| 694 * For DDI_DETACH command: | |
| 695 * Free local structures allocated for SATA HBA instance during | |
| 696 * sata_hba_attach processing. | |
| 697 * | |
| 698 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. | |
| 699 * | |
| 700 * For DDI_SUSPEND command: | |
| 701 * Not implemented at this time (postponed until phase 2 of the development) | |
| 702 * Returnd DDI_SUCCESS. | |
| 703 * | |
| 704 * When the last HBA instance is detached, the event daemon is terminated. | |
| 705 * | |
| 706 * NOTE: cport support only, no port multiplier support. | |
| 707 */ | |
| 708 int | |
| 709 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) | |
| 710 { | |
| 711 dev_info_t *tdip; | |
| 712 sata_hba_inst_t *sata_hba_inst; | |
| 713 scsi_hba_tran_t *scsi_hba_tran; | |
| 714 sata_cport_info_t *cportinfo; | |
| 715 sata_drive_info_t *sdinfo; | |
| 716 int ncport; | |
| 717 | |
| 718 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", | |
| 719 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); | |
| 720 | |
| 721 switch (cmd) { | |
| 722 case DDI_DETACH: | |
| 723 | |
| 724 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 725 return (DDI_FAILURE); | |
| 726 | |
| 727 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 728 if (sata_hba_inst == NULL) | |
| 729 return (DDI_FAILURE); | |
| 730 | |
| 731 if (scsi_hba_detach(dip) == DDI_FAILURE) { | |
| 732 sata_hba_inst->satahba_attached = 1; | |
| 733 return (DDI_FAILURE); | |
| 734 } | |
| 735 | |
| 736 /* | |
| 737 * Free all target nodes - at this point | |
| 738 * devices should be at least offlined | |
| 739 * otherwise scsi_hba_detach() should not be called. | |
| 740 */ | |
| 741 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 742 ncport++) { | |
| 743 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 744 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 745 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 746 if (sdinfo != NULL) { | |
| 747 tdip = sata_get_target_dip(dip, | |
| 748 ncport); | |
| 749 if (tdip != NULL) { | |
| 750 if (ndi_devi_offline(tdip, | |
| 751 NDI_DEVI_REMOVE) != | |
| 752 NDI_SUCCESS) { | |
| 753 SATA_LOG_D(( | |
| 754 sata_hba_inst, | |
| 755 CE_WARN, | |
| 756 "sata_hba_detach: " | |
| 757 "Target node not " | |
| 758 "removed !")); | |
| 759 return (DDI_FAILURE); | |
| 760 } | |
| 761 } | |
| 762 } | |
| 763 } | |
| 764 } | |
| 765 /* | |
| 766 * Disable sata event daemon processing for this HBA | |
| 767 */ | |
| 768 sata_hba_inst->satahba_attached = 0; | |
| 769 | |
| 770 /* | |
| 771 * Remove event daemon thread, if it is last HBA instance. | |
| 772 */ | |
| 773 | |
| 774 mutex_enter(&sata_mutex); | |
| 775 if (sata_hba_list->satahba_next == NULL) { | |
| 776 mutex_exit(&sata_mutex); | |
| 777 sata_event_thread_control(0); | |
| 778 mutex_enter(&sata_mutex); | |
| 779 } | |
| 780 mutex_exit(&sata_mutex); | |
| 781 | |
| 782 /* Remove this HBA instance from the HBA list */ | |
| 783 sata_remove_hba_instance(dip); | |
| 784 | |
| 785 /* | |
| 786 * At this point there should be no target nodes attached. | |
| 787 * Detach and destroy device and port info structures. | |
| 788 */ | |
| 789 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 790 ncport++) { | |
| 791 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 792 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 793 sdinfo = | |
| 794 cportinfo->cport_devp.cport_sata_drive; | |
| 795 if (sdinfo != NULL) { | |
| 796 /* Release device structure */ | |
| 797 kmem_free(sdinfo, | |
| 798 sizeof (sata_drive_info_t)); | |
| 799 } | |
| 800 /* Release cport info */ | |
| 801 mutex_destroy(&cportinfo->cport_mutex); | |
| 802 kmem_free(cportinfo, | |
| 803 sizeof (sata_cport_info_t)); | |
| 804 } | |
| 805 } | |
| 806 | |
| 807 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); | |
| 808 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
809 (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
|
810 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
811 taskq_destroy(sata_hba_inst->satahba_taskq); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
812 |
| 1258 | 813 mutex_destroy(&sata_hba_inst->satahba_mutex); |
| 814 kmem_free((void *)sata_hba_inst, | |
| 815 sizeof (struct sata_hba_inst)); | |
| 816 | |
| 817 return (DDI_SUCCESS); | |
| 818 | |
| 819 case DDI_SUSPEND: | |
| 820 /* | |
| 821 * Postponed until phase 2 | |
| 822 */ | |
| 823 return (DDI_FAILURE); | |
| 824 | |
| 825 default: | |
| 826 return (DDI_FAILURE); | |
| 827 } | |
| 828 } | |
| 829 | |
| 830 | |
| 831 /* | |
| 832 * Called by an HBA drive from _fini() routine. | |
| 833 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. | |
| 834 */ | |
| 835 void | |
| 836 sata_hba_fini(struct modlinkage *modlp) | |
| 837 { | |
| 838 SATADBG1(SATA_DBG_HBA_IF, NULL, | |
| 839 "sata_hba_fini: name %s\n", | |
| 840 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); | |
| 841 | |
| 842 scsi_hba_fini(modlp); | |
| 843 } | |
| 844 | |
| 845 | |
| 846 /* | |
| 847 * Default open and close routine for sata_hba framework. | |
| 848 * | |
| 849 */ | |
| 850 /* | |
| 851 * Open devctl node. | |
| 852 * | |
| 853 * Returns: | |
| 854 * 0 if node was open successfully, error code otherwise. | |
| 855 * | |
| 856 * | |
| 857 */ | |
| 858 | |
| 859 static int | |
| 860 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) | |
| 861 { | |
| 862 #ifndef __lock_lint | |
| 863 _NOTE(ARGUNUSED(credp)) | |
| 864 #endif | |
| 865 int rv = 0; | |
| 866 dev_info_t *dip; | |
| 867 scsi_hba_tran_t *scsi_hba_tran; | |
| 868 sata_hba_inst_t *sata_hba_inst; | |
| 869 | |
| 870 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); | |
| 871 | |
| 872 if (otyp != OTYP_CHR) | |
| 873 return (EINVAL); | |
| 874 | |
| 875 dip = sata_devt_to_devinfo(*devp); | |
| 876 if (dip == NULL) | |
| 877 return (ENXIO); | |
| 878 | |
| 879 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 880 return (ENXIO); | |
| 881 | |
| 882 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 883 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) | |
| 884 return (ENXIO); | |
| 885 | |
| 886 mutex_enter(&sata_mutex); | |
| 887 if (flags & FEXCL) { | |
| 888 if (sata_hba_inst->satahba_open_flag != 0) { | |
| 889 rv = EBUSY; | |
| 890 } else { | |
| 891 sata_hba_inst->satahba_open_flag = | |
| 892 SATA_DEVCTL_EXOPENED; | |
| 893 } | |
| 894 } else { | |
| 895 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { | |
| 896 rv = EBUSY; | |
| 897 } else { | |
| 898 sata_hba_inst->satahba_open_flag = | |
| 899 SATA_DEVCTL_SOPENED; | |
| 900 } | |
| 901 } | |
| 902 mutex_exit(&sata_mutex); | |
| 903 | |
| 904 return (rv); | |
| 905 } | |
| 906 | |
| 907 | |
| 908 /* | |
| 909 * Close devctl node. | |
| 910 * Returns: | |
| 911 * 0 if node was closed successfully, error code otherwise. | |
| 912 * | |
| 913 */ | |
| 914 | |
| 915 static int | |
| 916 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) | |
| 917 { | |
| 918 #ifndef __lock_lint | |
| 919 _NOTE(ARGUNUSED(credp)) | |
| 920 _NOTE(ARGUNUSED(flag)) | |
| 921 #endif | |
| 922 dev_info_t *dip; | |
| 923 scsi_hba_tran_t *scsi_hba_tran; | |
| 924 sata_hba_inst_t *sata_hba_inst; | |
| 925 | |
| 926 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); | |
| 927 | |
| 928 if (otyp != OTYP_CHR) | |
| 929 return (EINVAL); | |
| 930 | |
| 931 dip = sata_devt_to_devinfo(dev); | |
| 932 if (dip == NULL) | |
| 933 return (ENXIO); | |
| 934 | |
| 935 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 936 return (ENXIO); | |
| 937 | |
| 938 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 939 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) | |
| 940 return (ENXIO); | |
| 941 | |
| 942 mutex_enter(&sata_mutex); | |
| 943 sata_hba_inst->satahba_open_flag = 0; | |
| 944 mutex_exit(&sata_mutex); | |
| 945 return (0); | |
| 946 } | |
| 947 | |
| 948 | |
| 949 | |
| 950 /* | |
| 951 * Standard IOCTL commands for SATA hotplugging. | |
| 952 * Implemented DEVCTL_AP commands: | |
| 953 * DEVCTL_AP_CONNECT | |
| 954 * DEVCTL_AP_DISCONNECT | |
| 955 * DEVCTL_AP_CONFIGURE | |
| 956 * DEVCTL_UNCONFIGURE | |
| 957 * DEVCTL_AP_CONTROL | |
| 958 * | |
| 959 * Commands passed to default ndi ioctl handler: | |
| 960 * DEVCTL_DEVICE_GETSTATE | |
| 961 * DEVCTL_DEVICE_ONLINE | |
| 962 * DEVCTL_DEVICE_OFFLINE | |
| 963 * DEVCTL_DEVICE_REMOVE | |
| 964 * DEVCTL_DEVICE_INSERT | |
| 965 * DEVCTL_BUS_GETSTATE | |
| 966 * | |
| 967 * All other cmds are passed to HBA if it provide ioctl handler, or failed | |
| 968 * if not. | |
| 969 * | |
| 970 * Returns: | |
| 971 * 0 if successful, | |
| 972 * error code if operation failed. | |
| 973 * | |
| 974 * NOTE: Port Multiplier is not supported. | |
| 975 * | |
| 976 */ | |
| 977 | |
| 978 static int | |
| 979 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, | |
| 980 int *rvalp) | |
| 981 { | |
| 982 #ifndef __lock_lint | |
| 983 _NOTE(ARGUNUSED(credp)) | |
| 984 _NOTE(ARGUNUSED(rvalp)) | |
| 985 #endif | |
| 986 int rv = 0; | |
| 987 int32_t comp_port = -1; | |
| 988 dev_info_t *dip, *tdip; | |
| 989 devctl_ap_state_t ap_state; | |
| 990 struct devctl_iocdata *dcp = NULL; | |
| 991 scsi_hba_tran_t *scsi_hba_tran; | |
| 992 sata_hba_inst_t *sata_hba_inst; | |
| 993 sata_device_t sata_device; | |
| 994 sata_drive_info_t *sdinfo; | |
| 995 sata_cport_info_t *cportinfo; | |
| 996 int cport, pmport, qual; | |
| 997 int rval = SATA_SUCCESS; | |
| 998 | |
| 999 dip = sata_devt_to_devinfo(dev); | |
| 1000 if (dip == NULL) | |
| 1001 return (ENXIO); | |
| 1002 | |
| 1003 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) | |
| 1004 return (ENXIO); | |
| 1005 | |
| 1006 sata_hba_inst = scsi_hba_tran->tran_hba_private; | |
| 1007 if (sata_hba_inst == NULL) | |
| 1008 return (ENXIO); | |
| 1009 | |
| 1010 if (sata_hba_inst->satahba_tran == NULL) | |
| 1011 return (ENXIO); | |
| 1012 | |
| 1013 switch (cmd) { | |
| 1014 | |
| 1015 case DEVCTL_DEVICE_GETSTATE: | |
| 1016 case DEVCTL_DEVICE_ONLINE: | |
| 1017 case DEVCTL_DEVICE_OFFLINE: | |
| 1018 case DEVCTL_DEVICE_REMOVE: | |
| 1019 case DEVCTL_BUS_GETSTATE: | |
| 1020 /* | |
| 1021 * There may be more cases that we want to pass to default | |
| 1022 * handler rather then fail them. | |
| 1023 */ | |
| 1024 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); | |
| 1025 } | |
| 1026 | |
| 1027 /* read devctl ioctl data */ | |
| 1028 if (cmd != DEVCTL_AP_CONTROL) { | |
| 1029 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) | |
| 1030 return (EFAULT); | |
| 1031 | |
| 1032 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == | |
| 1033 -1) { | |
| 1034 if (dcp) | |
| 1035 ndi_dc_freehdl(dcp); | |
| 1036 return (EINVAL); | |
| 1037 } | |
| 1038 | |
| 1039 cport = SCSI_TO_SATA_CPORT(comp_port); | |
| 1040 pmport = SCSI_TO_SATA_PMPORT(comp_port); | |
| 1041 /* Only cport is considered now, i.e. SATA_ADDR_CPORT */ | |
| 1042 qual = SATA_ADDR_CPORT; | |
| 1043 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, | |
| 1044 qual) != 0) { | |
| 1045 ndi_dc_freehdl(dcp); | |
| 1046 return (EINVAL); | |
| 1047 } | |
| 1048 | |
| 1049 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 1050 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1051 cport_mutex); | |
| 1052 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { | |
| 1053 /* | |
| 1054 * Cannot process ioctl request now. Come back later. | |
| 1055 */ | |
| 1056 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1057 cport_mutex); | |
| 1058 ndi_dc_freehdl(dcp); | |
| 1059 return (EBUSY); | |
| 1060 } | |
| 1061 /* Block event processing for this port */ | |
| 1062 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; | |
| 1063 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1064 | |
| 1065 sata_device.satadev_addr.cport = cport; | |
| 1066 sata_device.satadev_addr.pmport = pmport; | |
| 1067 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1068 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 1069 } | |
| 1070 | |
| 1071 switch (cmd) { | |
| 1072 | |
| 1073 case DEVCTL_AP_DISCONNECT: | |
| 1074 /* | |
| 1075 * Normally, cfgadm sata plugin will try to offline | |
| 1076 * (unconfigure) device before this request. Nevertheless, | |
| 1077 * if a device is still configured, we need to | |
| 1078 * attempt to offline and unconfigure device first, and we will | |
| 1079 * deactivate the port regardless of the unconfigure | |
| 1080 * operation results. | |
| 1081 * | |
| 1082 * DEVCTL_AP_DISCONNECT invokes | |
| 1083 * sata_hba_inst->satahba_tran-> | |
| 1084 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). | |
| 1085 * If successful, the device structure (if any) attached | |
| 1086 * to a port is removed and state of the port marked | |
| 1087 * appropriately. | |
| 1088 * Failure of the port_deactivate may keep port in | |
| 1089 * the active state, or may fail the port. | |
| 1090 */ | |
| 1091 | |
| 1092 /* Check the current state of the port */ | |
| 1093 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 1094 SATA_SUCCESS) { | |
| 1095 rv = EIO; | |
| 1096 break; | |
| 1097 } | |
| 1098 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1099 cport_mutex); | |
| 1100 if (cportinfo->cport_state & | |
| 1101 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) { | |
| 1102 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1103 cport_mutex); | |
| 1104 rv = EIO; | |
| 1105 break; | |
| 1106 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1107 /* Sanity check */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1108 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
|
1109 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
1110 cport_mutex); |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1111 /* No physical port deactivation supported. */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1112 break; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1113 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1114 |
| 1258 | 1115 /* |
| 1116 * set port's dev_state to not ready - this will disable | |
| 1117 * an access to an attached device. | |
| 1118 */ | |
| 1119 cportinfo->cport_state &= ~SATA_STATE_READY; | |
| 1120 | |
| 1121 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1122 sdinfo = cportinfo->cport_devp.cport_sata_drive; | |
| 1123 ASSERT(sdinfo != NULL); | |
| 1124 if ((sdinfo->satadrv_type & | |
| 1125 (SATA_VALID_DEV_TYPE))) { | |
| 1126 /* | |
| 1127 * If a target node exists, try to offline | |
| 1128 * a device and remove target node. | |
| 1129 */ | |
| 1130 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1131 cport)->cport_mutex); | |
| 1132 tdip = sata_get_target_dip(dip, comp_port); | |
| 1133 if (tdip != NULL) { | |
| 1134 /* target node exist */ | |
| 1135 if (ndi_devi_offline(tdip, | |
| 1136 NDI_DEVI_REMOVE) != NDI_SUCCESS) { | |
| 1137 /* | |
| 1138 * Problem | |
| 1139 * A target node remained | |
| 1140 * attached. This happens when | |
| 1141 * the file was open or a node | |
| 1142 * was waiting for resources. | |
| 1143 * Cannot do anything about it. | |
| 1144 */ | |
| 1145 SATA_LOG_D((sata_hba_inst, | |
| 1146 CE_WARN, | |
| 1147 "sata_hba_ioctl: " | |
| 1148 "disconnect: cannot " | |
| 1149 "remove target node!!!")); | |
| 1150 } | |
| 1151 } | |
| 1152 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1153 cport)->cport_mutex); | |
| 1154 /* | |
| 1155 * Remove and release sata_drive_info | |
| 1156 * structure. | |
| 1157 */ | |
| 1158 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != | |
| 1159 NULL) { | |
| 1160 SATA_CPORTINFO_DRV_INFO(cportinfo) = | |
| 1161 NULL; | |
| 1162 (void) kmem_free((void *)sdinfo, | |
| 1163 sizeof (sata_drive_info_t)); | |
| 1164 cportinfo->cport_dev_type = | |
| 1165 SATA_DTYPE_NONE; | |
| 1166 } | |
| 1167 } | |
| 1168 /* | |
| 1169 * 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
|
1170 * Put PMult handling code here, when PMult is |
| 1258 | 1171 * supported. |
| 1172 */ | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1173 |
| 1258 | 1174 } |
| 1175 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1176 /* Just ask HBA driver to deactivate port */ | |
| 1177 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1178 | |
| 1179 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) | |
| 1180 (dip, &sata_device); | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1181 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1182 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1183 * 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
|
1184 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1185 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1186 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1187 &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
|
1188 |
| 1258 | 1189 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1190 cport_mutex); | |
| 1191 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1192 | |
| 1193 if (rval != SATA_SUCCESS) { | |
| 1194 /* | |
| 1195 * Port deactivation failure - do not | |
| 1196 * change port state unless the state | |
| 1197 * returned by HBA indicates a port failure. | |
| 1198 */ | |
| 1199 if (sata_device.satadev_state & SATA_PSTATE_FAILED) | |
| 1200 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 1201 rv = EIO; | |
| 1202 } else { | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1203 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1204 * 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
|
1205 * 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
|
1206 * the port is activated again. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1207 */ |
| 1258 | 1208 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; |
| 1209 } | |
| 1210 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1211 break; | |
| 1212 | |
| 1213 case DEVCTL_AP_UNCONFIGURE: | |
| 1214 | |
| 1215 /* | |
| 1216 * The unconfigure operation uses generic nexus operation to | |
| 1217 * offline a device. It leaves a target device node attached. | |
| 1218 * and obviously sata_drive_info attached as well, because | |
| 1219 * from the hardware point of view nothing has changed. | |
| 1220 */ | |
| 1221 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { | |
| 1222 | |
| 1223 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != | |
| 1224 NDI_SUCCESS) { | |
| 1225 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1226 "sata_hba_ioctl: unconfigure: " | |
| 1227 "failed to unconfigure " | |
| 1228 "device at cport %d", cport)); | |
| 1229 rv = EIO; | |
| 1230 } | |
| 1231 /* | |
| 1232 * The target node devi_state should be marked with | |
| 1233 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). | |
| 1234 * This would be the indication for cfgadm that | |
| 1235 * the AP node occupant state is 'unconfigured'. | |
| 1236 */ | |
| 1237 | |
| 1238 } else { | |
| 1239 /* | |
| 1240 * This would indicate a failure on the part of cfgadm | |
| 1241 * to detect correct state of the node prior to this | |
| 1242 * call - one cannot unconfigure non-existing device. | |
| 1243 */ | |
| 1244 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1245 "sata_hba_ioctl: unconfigure: " | |
| 1246 "attempt to unconfigure non-existing device " | |
| 1247 "at cport %d", cport)); | |
| 1248 rv = ENXIO; | |
| 1249 } | |
| 1250 | |
| 1251 break; | |
| 1252 | |
| 1253 case DEVCTL_AP_CONNECT: | |
| 1254 { | |
| 1255 /* | |
| 1256 * The sata cfgadm pluging will invoke this operation only if | |
| 1257 * port was found in the disconnect state (failed state | |
| 1258 * is also treated as the disconnected state). | |
| 1259 * DEVCTL_AP_CONNECT would invoke | |
| 1260 * sata_hba_inst->satahba_tran-> | |
| 1261 * sata_tran_hotplug_ops->sata_tran_port_activate(). | |
| 1262 * If successful and a device is found attached to the port, | |
| 1263 * the initialization sequence is executed to attach | |
| 1264 * a device structure to a port structure. The device is not | |
| 1265 * set in configured state (system-wise) by this operation. | |
| 1266 * The state of the port and a device would be set | |
| 1267 * appropriately. | |
| 1268 * | |
| 1269 * Note, that activating the port may generate link events, | |
| 1270 * so is is important that following processing and the | |
| 1271 * event processing does not interfere with each other! | |
| 1272 * | |
| 1273 * This operation may remove port failed state and will | |
| 1274 * try to make port active and in good standing. | |
| 1275 */ | |
| 1276 | |
| 1277 /* We only care about host sata cport for now */ | |
| 1278 | |
| 1279 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { | |
| 1280 /* Just let HBA driver to activate port */ | |
| 1281 | |
| 1282 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 1283 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1284 /* | |
| 1285 * Port activation failure. | |
| 1286 */ | |
| 1287 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1288 cport)->cport_mutex); | |
| 1289 sata_update_port_info(sata_hba_inst, | |
| 1290 &sata_device); | |
| 1291 if (sata_device.satadev_state & | |
| 1292 SATA_PSTATE_FAILED) { | |
| 1293 cportinfo->cport_state = | |
| 1294 SATA_PSTATE_FAILED; | |
| 1295 } | |
| 1296 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1297 cport)->cport_mutex); | |
| 1298 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1299 "sata_hba_ioctl: connect: " | |
| 1300 "failed to activate SATA cport %d", | |
| 1301 cport)); | |
| 1302 rv = EIO; | |
| 1303 break; | |
| 1304 } | |
| 1305 } | |
| 1306 /* Virgin port state - will be updated by the port re-probe. */ | |
| 1307 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1308 cport)->cport_mutex); | |
| 1309 cportinfo->cport_state = 0; | |
| 1310 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1311 cport)->cport_mutex); | |
| 1312 | |
| 1313 if (sata_reprobe_port(sata_hba_inst, &sata_device) == | |
| 1314 SATA_FAILURE) | |
| 1315 rv = EIO; | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1316 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1317 * 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
|
1318 * without the hint |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1319 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1320 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1321 &sata_device.satadev_addr, SE_NO_HINT); |
| 1258 | 1322 /* |
| 1323 * If there is a device attached to the port, emit | |
| 1324 * a message. | |
| 1325 */ | |
| 1326 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1327 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
|
1328 "SATA device detected at port %d", cport); |
| 1258 | 1329 } |
| 1330 break; | |
| 1331 } | |
| 1332 | |
| 1333 case DEVCTL_AP_CONFIGURE: | |
| 1334 { | |
| 1335 boolean_t target = TRUE; | |
| 1336 | |
| 1337 /* | |
| 1338 * A port may be in an active or shutdown state. | |
| 1339 * If port is in a failed state, operation is aborted - one | |
| 1340 * has to use explicit connect or port activate request | |
| 1341 * to try to get a port into non-failed mode. | |
| 1342 * | |
| 1343 * If a port is in a shutdown state, arbitrarily invoke | |
| 1344 * sata_tran_port_activate() prior to any other operation. | |
| 1345 * | |
| 1346 * Verify that port state is READY and there is a device | |
| 1347 * of a supported type attached to this port. | |
| 1348 * If target node exists, a device was most likely offlined. | |
| 1349 * If target node does not exist, create a target node an | |
| 1350 * attempt to online it. | |
| 1351 * * | |
| 1352 * NO PMult or devices beyond PMult are supported yet. | |
| 1353 */ | |
| 1354 | |
| 1355 /* We only care about host controller's sata cport for now. */ | |
| 1356 if (cportinfo->cport_state & SATA_PSTATE_FAILED) { | |
| 1357 rv = ENXIO; | |
| 1358 break; | |
| 1359 } | |
| 1360 /* Check the current state of the port */ | |
| 1361 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1362 | |
| 1363 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 1364 (dip, &sata_device); | |
| 1365 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1366 cport_mutex); | |
| 1367 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1368 if (rval != SATA_SUCCESS || | |
| 1369 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { | |
| 1370 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 1371 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1372 cport_mutex); | |
| 1373 rv = EIO; | |
| 1374 break; | |
| 1375 } | |
| 1376 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
|
1377 target = FALSE; |
| 1258 | 1378 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1379 cport_mutex); | |
| 1380 | |
| 1381 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { | |
| 1382 /* Just let HBA driver to activate port */ | |
| 1383 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 1384 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1385 /* | |
| 1386 * Port activation failure - do not | |
| 1387 * change port state unless the state | |
| 1388 * returned by HBA indicates a port | |
| 1389 * failure. | |
| 1390 */ | |
| 1391 mutex_enter(&SATA_CPORT_INFO( | |
| 1392 sata_hba_inst, cport)->cport_mutex); | |
| 1393 sata_update_port_info(sata_hba_inst, | |
| 1394 &sata_device); | |
| 1395 if (sata_device.satadev_state & | |
| 1396 SATA_PSTATE_FAILED) { | |
| 1397 cportinfo->cport_state = | |
| 1398 SATA_PSTATE_FAILED; | |
| 1399 } | |
| 1400 mutex_exit(&SATA_CPORT_INFO( | |
| 1401 sata_hba_inst, cport)->cport_mutex); | |
| 1402 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1403 "sata_hba_ioctl: configure: " | |
| 1404 "failed to activate SATA cport %d", | |
| 1405 cport)); | |
| 1406 rv = EIO; | |
| 1407 break; | |
| 1408 } | |
| 1409 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1410 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1411 * 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
|
1412 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1413 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1414 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1415 &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
|
1416 |
| 1258 | 1417 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1418 cport_mutex); | |
| 1419 /* Virgin port state */ | |
| 1420 cportinfo->cport_state = 0; | |
| 1421 } | |
| 1422 /* | |
| 1423 * Always reprobe port, to get current device info. | |
| 1424 */ | |
| 1425 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1426 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 1427 SATA_SUCCESS) { | |
| 1428 rv = EIO; | |
| 1429 break; | |
| 1430 } | |
| 1431 if (target == FALSE && | |
| 1432 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1433 /* | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1434 * 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
|
1435 * to active one with device attached. |
| 1258 | 1436 */ |
| 1437 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
|
1438 "SATA device detected at port %d", |
| 1258 | 1439 cport); |
| 1440 } | |
| 1441 | |
| 1442 /* | |
| 1443 * This is where real configure starts. | |
| 1444 * Change following check for PMult support. | |
| 1445 */ | |
| 1446 if (!(sata_device.satadev_type & SATA_VALID_DEV_TYPE)) { | |
| 1447 /* No device to configure */ | |
| 1448 rv = ENXIO; /* No device to configure */ | |
| 1449 break; | |
| 1450 } | |
| 1451 | |
| 1452 /* | |
| 1453 * Here we may have a device in reset condition, | |
| 1454 * but because we are just configuring it, there is | |
| 1455 * no need to process the reset other than just | |
| 1456 * to clear device reset condition in the HBA driver. | |
| 1457 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will | |
| 1458 * cause a first command sent the HBA driver with the request | |
| 1459 * to clear device reset condition. | |
| 1460 */ | |
| 1461 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1462 cport_mutex); | |
| 1463 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 1464 if (sdinfo == NULL) { | |
| 1465 rv = ENXIO; | |
| 1466 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1467 cport_mutex); | |
| 1468 break; | |
| 1469 } | |
| 1470 if (sdinfo->satadrv_event_flags & | |
| 1471 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) | |
| 1472 sdinfo->satadrv_event_flags = 0; | |
| 1473 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 1474 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1475 | |
| 1476 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { | |
| 1477 /* target node still exists */ | |
| 1478 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { | |
| 1479 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1480 "sata_hba_ioctl: configure: " | |
| 1481 "onlining device at cport %d failed", | |
| 1482 cport)); | |
| 1483 rv = EIO; | |
| 1484 break; | |
| 1485 } | |
| 1486 } else { | |
| 1487 /* | |
| 1488 * No target node - need to create a new target node. | |
| 1489 */ | |
| 1490 tdip = sata_create_target_node(dip, sata_hba_inst, | |
| 1491 &sata_device.satadev_addr); | |
| 1492 if (tdip == NULL) { | |
| 1493 /* configure failed */ | |
| 1494 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1495 "sata_hba_ioctl: configure: " | |
| 1496 "configuring device at cport %d " | |
| 1497 "failed", cport)); | |
| 1498 rv = EIO; | |
| 1499 break; | |
| 1500 } | |
| 1501 } | |
| 1502 | |
| 1503 break; | |
| 1504 } | |
| 1505 | |
| 1506 case DEVCTL_AP_GETSTATE: | |
| 1507 | |
| 1508 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); | |
| 1509 | |
| 1510 ap_state.ap_last_change = (time_t)-1; | |
| 1511 ap_state.ap_error_code = 0; | |
| 1512 ap_state.ap_in_transition = 0; | |
| 1513 | |
| 1514 /* Copy the return AP-state information to the user space */ | |
| 1515 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { | |
| 1516 rv = EFAULT; | |
| 1517 } | |
| 1518 break; | |
| 1519 | |
| 1520 case DEVCTL_AP_CONTROL: | |
| 1521 { | |
| 1522 /* | |
| 1523 * Generic devctl for hardware specific functionality | |
| 1524 */ | |
| 1525 sata_ioctl_data_t ioc; | |
| 1526 | |
| 1527 ASSERT(dcp == NULL); | |
| 1528 | |
| 1529 /* Copy in user ioctl data first */ | |
| 1530 #ifdef _MULTI_DATAMODEL | |
| 1531 if (ddi_model_convert_from(mode & FMODELS) == | |
| 1532 DDI_MODEL_ILP32) { | |
| 1533 | |
| 1534 sata_ioctl_data_32_t ioc32; | |
| 1535 | |
| 1536 if (ddi_copyin((void *)arg, (void *)&ioc32, | |
| 1537 sizeof (ioc32), mode) != 0) { | |
| 1538 rv = EFAULT; | |
| 1539 break; | |
| 1540 } | |
| 1541 ioc.cmd = (uint_t)ioc32.cmd; | |
| 1542 ioc.port = (uint_t)ioc32.port; | |
| 1543 ioc.get_size = (uint_t)ioc32.get_size; | |
| 1544 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; | |
| 1545 ioc.bufsiz = (uint_t)ioc32.bufsiz; | |
| 1546 ioc.misc_arg = (uint_t)ioc32.misc_arg; | |
| 1547 } else | |
| 1548 #endif /* _MULTI_DATAMODEL */ | |
| 1549 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), | |
| 1550 mode) != 0) { | |
| 1551 return (EFAULT); | |
| 1552 } | |
| 1553 | |
| 1554 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 1555 "sata_hba_ioctl: DEVCTL_AP_CONTROL " | |
| 1556 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); | |
| 1557 | |
| 1558 /* | |
| 1559 * To avoid BE/LE and 32/64 issues, a get_size always returns | |
| 1560 * a 32-bit number. | |
| 1561 */ | |
| 1562 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { | |
| 1563 return (EINVAL); | |
| 1564 } | |
| 1565 /* validate address */ | |
| 1566 cport = SCSI_TO_SATA_CPORT(ioc.port); | |
| 1567 pmport = SCSI_TO_SATA_PMPORT(ioc.port); | |
| 1568 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); | |
| 1569 | |
| 1570 /* Override address qualifier - handle cport only for now */ | |
| 1571 qual = SATA_ADDR_CPORT; | |
| 1572 | |
| 1573 if (sata_validate_sata_address(sata_hba_inst, cport, | |
| 1574 pmport, qual) != 0) | |
| 1575 return (EINVAL); | |
| 1576 | |
| 1577 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 1578 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1579 cport_mutex); | |
| 1580 /* Is the port locked by event processing daemon ? */ | |
| 1581 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { | |
| 1582 /* | |
| 1583 * Cannot process ioctl request now. Come back later | |
| 1584 */ | |
| 1585 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1586 cport_mutex); | |
| 1587 return (EBUSY); | |
| 1588 } | |
| 1589 /* Block event processing for this port */ | |
| 1590 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; | |
| 1591 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 1592 | |
| 1593 | |
| 1594 sata_device.satadev_addr.cport = cport; | |
| 1595 sata_device.satadev_addr.pmport = pmport; | |
| 1596 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 1597 | |
| 1598 switch (ioc.cmd) { | |
| 1599 | |
| 1600 case SATA_CFGA_RESET_PORT: | |
| 1601 /* | |
| 1602 * There is no protection here for configured | |
| 1603 * device. | |
| 1604 */ | |
| 1605 | |
| 1606 /* Sanity check */ | |
| 1607 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1608 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1609 "sata_hba_ioctl: " | |
| 1610 "sata_hba_tran missing required " | |
| 1611 "function sata_tran_reset_dport")); | |
| 1612 rv = EINVAL; | |
| 1613 break; | |
| 1614 } | |
| 1615 | |
| 1616 /* handle cport only for now */ | |
| 1617 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1618 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1619 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1620 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1621 "sata_hba_ioctl: reset port: " | |
| 1622 "failed cport %d pmport %d", | |
| 1623 cport, pmport)); | |
| 1624 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1625 cport)->cport_mutex); | |
| 1626 sata_update_port_info(sata_hba_inst, | |
| 1627 &sata_device); | |
| 1628 SATA_CPORT_STATE(sata_hba_inst, cport) = | |
| 1629 SATA_PSTATE_FAILED; | |
| 1630 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1631 cport)->cport_mutex); | |
| 1632 rv = EIO; | |
| 1633 } | |
| 1634 /* | |
| 1635 * Since the port was reset, it should be probed and | |
| 1636 * attached device reinitialized. At this point the | |
| 1637 * port state is unknown - it's state is HBA-specific. | |
| 1638 * Re-probe port to get its state. | |
| 1639 */ | |
| 1640 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 1641 SATA_SUCCESS) { | |
| 1642 rv = EIO; | |
| 1643 break; | |
| 1644 } | |
| 1645 break; | |
| 1646 | |
| 1647 case SATA_CFGA_RESET_DEVICE: | |
| 1648 /* | |
| 1649 * There is no protection here for configured | |
| 1650 * device. | |
| 1651 */ | |
| 1652 | |
| 1653 /* Sanity check */ | |
| 1654 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1655 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1656 "sata_hba_ioctl: " | |
| 1657 "sata_hba_tran missing required " | |
| 1658 "function sata_tran_reset_dport")); | |
| 1659 rv = EINVAL; | |
| 1660 break; | |
| 1661 } | |
| 1662 | |
| 1663 /* handle only device attached to cports, for now */ | |
| 1664 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1665 | |
| 1666 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1667 cport_mutex); | |
| 1668 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 1669 &sata_device); | |
| 1670 if (sdinfo == NULL) { | |
| 1671 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1672 cport)->cport_mutex); | |
| 1673 rv = EINVAL; | |
| 1674 break; | |
| 1675 } | |
| 1676 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1677 cport_mutex); | |
| 1678 | |
| 1679 /* only handle cport for now */ | |
| 1680 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1681 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1682 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1683 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1684 "sata_hba_ioctl: reset device: failed " | |
| 1685 "cport %d pmport %d", cport, pmport)); | |
| 1686 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1687 cport)->cport_mutex); | |
| 1688 sata_update_port_info(sata_hba_inst, | |
| 1689 &sata_device); | |
| 1690 /* | |
| 1691 * Device info structure remains | |
| 1692 * attached. Another device reset or | |
| 1693 * port disconnect/connect and re-probing is | |
| 1694 * needed to change it's state | |
| 1695 */ | |
| 1696 sdinfo->satadrv_state &= ~SATA_STATE_READY; | |
| 1697 sdinfo->satadrv_state |= | |
| 1698 SATA_DSTATE_FAILED; | |
| 1699 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1700 cport)->cport_mutex); | |
| 1701 rv = EIO; | |
| 1702 } | |
| 1703 /* | |
| 1704 * Since the device was reset, we expect reset event | |
| 1705 * to be reported and processed. | |
| 1706 */ | |
| 1707 break; | |
| 1708 | |
| 1709 case SATA_CFGA_RESET_ALL: | |
| 1710 { | |
| 1711 int tcport; | |
| 1712 | |
| 1713 /* | |
| 1714 * There is no protection here for configured | |
| 1715 * devices. | |
| 1716 */ | |
| 1717 /* Sanity check */ | |
| 1718 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { | |
| 1719 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1720 "sata_hba_ioctl: " | |
| 1721 "sata_hba_tran missing required " | |
| 1722 "function sata_tran_reset_dport")); | |
| 1723 rv = EINVAL; | |
| 1724 break; | |
| 1725 } | |
| 1726 | |
| 1727 /* | |
| 1728 * Need to lock all ports, not just one. | |
| 1729 * If any port is locked by event processing, fail | |
| 1730 * the whole operation. | |
| 1731 * One port is already locked, but for simplicity | |
| 1732 * lock it again. | |
| 1733 */ | |
| 1734 for (tcport = 0; | |
| 1735 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1736 tcport++) { | |
| 1737 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1738 tcport)->cport_mutex); | |
| 1739 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> | |
| 1740 cport_event_flags) & | |
| 1741 SATA_EVNT_LOCK_PORT_BUSY) != 0) { | |
| 1742 rv = EBUSY; | |
| 1743 mutex_exit( | |
| 1744 &SATA_CPORT_INFO(sata_hba_inst, | |
| 1745 tcport)->cport_mutex); | |
| 1746 break; | |
| 1747 } else { | |
| 1748 SATA_CPORT_INFO(sata_hba_inst, | |
| 1749 tcport)->cport_event_flags |= | |
| 1750 SATA_APCTL_LOCK_PORT_BUSY; | |
| 1751 } | |
| 1752 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1753 tcport)->cport_mutex); | |
| 1754 } | |
| 1755 | |
| 1756 if (rv == 0) { | |
| 1757 /* | |
| 1758 * All cports successfully locked. | |
| 1759 * Reset main SATA controller only for now - | |
| 1760 * no PMult. | |
| 1761 */ | |
| 1762 sata_device.satadev_addr.qual = | |
| 1763 SATA_ADDR_CNTRL; | |
| 1764 | |
| 1765 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 1766 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1767 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1768 "sata_hba_ioctl: reset controller " | |
| 1769 "failed")); | |
| 1770 rv = EIO; | |
| 1771 } | |
| 1772 | |
| 1773 /* | |
| 1774 * Since ports were reset, they should be | |
| 1775 * re-probed and attached devices | |
| 1776 * reinitialized. | |
| 1777 * At this point port states are unknown, | |
| 1778 * Re-probe ports to get their state - | |
| 1779 * cports only for now. | |
| 1780 */ | |
| 1781 for (tcport = 0; | |
| 1782 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1783 tcport++) { | |
| 1784 sata_device.satadev_addr.cport = | |
| 1785 tcport; | |
| 1786 sata_device.satadev_addr.qual = | |
| 1787 SATA_ADDR_CPORT; | |
| 1788 | |
| 1789 if (sata_reprobe_port(sata_hba_inst, | |
| 1790 &sata_device) != SATA_SUCCESS) | |
| 1791 rv = EIO; | |
| 1792 | |
| 1793 } | |
| 1794 } | |
| 1795 /* | |
| 1796 * Unlock all ports | |
| 1797 */ | |
| 1798 for (tcport = 0; | |
| 1799 tcport < SATA_NUM_CPORTS(sata_hba_inst); | |
| 1800 tcport++) { | |
| 1801 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1802 tcport)->cport_mutex); | |
| 1803 SATA_CPORT_INFO(sata_hba_inst, tcport)-> | |
| 1804 cport_event_flags &= | |
| 1805 ~SATA_APCTL_LOCK_PORT_BUSY; | |
| 1806 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1807 tcport)->cport_mutex); | |
| 1808 } | |
| 1809 | |
| 1810 /* | |
| 1811 * This operation returns EFAULT if either reset | |
| 1812 * controller failed or a re-probbing of any ports | |
| 1813 * failed. | |
| 1814 * We return here, because common return is for | |
| 1815 * a single cport operation. | |
| 1816 */ | |
| 1817 return (rv); | |
| 1818 } | |
| 1819 | |
| 1820 case SATA_CFGA_PORT_DEACTIVATE: | |
| 1821 /* Sanity check */ | |
| 1822 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { | |
| 1823 rv = ENOTSUP; | |
| 1824 break; | |
| 1825 } | |
| 1826 /* | |
| 1827 * Arbitrarily unconfigure attached device, if any. | |
| 1828 * Even if the unconfigure fails, proceed with the | |
| 1829 * port deactivation. | |
| 1830 */ | |
| 1831 | |
| 1832 /* Handle only device attached to cports, for now */ | |
| 1833 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 1834 | |
| 1835 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1836 cport_mutex); | |
| 1837 cportinfo->cport_state &= ~SATA_STATE_READY; | |
| 1838 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 1839 /* | |
| 1840 * Handle only device attached to cports, | |
| 1841 * for now | |
| 1842 */ | |
| 1843 sata_device.satadev_addr.qual = | |
| 1844 SATA_ADDR_DCPORT; | |
| 1845 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 1846 &sata_device); | |
| 1847 if (sdinfo != NULL && | |
| 1848 (sdinfo->satadrv_type & | |
| 1849 SATA_VALID_DEV_TYPE)) { | |
| 1850 /* | |
| 1851 * If a target node exists, try to | |
| 1852 * offline a device and remove target | |
| 1853 * node. | |
| 1854 */ | |
| 1855 mutex_exit(&SATA_CPORT_INFO( | |
| 1856 sata_hba_inst, cport)->cport_mutex); | |
| 1857 tdip = sata_get_target_dip(dip, cport); | |
| 1858 if (tdip != NULL) { | |
| 1859 /* target node exist */ | |
| 1860 SATADBG1(SATA_DBG_IOCTL_IF, | |
| 1861 sata_hba_inst, | |
| 1862 "sata_hba_ioctl: " | |
| 1863 "port deactivate: " | |
| 1864 "target node exists.", | |
| 1865 NULL); | |
| 1866 | |
| 1867 if (ndi_devi_offline(tdip, | |
| 1868 NDI_UNCONFIG) != | |
| 1869 NDI_SUCCESS) { | |
| 1870 SATA_LOG_D(( | |
| 1871 sata_hba_inst, | |
| 1872 CE_WARN, | |
| 1873 "sata_hba_ioctl:" | |
| 1874 "port deactivate: " | |
| 1875 "failed to " | |
| 1876 "unconfigure " | |
| 1877 "device at cport " | |
| 1878 "%d", cport)); | |
| 1879 } | |
| 1880 if (ndi_devi_offline(tdip, | |
| 1881 NDI_DEVI_REMOVE) != | |
| 1882 NDI_SUCCESS) { | |
| 1883 /* | |
| 1884 * Problem; | |
| 1885 * target node remained | |
| 1886 * attached. | |
| 1887 * Too bad... | |
| 1888 */ | |
| 1889 SATA_LOG_D(( | |
| 1890 sata_hba_inst, | |
| 1891 CE_WARN, | |
| 1892 "sata_hba_ioctl: " | |
| 1893 "port deactivate: " | |
| 1894 "failed to " | |
| 1895 "unconfigure " | |
| 1896 "device at " | |
| 1897 "cport %d", | |
| 1898 cport)); | |
| 1899 } | |
| 1900 } | |
| 1901 mutex_enter(&SATA_CPORT_INFO( | |
| 1902 sata_hba_inst, cport)->cport_mutex); | |
| 1903 /* | |
| 1904 * In any case, | |
| 1905 * remove and release sata_drive_info | |
| 1906 * structure. | |
| 1907 * (cport attached device ony, for now) | |
| 1908 */ | |
| 1909 SATA_CPORTINFO_DRV_INFO(cportinfo) = | |
| 1910 NULL; | |
| 1911 (void) kmem_free((void *)sdinfo, | |
| 1912 sizeof (sata_drive_info_t)); | |
| 1913 cportinfo->cport_dev_type = | |
| 1914 SATA_DTYPE_NONE; | |
| 1915 } | |
| 1916 /* | |
| 1917 * Note: PMult info requires different | |
| 1918 * handling. This comment is a placeholder for | |
| 1919 * a code handling PMult, to be implemented | |
| 1920 * in phase 2. | |
| 1921 */ | |
| 1922 } | |
| 1923 cportinfo->cport_state &= ~(SATA_STATE_PROBED | | |
| 1924 SATA_STATE_PROBING); | |
| 1925 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1926 cport_mutex); | |
| 1927 /* handle cport only for now */ | |
| 1928 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1929 /* Just let HBA driver to deactivate port */ | |
| 1930 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) | |
| 1931 (dip, &sata_device); | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1932 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1933 * Generate sysevent - |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1934 * 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
|
1935 * without the hint |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1936 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1937 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
1938 &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
|
1939 |
| 1258 | 1940 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> |
| 1941 cport_mutex); | |
| 1942 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 1943 if (rval != SATA_SUCCESS) { | |
| 1944 /* | |
| 1945 * Port deactivation failure - do not | |
| 1946 * change port state unless the state | |
| 1947 * returned by HBA indicates a port failure. | |
| 1948 */ | |
| 1949 if (sata_device.satadev_state & | |
| 1950 SATA_PSTATE_FAILED) { | |
| 1951 SATA_CPORT_STATE(sata_hba_inst, | |
| 1952 cport) = SATA_PSTATE_FAILED; | |
| 1953 } | |
| 1954 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 1955 "sata_hba_ioctl: port deactivate: " | |
| 1956 "cannot deactivate SATA cport %d", | |
| 1957 cport)); | |
| 1958 rv = EIO; | |
| 1959 } else { | |
| 1960 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; | |
| 1961 } | |
| 1962 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 1963 cport_mutex); | |
| 1964 | |
| 1965 break; | |
| 1966 | |
| 1967 case SATA_CFGA_PORT_ACTIVATE: | |
| 1968 { | |
| 1969 boolean_t dev_existed = TRUE; | |
| 1970 | |
| 1971 /* Sanity check */ | |
| 1972 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { | |
| 1973 rv = ENOTSUP; | |
| 1974 break; | |
| 1975 } | |
| 1976 /* handle cport only for now */ | |
| 1977 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || | |
| 1978 cportinfo->cport_dev_type == SATA_DTYPE_NONE) | |
| 1979 dev_existed = FALSE; | |
| 1980 | |
| 1981 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 1982 /* Just let HBA driver to activate port */ | |
| 1983 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) | |
| 1984 (dip, &sata_device) != SATA_SUCCESS) { | |
| 1985 /* | |
| 1986 * Port activation failure - do not | |
| 1987 * change port state unless the state | |
| 1988 * returned by HBA indicates a port failure. | |
| 1989 */ | |
| 1990 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 1991 cport)->cport_mutex); | |
| 1992 sata_update_port_info(sata_hba_inst, | |
| 1993 &sata_device); | |
| 1994 if (sata_device.satadev_state & | |
| 1995 SATA_PSTATE_FAILED) { | |
| 1996 SATA_CPORT_STATE(sata_hba_inst, | |
| 1997 cport) = SATA_PSTATE_FAILED; | |
| 1998 } | |
| 1999 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2000 cport)->cport_mutex); | |
| 2001 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2002 "sata_hba_ioctl: port activate: " | |
| 2003 "cannot activate SATA cport %d", | |
| 2004 cport)); | |
| 2005 rv = EIO; | |
| 2006 break; | |
| 2007 } | |
| 2008 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2009 cport_mutex); | |
| 2010 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; | |
| 2011 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2012 cport_mutex); | |
| 2013 | |
| 2014 /* | |
| 2015 * Re-probe port to find its current state and | |
| 2016 * possibly attached device. | |
| 2017 * Port re-probing may change the cportinfo device | |
| 2018 * type if device is found attached. | |
| 2019 * If port probing failed, the device type would be | |
| 2020 * set to SATA_DTYPE_NONE. | |
| 2021 */ | |
| 2022 (void) sata_reprobe_port(sata_hba_inst, &sata_device); | |
| 2023 | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2024 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2025 * Generate sysevent - |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2026 * 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
|
2027 * without the hint. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2028 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2029 sata_gen_sysevent(sata_hba_inst, |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
2030 &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
|
2031 |
| 1258 | 2032 if (dev_existed == FALSE && |
| 2033 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 2034 /* | |
| 2035 * That's the transition from "inactive" port | |
| 2036 * state or active port without a device | |
| 2037 * attached to the active port state with | |
| 2038 * a device attached. | |
| 2039 */ | |
| 2040 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
|
2041 "SATA device detected at port %d", cport); |
| 1258 | 2042 } |
| 2043 | |
| 2044 break; | |
| 2045 } | |
| 2046 | |
| 2047 case SATA_CFGA_PORT_SELF_TEST: | |
| 2048 | |
| 2049 /* Sanity check */ | |
| 2050 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) { | |
| 2051 rv = ENOTSUP; | |
| 2052 break; | |
| 2053 } | |
| 2054 /* | |
| 2055 * There is no protection here for a configured | |
| 2056 * device attached to this port. | |
| 2057 */ | |
| 2058 | |
| 2059 /* only handle cport for now */ | |
| 2060 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 2061 | |
| 2062 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) | |
| 2063 (dip, &sata_device) != SATA_SUCCESS) { | |
| 2064 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2065 "sata_hba_ioctl: port selftest: " | |
| 2066 "failed cport %d pmport %d", | |
| 2067 cport, pmport)); | |
| 2068 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2069 cport)->cport_mutex); | |
| 2070 sata_update_port_info(sata_hba_inst, | |
| 2071 &sata_device); | |
| 2072 SATA_CPORT_STATE(sata_hba_inst, cport) = | |
| 2073 SATA_PSTATE_FAILED; | |
| 2074 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2075 cport)->cport_mutex); | |
| 2076 rv = EIO; | |
| 2077 break; | |
| 2078 } | |
| 2079 /* | |
| 2080 * Since the port was reset, it should be probed and | |
| 2081 * attached device reinitialized. At this point the | |
| 2082 * port state is unknown - it's state is HBA-specific. | |
| 2083 * Force port re-probing to get it into a known state. | |
| 2084 */ | |
| 2085 if (sata_reprobe_port(sata_hba_inst, &sata_device) != | |
| 2086 SATA_SUCCESS) { | |
| 2087 rv = EIO; | |
| 2088 break; | |
| 2089 } | |
| 2090 break; | |
| 2091 | |
| 2092 case SATA_CFGA_GET_DEVICE_PATH: | |
| 2093 { | |
| 2094 char path[MAXPATHLEN]; | |
| 2095 uint32_t size; | |
| 2096 | |
| 2097 (void) strcpy(path, "/devices"); | |
| 2098 if ((tdip = sata_get_target_dip(dip, ioc.port)) == | |
| 2099 NULL) { | |
| 2100 | |
| 2101 /* | |
| 2102 * No such device. | |
| 2103 * If this is a request for a size, do not | |
| 2104 * return EINVAL for non-exisiting target, | |
| 2105 * because cfgadm will indicate a meaningless | |
| 2106 * ioctl failure. | |
| 2107 * If this is a real request for a path, | |
| 2108 * indicate invalid argument. | |
| 2109 */ | |
| 2110 if (!ioc.get_size) { | |
| 2111 rv = EINVAL; | |
| 2112 break; | |
| 2113 } | |
| 2114 } else { | |
| 2115 (void) ddi_pathname(tdip, path + strlen(path)); | |
| 2116 } | |
| 2117 size = strlen(path) + 1; | |
| 2118 | |
| 2119 if (ioc.get_size) { | |
| 2120 if (ddi_copyout((void *)&size, | |
| 2121 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2122 rv = EFAULT; | |
| 2123 } | |
| 2124 } else { | |
| 2125 if (ioc.bufsiz != size) { | |
| 2126 rv = EINVAL; | |
| 2127 } else if (ddi_copyout((void *)&path, | |
| 2128 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2129 rv = EFAULT; | |
| 2130 } | |
| 2131 } | |
| 2132 break; | |
| 2133 } | |
| 2134 | |
| 2135 case SATA_CFGA_GET_AP_TYPE: | |
| 2136 { | |
| 2137 uint32_t type_len; | |
| 2138 const char *ap_type; | |
| 2139 | |
| 2140 /* cport only, no port multiplier support */ | |
| 2141 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { | |
| 2142 case SATA_DTYPE_NONE: | |
| 2143 ap_type = "port"; | |
| 2144 break; | |
| 2145 | |
| 2146 case SATA_DTYPE_ATADISK: | |
| 2147 ap_type = "disk"; | |
| 2148 break; | |
| 2149 | |
| 2150 case SATA_DTYPE_ATAPICD: | |
| 2151 ap_type = "cd/dvd"; | |
| 2152 break; | |
| 2153 | |
| 2154 case SATA_DTYPE_PMULT: | |
| 2155 ap_type = "pmult"; | |
| 2156 break; | |
| 2157 | |
| 2158 case SATA_DTYPE_UNKNOWN: | |
| 2159 ap_type = "unknown"; | |
| 2160 break; | |
| 2161 | |
| 2162 default: | |
| 2163 ap_type = "unsupported"; | |
| 2164 break; | |
| 2165 | |
| 2166 } /* end of dev_type switch */ | |
| 2167 | |
| 2168 type_len = strlen(ap_type) + 1; | |
| 2169 | |
| 2170 if (ioc.get_size) { | |
| 2171 if (ddi_copyout((void *)&type_len, | |
| 2172 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2173 rv = EFAULT; | |
| 2174 break; | |
| 2175 } | |
| 2176 } else { | |
| 2177 if (ioc.bufsiz != type_len) { | |
| 2178 rv = EINVAL; | |
| 2179 break; | |
| 2180 } | |
| 2181 if (ddi_copyout((void *)ap_type, ioc.buf, | |
| 2182 ioc.bufsiz, mode) != 0) { | |
| 2183 rv = EFAULT; | |
| 2184 break; | |
| 2185 } | |
| 2186 } | |
| 2187 | |
| 2188 break; | |
| 2189 } | |
| 2190 | |
| 2191 case SATA_CFGA_GET_MODEL_INFO: | |
| 2192 { | |
| 2193 uint32_t info_len; | |
| 2194 char ap_info[sizeof (sdinfo->satadrv_id.ai_model) + 1]; | |
| 2195 | |
| 2196 /* | |
| 2197 * This operation should return to cfgadm the | |
| 2198 * device model information string | |
| 2199 */ | |
| 2200 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2201 cport_mutex); | |
| 2202 /* only handle device connected to cport for now */ | |
| 2203 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2204 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2205 &sata_device); | |
| 2206 if (sdinfo == NULL) { | |
| 2207 rv = EINVAL; | |
| 2208 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2209 cport)->cport_mutex); | |
| 2210 break; | |
| 2211 } | |
| 2212 bcopy(sdinfo->satadrv_id.ai_model, ap_info, | |
| 2213 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 2214 swab(ap_info, ap_info, | |
| 2215 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 2216 ap_info[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; | |
| 2217 | |
| 2218 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2219 cport_mutex); | |
| 2220 | |
| 2221 info_len = strlen(ap_info) + 1; | |
| 2222 | |
| 2223 if (ioc.get_size) { | |
| 2224 if (ddi_copyout((void *)&info_len, | |
| 2225 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2226 rv = EFAULT; | |
| 2227 break; | |
| 2228 } | |
| 2229 } else { | |
| 2230 if (ioc.bufsiz < info_len) { | |
| 2231 rv = EINVAL; | |
| 2232 break; | |
| 2233 } | |
| 2234 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2235 ioc.bufsiz, mode) != 0) { | |
| 2236 rv = EFAULT; | |
| 2237 break; | |
| 2238 } | |
| 2239 } | |
| 2240 | |
| 2241 break; | |
| 2242 } | |
| 2243 | |
| 2244 case SATA_CFGA_GET_REVFIRMWARE_INFO: | |
| 2245 { | |
| 2246 uint32_t info_len; | |
| 2247 char ap_info[ | |
| 2248 sizeof (sdinfo->satadrv_id.ai_fw) + 1]; | |
| 2249 | |
| 2250 /* | |
| 2251 * This operation should return to cfgadm the | |
| 2252 * device firmware revision information string | |
| 2253 */ | |
| 2254 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2255 cport_mutex); | |
| 2256 /* only handle device connected to cport for now */ | |
| 2257 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2258 | |
| 2259 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2260 &sata_device); | |
| 2261 if (sdinfo == NULL) { | |
| 2262 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2263 cport)->cport_mutex); | |
| 2264 rv = EINVAL; | |
| 2265 break; | |
| 2266 } | |
| 2267 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, | |
| 2268 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 2269 swab(ap_info, ap_info, | |
| 2270 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 2271 ap_info[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; | |
| 2272 | |
| 2273 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2274 cport_mutex); | |
| 2275 | |
| 2276 info_len = strlen(ap_info) + 1; | |
| 2277 | |
| 2278 if (ioc.get_size) { | |
| 2279 if (ddi_copyout((void *)&info_len, | |
| 2280 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2281 rv = EFAULT; | |
| 2282 break; | |
| 2283 } | |
| 2284 } else { | |
| 2285 if (ioc.bufsiz < info_len) { | |
| 2286 rv = EINVAL; | |
| 2287 break; | |
| 2288 } | |
| 2289 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2290 ioc.bufsiz, mode) != 0) { | |
| 2291 rv = EFAULT; | |
| 2292 break; | |
| 2293 } | |
| 2294 } | |
| 2295 | |
| 2296 break; | |
| 2297 } | |
| 2298 | |
| 2299 case SATA_CFGA_GET_SERIALNUMBER_INFO: | |
| 2300 { | |
| 2301 uint32_t info_len; | |
| 2302 char ap_info[ | |
| 2303 sizeof (sdinfo->satadrv_id.ai_drvser) + 1]; | |
| 2304 | |
| 2305 /* | |
| 2306 * This operation should return to cfgadm the | |
| 2307 * device serial number information string | |
| 2308 */ | |
| 2309 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2310 cport_mutex); | |
| 2311 /* only handle device connected to cport for now */ | |
| 2312 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 2313 | |
| 2314 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2315 &sata_device); | |
| 2316 if (sdinfo == NULL) { | |
| 2317 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 2318 cport)->cport_mutex); | |
| 2319 rv = EINVAL; | |
| 2320 break; | |
| 2321 } | |
| 2322 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, | |
| 2323 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 2324 swab(ap_info, ap_info, | |
| 2325 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 2326 ap_info[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; | |
| 2327 | |
| 2328 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> | |
| 2329 cport_mutex); | |
| 2330 | |
| 2331 info_len = strlen(ap_info) + 1; | |
| 2332 | |
| 2333 if (ioc.get_size) { | |
| 2334 if (ddi_copyout((void *)&info_len, | |
| 2335 ioc.buf, ioc.bufsiz, mode) != 0) { | |
| 2336 rv = EFAULT; | |
| 2337 break; | |
| 2338 } | |
| 2339 } else { | |
| 2340 if (ioc.bufsiz < info_len) { | |
| 2341 rv = EINVAL; | |
| 2342 break; | |
| 2343 } | |
| 2344 if (ddi_copyout((void *)ap_info, ioc.buf, | |
| 2345 ioc.bufsiz, mode) != 0) { | |
| 2346 rv = EFAULT; | |
| 2347 break; | |
| 2348 } | |
| 2349 } | |
| 2350 | |
| 2351 break; | |
| 2352 } | |
| 2353 | |
| 2354 default: | |
| 2355 rv = EINVAL; | |
| 2356 break; | |
| 2357 | |
| 2358 } /* End of DEVCTL_AP_CONTROL cmd switch */ | |
| 2359 | |
| 2360 break; | |
| 2361 } | |
| 2362 | |
| 2363 default: | |
| 2364 { | |
| 2365 /* | |
| 2366 * If we got here, we got an IOCTL that SATA HBA Framework | |
| 2367 * does not recognize. Pass ioctl to HBA driver, in case | |
| 2368 * it could process it. | |
| 2369 */ | |
| 2370 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; | |
| 2371 dev_info_t *mydip = SATA_DIP(sata_hba_inst); | |
| 2372 | |
| 2373 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 2374 "IOCTL 0x%2x not supported in SATA framework, " | |
| 2375 "passthrough to HBA", cmd); | |
| 2376 | |
| 2377 if (sata_tran->sata_tran_ioctl == NULL) { | |
| 2378 rv = EINVAL; | |
| 2379 break; | |
| 2380 } | |
| 2381 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); | |
| 2382 if (rval != 0) { | |
| 2383 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, | |
| 2384 "IOCTL 0x%2x failed in HBA", cmd); | |
| 2385 rv = rval; | |
| 2386 } | |
| 2387 break; | |
| 2388 } | |
| 2389 | |
| 2390 } /* End of main IOCTL switch */ | |
| 2391 | |
| 2392 if (dcp) { | |
| 2393 ndi_dc_freehdl(dcp); | |
| 2394 } | |
| 2395 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 2396 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; | |
| 2397 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); | |
| 2398 | |
| 2399 return (rv); | |
| 2400 } | |
| 2401 | |
| 2402 | |
| 2403 | |
| 2404 | |
| 2405 /* ****************** SCSA required entry points *********************** */ | |
| 2406 | |
| 2407 /* | |
| 2408 * Implementation of scsi tran_tgt_init. | |
| 2409 * sata_scsi_tgt_init() initializes scsi_device structure | |
| 2410 * | |
| 2411 * If successful, DDI_SUCCESS is returned. | |
| 2412 * DDI_FAILURE is returned if addressed device does not exist | |
| 2413 */ | |
| 2414 | |
| 2415 static int | |
| 2416 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, | |
| 2417 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) | |
| 2418 { | |
| 2419 #ifndef __lock_lint | |
| 2420 _NOTE(ARGUNUSED(hba_dip)) | |
| 2421 #endif | |
| 2422 sata_device_t sata_device; | |
| 2423 sata_drive_info_t *sdinfo; | |
| 2424 sata_hba_inst_t *sata_hba_inst; | |
| 2425 | |
| 2426 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); | |
| 2427 | |
| 2428 /* Validate scsi device address */ | |
| 2429 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, | |
| 2430 &sata_device) != 0) | |
| 2431 return (DDI_FAILURE); | |
| 2432 | |
| 2433 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2434 sata_device.satadev_addr.cport))); | |
| 2435 | |
| 2436 /* sata_device now contains a valid sata address */ | |
| 2437 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 2438 if (sdinfo == NULL) { | |
| 2439 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2440 sata_device.satadev_addr.cport))); | |
| 2441 return (DDI_FAILURE); | |
| 2442 } | |
| 2443 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { | |
| 2444 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2445 sata_device.satadev_addr.cport))); | |
| 2446 if (ndi_prop_update_string(DDI_DEV_T_NONE, tgt_dip, | |
| 2447 "variant", "atapi") != DDI_PROP_SUCCESS) { | |
| 2448 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2449 "sata_scsi_tgt_init: variant atapi " | |
| 2450 "property could not be created")); | |
| 2451 return (DDI_FAILURE); | |
| 2452 } | |
| 2453 return (DDI_SUCCESS); | |
| 2454 } | |
| 2455 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2456 sata_device.satadev_addr.cport))); | |
| 2457 return (DDI_SUCCESS); | |
| 2458 } | |
| 2459 | |
| 2460 /* | |
| 2461 * Implementation of scsi tran_tgt_probe. | |
| 2462 * Probe target, by calling default scsi routine scsi_hba_probe() | |
| 2463 */ | |
| 2464 static int | |
| 2465 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) | |
| 2466 { | |
| 2467 sata_hba_inst_t *sata_hba_inst = | |
| 2468 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); | |
| 2469 int rval; | |
| 2470 | |
| 2471 rval = scsi_hba_probe(sd, callback); | |
| 2472 | |
| 2473 if (rval == SCSIPROBE_EXISTS) { | |
| 2474 /* | |
| 2475 * Set property "pm-capable" on the target device node, so that | |
| 2476 * the target driver will not try to fetch scsi cycle counters | |
| 2477 * before enabling device power-management. | |
| 2478 */ | |
| 2479 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, | |
| 2480 "pm-capable", 1)) != DDI_PROP_SUCCESS) { | |
| 2481 sata_log(sata_hba_inst, CE_WARN, | |
| 2482 "device at port %d: will not be power-managed ", | |
| 2483 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); | |
| 2484 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2485 "failure updating pm-capable property")); | |
| 2486 } | |
| 2487 } | |
| 2488 return (rval); | |
| 2489 } | |
| 2490 | |
| 2491 /* | |
| 2492 * Implementation of scsi tran_tgt_free. | |
| 2493 * Release all resources allocated for scsi_device | |
| 2494 */ | |
| 2495 static void | |
| 2496 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, | |
| 2497 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) | |
| 2498 { | |
| 2499 #ifndef __lock_lint | |
| 2500 _NOTE(ARGUNUSED(hba_dip)) | |
| 2501 #endif | |
| 2502 sata_device_t sata_device; | |
| 2503 sata_drive_info_t *sdinfo; | |
| 2504 sata_hba_inst_t *sata_hba_inst; | |
| 2505 | |
| 2506 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); | |
| 2507 | |
| 2508 /* Validate scsi device address */ | |
| 2509 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, | |
| 2510 &sata_device) != 0) | |
| 2511 return; | |
| 2512 | |
| 2513 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2514 sata_device.satadev_addr.cport))); | |
| 2515 | |
| 2516 /* sata_device now should contain a valid sata address */ | |
| 2517 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 2518 if (sdinfo == NULL) { | |
| 2519 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2520 sata_device.satadev_addr.cport))); | |
| 2521 return; | |
| 2522 } | |
| 2523 /* | |
| 2524 * We did not allocate any resources in sata_scsi_tgt_init() | |
| 2525 * other than property for ATAPI device, if any | |
| 2526 */ | |
| 2527 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { | |
| 2528 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2529 sata_device.satadev_addr.cport))); | |
| 2530 if (ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "variant") != | |
| 2531 DDI_PROP_SUCCESS) | |
| 2532 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 2533 "sata_scsi_tgt_free: variant atapi " | |
| 2534 "property could not be removed")); | |
| 2535 } else { | |
| 2536 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2537 sata_device.satadev_addr.cport))); | |
| 2538 } | |
| 2539 } | |
| 2540 | |
| 2541 /* | |
| 2542 * Implementation of scsi tran_init_pkt | |
| 2543 * Upon successful return, scsi pkt buffer has DMA resources allocated. | |
| 2544 * | |
| 2545 * It seems that we should always allocate pkt, even if the address is | |
| 2546 * for non-existing device - just use some default for dma_attr. | |
| 2547 * The reason is that there is no way to communicate this to a caller here. | |
| 2548 * Subsequent call to sata_scsi_start may fail appropriately. | |
| 2549 * Simply returning NULL does not seem to discourage a target driver... | |
| 2550 * | |
| 2551 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. | |
| 2552 */ | |
| 2553 static struct scsi_pkt * | |
| 2554 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, | |
| 2555 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, | |
| 2556 int (*callback)(caddr_t), caddr_t arg) | |
| 2557 { | |
| 2558 sata_hba_inst_t *sata_hba_inst = | |
| 2559 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2560 dev_info_t *dip = SATA_DIP(sata_hba_inst); | |
| 2561 sata_device_t sata_device; | |
| 2562 sata_drive_info_t *sdinfo; | |
| 2563 sata_pkt_txlate_t *spx; | |
| 2564 ddi_dma_attr_t cur_dma_attr; | |
| 2565 int rval; | |
| 2566 boolean_t new_pkt = TRUE; | |
| 2567 | |
| 2568 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); | |
| 2569 | |
| 2570 /* | |
| 2571 * We need to translate the address, even if it could be | |
| 2572 * a bogus one, for a non-existing device | |
| 2573 */ | |
| 2574 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); | |
| 2575 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 2576 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); | |
| 2577 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 2578 | |
| 2579 if (pkt == NULL) { | |
| 2580 /* | |
| 2581 * Have to allocate a brand new scsi packet. | |
| 2582 * We need to operate with auto request sense enabled. | |
| 2583 */ | |
| 2584 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, | |
| 2585 MAX(statuslen, sizeof (struct scsi_arq_status)), | |
| 2586 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); | |
| 2587 | |
| 2588 if (pkt == NULL) | |
| 2589 return (NULL); | |
| 2590 | |
| 2591 /* Fill scsi packet structure */ | |
| 2592 pkt->pkt_comp = (void (*)())NULL; | |
| 2593 pkt->pkt_time = 0; | |
| 2594 pkt->pkt_resid = 0; | |
| 2595 pkt->pkt_statistics = 0; | |
| 2596 pkt->pkt_reason = 0; | |
| 2597 | |
| 2598 /* | |
| 2599 * pkt_hba_private will point to sata pkt txlate structure | |
| 2600 */ | |
| 2601 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2602 bzero(spx, sizeof (sata_pkt_txlate_t)); | |
| 2603 | |
| 2604 spx->txlt_scsi_pkt = pkt; | |
| 2605 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 2606 | |
| 2607 /* Allocate sata_pkt */ | |
| 2608 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); | |
| 2609 if (spx->txlt_sata_pkt == NULL) { | |
| 2610 /* Could not allocate sata pkt */ | |
| 2611 scsi_hba_pkt_free(ap, pkt); | |
| 2612 return (NULL); | |
| 2613 } | |
| 2614 /* Set sata address */ | |
| 2615 spx->txlt_sata_pkt->satapkt_device = sata_device; | |
| 2616 | |
| 2617 if ((bp == NULL) || (bp->b_bcount == 0)) | |
| 2618 return (pkt); | |
| 2619 | |
| 2620 spx->txlt_total_residue = bp->b_bcount; | |
| 2621 } else { | |
| 2622 new_pkt = FALSE; | |
| 2623 /* | |
| 2624 * Packet was preallocated/initialized by previous call | |
| 2625 */ | |
| 2626 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2627 | |
| 2628 if ((bp == NULL) || (bp->b_bcount == 0)) { | |
| 2629 return (pkt); | |
| 2630 } | |
| 2631 ASSERT(spx->txlt_buf_dma_handle != NULL); | |
| 2632 | |
| 2633 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ | |
| 2634 } | |
| 2635 | |
| 2636 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; | |
| 2637 | |
| 2638 /* | |
| 2639 * We use an adjusted version of the dma_attr, to account | |
| 2640 * for device addressing limitations. | |
| 2641 * sata_adjust_dma_attr() will handle sdinfo == NULL which may | |
| 2642 * happen when a device is not yet configured. | |
| 2643 */ | |
| 2644 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2645 sata_device.satadev_addr.cport))); | |
| 2646 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 2647 &spx->txlt_sata_pkt->satapkt_device); | |
| 2648 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ | |
| 2649 sata_adjust_dma_attr(sdinfo, | |
| 2650 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); | |
| 2651 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2652 sata_device.satadev_addr.cport))); | |
| 2653 /* | |
| 2654 * Allocate necessary DMA resources for the packet's buffer | |
| 2655 */ | |
| 2656 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, | |
| 2657 &cur_dma_attr)) != DDI_SUCCESS) { | |
| 2658 sata_pkt_free(spx); | |
| 2659 /* | |
| 2660 * If a DMA allocation request fails with | |
| 2661 * DDI_DMA_NOMAPPING, indicate the error by calling | |
| 2662 * bioerror(9F) with bp and an error code of EFAULT. | |
| 2663 * If a DMA allocation request fails with | |
| 2664 * DDI_DMA_TOOBIG, indicate the error by calling | |
| 2665 * bioerror(9F) with bp and an error code of EINVAL. | |
| 2666 */ | |
| 2667 switch (rval) { | |
| 2668 case DDI_DMA_NORESOURCES: | |
| 2669 bioerror(bp, 0); | |
| 2670 break; | |
| 2671 case DDI_DMA_NOMAPPING: | |
| 2672 case DDI_DMA_BADATTR: | |
| 2673 bioerror(bp, EFAULT); | |
| 2674 break; | |
| 2675 case DDI_DMA_TOOBIG: | |
| 2676 default: | |
| 2677 bioerror(bp, EINVAL); | |
| 2678 break; | |
| 2679 } | |
| 2680 if (new_pkt == TRUE) { | |
| 2681 sata_pkt_free(spx); | |
| 2682 scsi_hba_pkt_free(ap, pkt); | |
| 2683 } | |
| 2684 return (NULL); | |
| 2685 } | |
| 2686 /* Set number of bytes that are not yet accounted for */ | |
| 2687 pkt->pkt_resid = spx->txlt_total_residue; | |
| 2688 ASSERT(pkt->pkt_resid >= 0); | |
| 2689 | |
| 2690 return (pkt); | |
| 2691 } | |
| 2692 | |
| 2693 /* | |
| 2694 * Implementation of scsi tran_start. | |
| 2695 * Translate scsi cmd into sata operation and return status. | |
| 2696 * Supported scsi commands: | |
| 2697 * SCMD_INQUIRY | |
| 2698 * SCMD_TEST_UNIT_READY | |
| 2699 * SCMD_START_STOP | |
| 2700 * SCMD_READ_CAPACITY | |
| 2701 * SCMD_REQUEST_SENSE | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
2702 * SCMD_LOG_SENSE_G1 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
2703 * SCMD_LOG_SELECT_G1 |
| 1258 | 2704 * SCMD_MODE_SENSE (specific pages) |
| 2705 * SCMD_MODE_SENSE_G1 (specific pages) | |
| 2706 * SCMD_MODE_SELECT (specific pages) | |
| 2707 * SCMD_MODE_SELECT_G1 (specific pages) | |
| 2708 * SCMD_SYNCHRONIZE_CACHE | |
| 2709 * SCMD_SYNCHRONIZE_CACHE_G1 | |
| 2710 * SCMD_READ | |
| 2711 * SCMD_READ_G1 | |
| 2712 * SCMD_READ_G4 | |
| 2713 * SCMD_READ_G5 | |
| 2714 * SCMD_WRITE | |
| 2715 * SCMD_WRITE_G1 | |
| 2716 * SCMD_WRITE_G4 | |
| 2717 * SCMD_WRITE_G5 | |
| 2718 * SCMD_SEEK (noop) | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
2719 * SCMD_SDIAG |
| 1258 | 2720 * |
| 2721 * All other commands are rejected as unsupported. | |
| 2722 * | |
| 2723 * Returns: | |
| 2724 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver | |
| 2725 * for execution. | |
| 2726 * TRAN_BADPKT if cmd was directed to invalid address. | |
| 2727 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including | |
| 2728 * unexpected removal of a device or some other unspecified error. | |
| 2729 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA | |
| 2730 * framework was busy performing some other operation(s). | |
| 2731 * | |
| 2732 */ | |
| 2733 static int | |
| 2734 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 2735 { | |
| 2736 sata_hba_inst_t *sata_hba_inst = | |
| 2737 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2738 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 2739 sata_drive_info_t *sdinfo; | |
| 2740 struct buf *bp; | |
| 2741 int cport; | |
| 2742 int rval; | |
| 2743 | |
| 2744 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2745 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); | |
| 2746 | |
| 2747 ASSERT(spx != NULL && | |
| 2748 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); | |
| 2749 | |
| 2750 /* | |
| 2751 * Mutex-protected section below is just to identify device type | |
| 2752 * and switch to ATAPI processing, if necessary | |
| 2753 */ | |
| 2754 cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 2755 | |
| 2756 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2757 | |
| 2758 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 2759 &spx->txlt_sata_pkt->satapkt_device); | |
| 2760 if (sdinfo == NULL) { | |
| 2761 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2762 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; | |
| 2763 return (TRAN_FATAL_ERROR); | |
| 2764 } | |
| 2765 | |
| 2766 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 2767 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2768 rval = sata_txlt_atapi(spx); | |
| 2769 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2770 "sata_scsi_start atapi: rval %d\n", rval); | |
| 2771 return (rval); | |
| 2772 } | |
| 2773 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 2774 | |
| 2775 /* ATA Disk commands processing starts here */ | |
| 2776 | |
| 2777 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 2778 | |
| 2779 switch (pkt->pkt_cdbp[0]) { | |
| 2780 | |
| 2781 case SCMD_INQUIRY: | |
| 2782 /* Mapped to identify device */ | |
| 2783 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2784 bp_mapin(bp); | |
| 2785 rval = sata_txlt_inquiry(spx); | |
| 2786 break; | |
| 2787 | |
| 2788 case SCMD_TEST_UNIT_READY: | |
| 2789 /* | |
| 2790 * SAT "SATA to ATA Translation" doc specifies translation | |
| 2791 * to ATA CHECK POWER MODE. | |
| 2792 */ | |
| 2793 rval = sata_txlt_test_unit_ready(spx); | |
| 2794 break; | |
| 2795 | |
| 2796 case SCMD_START_STOP: | |
| 2797 /* Mapping depends on the command */ | |
| 2798 rval = sata_txlt_start_stop_unit(spx); | |
| 2799 break; | |
| 2800 | |
| 2801 case SCMD_READ_CAPACITY: | |
| 2802 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2803 bp_mapin(bp); | |
| 2804 rval = sata_txlt_read_capacity(spx); | |
| 2805 break; | |
| 2806 | |
| 2807 case SCMD_REQUEST_SENSE: | |
| 2808 /* | |
| 2809 * Always No Sense, since we force ARQ | |
| 2810 */ | |
| 2811 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2812 bp_mapin(bp); | |
| 2813 rval = sata_txlt_request_sense(spx); | |
| 2814 break; | |
| 2815 | |
| 2816 case SCMD_LOG_SENSE_G1: | |
| 2817 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2818 bp_mapin(bp); | |
| 2819 rval = sata_txlt_log_sense(spx); | |
| 2820 break; | |
| 2821 | |
| 2822 case SCMD_LOG_SELECT_G1: | |
| 2823 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2824 bp_mapin(bp); | |
| 2825 rval = sata_txlt_log_select(spx); | |
| 2826 break; | |
| 2827 | |
| 2828 case SCMD_MODE_SENSE: | |
| 2829 case SCMD_MODE_SENSE_G1: | |
| 2830 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2831 bp_mapin(bp); | |
| 2832 rval = sata_txlt_mode_sense(spx); | |
| 2833 break; | |
| 2834 | |
| 2835 | |
| 2836 case SCMD_MODE_SELECT: | |
| 2837 case SCMD_MODE_SELECT_G1: | |
| 2838 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) | |
| 2839 bp_mapin(bp); | |
| 2840 rval = sata_txlt_mode_select(spx); | |
| 2841 break; | |
| 2842 | |
| 2843 case SCMD_SYNCHRONIZE_CACHE: | |
| 2844 case SCMD_SYNCHRONIZE_CACHE_G1: | |
| 2845 rval = sata_txlt_synchronize_cache(spx); | |
| 2846 break; | |
| 2847 | |
| 2848 case SCMD_READ: | |
| 2849 case SCMD_READ_G1: | |
| 2850 case SCMD_READ_G4: | |
| 2851 case SCMD_READ_G5: | |
| 2852 rval = sata_txlt_read(spx); | |
| 2853 break; | |
| 2854 | |
| 2855 case SCMD_WRITE: | |
| 2856 case SCMD_WRITE_G1: | |
| 2857 case SCMD_WRITE_G4: | |
| 2858 case SCMD_WRITE_G5: | |
| 2859 rval = sata_txlt_write(spx); | |
| 2860 break; | |
| 2861 | |
| 2862 case SCMD_SEEK: | |
| 2863 rval = sata_txlt_nodata_cmd_immediate(spx); | |
| 2864 break; | |
| 2865 | |
| 2866 /* Other cases will be filed later */ | |
| 2867 /* postponed until phase 2 of the development */ | |
| 2868 default: | |
| 2869 rval = sata_txlt_invalid_command(spx); | |
| 2870 break; | |
| 2871 } | |
| 2872 | |
| 2873 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2874 "sata_scsi_start: rval %d\n", rval); | |
| 2875 | |
| 2876 return (rval); | |
| 2877 } | |
| 2878 | |
| 2879 /* | |
| 2880 * Implementation of scsi tran_abort. | |
| 2881 * Abort specific pkt or all packets. | |
| 2882 * | |
| 2883 * Returns 1 if one or more packets were aborted, returns 0 otherwise | |
| 2884 * | |
| 2885 * May be called from an interrupt level. | |
| 2886 */ | |
| 2887 static int | |
| 2888 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) | |
| 2889 { | |
| 2890 sata_hba_inst_t *sata_hba_inst = | |
| 2891 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2892 sata_device_t sata_device; | |
| 2893 sata_pkt_t *sata_pkt; | |
| 2894 | |
| 2895 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2896 "sata_scsi_abort: %s at target: 0x%x\n", | |
| 2897 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); | |
| 2898 | |
| 2899 /* Validate address */ | |
| 2900 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) | |
| 2901 /* Invalid address */ | |
| 2902 return (0); | |
| 2903 | |
| 2904 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2905 sata_device.satadev_addr.cport))); | |
| 2906 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 2907 /* invalid address */ | |
| 2908 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2909 sata_device.satadev_addr.cport))); | |
| 2910 return (0); | |
| 2911 } | |
| 2912 if (scsi_pkt == NULL) { | |
| 2913 /* | |
| 2914 * Abort all packets. | |
| 2915 * Although we do not have specific packet, we still need | |
| 2916 * dummy packet structure to pass device address to HBA. | |
| 2917 * Allocate one, without sleeping. Fail if pkt cannot be | |
| 2918 * allocated. | |
| 2919 */ | |
| 2920 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); | |
| 2921 if (sata_pkt == NULL) { | |
| 2922 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2923 sata_device.satadev_addr.cport))); | |
| 2924 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " | |
| 2925 "could not allocate sata_pkt")); | |
| 2926 return (0); | |
| 2927 } | |
| 2928 sata_pkt->satapkt_rev = SATA_PKT_REV; | |
| 2929 sata_pkt->satapkt_device = sata_device; | |
| 2930 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; | |
| 2931 } else { | |
| 2932 if (scsi_pkt->pkt_ha_private == NULL) { | |
| 2933 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2934 sata_device.satadev_addr.cport))); | |
| 2935 return (0); /* Bad scsi pkt */ | |
| 2936 } | |
| 2937 /* extract pointer to sata pkt */ | |
| 2938 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> | |
| 2939 txlt_sata_pkt; | |
| 2940 } | |
| 2941 | |
| 2942 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2943 sata_device.satadev_addr.cport))); | |
| 2944 /* Send abort request to HBA */ | |
| 2945 if ((*SATA_ABORT_FUNC(sata_hba_inst)) | |
| 2946 (SATA_DIP(sata_hba_inst), sata_pkt, | |
| 2947 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == | |
| 2948 SATA_SUCCESS) { | |
| 2949 if (scsi_pkt == NULL) | |
| 2950 kmem_free(sata_pkt, sizeof (sata_pkt_t)); | |
| 2951 /* Success */ | |
| 2952 return (1); | |
| 2953 } | |
| 2954 /* Else, something did not go right */ | |
| 2955 if (scsi_pkt == NULL) | |
| 2956 kmem_free(sata_pkt, sizeof (sata_pkt_t)); | |
| 2957 /* Failure */ | |
| 2958 return (0); | |
| 2959 } | |
| 2960 | |
| 2961 | |
| 2962 /* | |
| 2963 * Implementation os scsi tran_reset. | |
| 2964 * RESET_ALL request is translated into port reset. | |
| 2965 * RESET_TARGET requests is translated into a device reset, | |
| 2966 * RESET_LUN request is accepted only for LUN 0 and translated into | |
| 2967 * device reset. | |
| 2968 * The target reset should cause all HBA active and queued packets to | |
| 2969 * be terminated and returned with pkt reason SATA_PKT_RESET prior to | |
| 2970 * the return. HBA should report reset event for the device. | |
| 2971 * | |
| 2972 * Returns 1 upon success, 0 upon failure. | |
| 2973 */ | |
| 2974 static int | |
| 2975 sata_scsi_reset(struct scsi_address *ap, int level) | |
| 2976 { | |
| 2977 sata_hba_inst_t *sata_hba_inst = | |
| 2978 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 2979 sata_device_t sata_device; | |
| 2980 int val; | |
| 2981 | |
| 2982 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 2983 "sata_scsi_reset: level %d target: 0x%x\n", | |
| 2984 level, ap->a_target); | |
| 2985 | |
| 2986 /* Validate address */ | |
| 2987 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); | |
| 2988 if (val == -1) | |
| 2989 /* Invalid address */ | |
| 2990 return (0); | |
| 2991 | |
| 2992 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2993 sata_device.satadev_addr.cport))); | |
| 2994 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 2995 /* invalid address */ | |
| 2996 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 2997 sata_device.satadev_addr.cport))); | |
| 2998 return (0); | |
| 2999 } | |
| 3000 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3001 sata_device.satadev_addr.cport))); | |
| 3002 if (level == RESET_ALL) { | |
| 3003 /* port reset - cport only */ | |
| 3004 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 3005 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 3006 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) | |
| 3007 return (1); | |
| 3008 else | |
| 3009 return (0); | |
| 3010 | |
| 3011 } else if (val == 0 && | |
| 3012 (level == RESET_TARGET || level == RESET_LUN)) { | |
| 3013 /* reset device (device attached) */ | |
| 3014 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) | |
| 3015 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) | |
| 3016 return (1); | |
| 3017 else | |
| 3018 return (0); | |
| 3019 } | |
| 3020 return (0); | |
| 3021 } | |
| 3022 | |
| 3023 | |
| 3024 /* | |
| 3025 * Implementation of scsi tran_getcap (get transport/device capabilities). | |
| 3026 * Supported capabilities: | |
| 3027 * auto-rqsense (always supported) | |
| 3028 * tagged-qing (supported if HBA supports it) | |
| 3029 * dma_max | |
| 3030 * interconnect-type (INTERCONNECT_SATA) | |
| 3031 * | |
| 3032 * Request for other capabilities is rejected as unsupported. | |
| 3033 * | |
| 3034 * Returns supported capability value, or -1 if capability is unsuppported or | |
| 3035 * the address is invalid (no device). | |
| 3036 */ | |
| 3037 | |
| 3038 static int | |
| 3039 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) | |
| 3040 { | |
| 3041 | |
| 3042 sata_hba_inst_t *sata_hba_inst = | |
| 3043 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3044 sata_device_t sata_device; | |
| 3045 sata_drive_info_t *sdinfo; | |
| 3046 ddi_dma_attr_t adj_dma_attr; | |
| 3047 int rval; | |
| 3048 | |
| 3049 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3050 "sata_scsi_getcap: target: 0x%x, cap: %s\n", | |
| 3051 ap->a_target, cap); | |
| 3052 | |
| 3053 /* | |
| 3054 * We want to process the capabilities on per port granularity. | |
| 3055 * So, we are specifically restricting ourselves to whom != 0 | |
| 3056 * to exclude the controller wide handling. | |
| 3057 */ | |
| 3058 if (cap == NULL || whom == 0) | |
| 3059 return (-1); | |
| 3060 | |
| 3061 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { | |
| 3062 /* Invalid address */ | |
| 3063 return (-1); | |
| 3064 } | |
| 3065 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3066 sata_device.satadev_addr.cport))); | |
| 3067 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == | |
| 3068 NULL) { | |
| 3069 /* invalid address */ | |
| 3070 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3071 sata_device.satadev_addr.cport))); | |
| 3072 return (0); | |
| 3073 } | |
| 3074 | |
| 3075 switch (scsi_hba_lookup_capstr(cap)) { | |
| 3076 case SCSI_CAP_ARQ: | |
| 3077 rval = 1; /* ARQ supported, turned on */ | |
| 3078 break; | |
| 3079 | |
| 3080 case SCSI_CAP_SECTOR_SIZE: | |
| 3081 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) | |
| 3082 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ | |
| 3083 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) | |
| 3084 rval = SATA_ATAPI_SECTOR_SIZE; | |
| 3085 else rval = -1; | |
| 3086 break; | |
| 3087 | |
| 3088 case SCSI_CAP_TAGGED_QING: | |
| 3089 /* | |
| 3090 * It is enough if the controller supports queuing, regardless | |
| 3091 * of the device. NCQ support is an internal implementation | |
| 3092 * feature used between HBA and the device. | |
| 3093 */ | |
| 3094 if (SATA_QDEPTH(sata_hba_inst) > 1) | |
| 3095 rval = 1; /* Queuing supported */ | |
| 3096 else | |
| 3097 rval = -1; /* Queuing not supported */ | |
| 3098 break; | |
| 3099 | |
| 3100 case SCSI_CAP_DMA_MAX: | |
| 3101 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), | |
| 3102 &adj_dma_attr); | |
| 3103 rval = (int)adj_dma_attr.dma_attr_maxxfer; | |
| 3104 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ | |
| 3105 break; | |
| 3106 | |
| 3107 case SCSI_CAP_INTERCONNECT_TYPE: | |
| 3108 rval = INTERCONNECT_SATA; /* SATA interconnect type */ | |
| 3109 break; | |
| 3110 | |
| 3111 default: | |
| 3112 rval = -1; | |
| 3113 break; | |
| 3114 } | |
| 3115 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3116 sata_device.satadev_addr.cport))); | |
| 3117 return (rval); | |
| 3118 } | |
| 3119 | |
| 3120 /* | |
| 3121 * Implementation of scsi tran_setcap | |
| 3122 * | |
| 3123 * All supported capabilities are fixed/unchangeable. | |
| 3124 * Returns 0 for all supported capabilities and valid device, -1 otherwise. | |
| 3125 */ | |
| 3126 static int | |
| 3127 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) | |
| 3128 { | |
| 3129 #ifndef __lock_lint | |
| 3130 _NOTE(ARGUNUSED(value)) | |
| 3131 #endif | |
| 3132 sata_hba_inst_t *sata_hba_inst = | |
| 3133 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); | |
| 3134 sata_device_t sata_device; | |
| 3135 int rval; | |
| 3136 | |
| 3137 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 3138 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); | |
| 3139 | |
| 3140 /* | |
| 3141 * We want to process the capabilities on per port granularity. | |
| 3142 * So, we are specifically restricting ourselves to whom != 0 | |
| 3143 * to exclude the controller wide handling. | |
| 3144 */ | |
| 3145 if (cap == NULL || whom == 0) { | |
| 3146 return (-1); | |
| 3147 } | |
| 3148 | |
| 3149 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { | |
| 3150 /* Invalid address */ | |
| 3151 return (-1); | |
| 3152 } | |
| 3153 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3154 sata_device.satadev_addr.cport))); | |
| 3155 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { | |
| 3156 /* invalid address */ | |
| 3157 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3158 sata_device.satadev_addr.cport))); | |
| 3159 return (0); | |
| 3160 } | |
| 3161 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 3162 sata_device.satadev_addr.cport))); | |
| 3163 | |
| 3164 switch (scsi_hba_lookup_capstr(cap)) { | |
| 3165 case SCSI_CAP_ARQ: | |
| 3166 case SCSI_CAP_SECTOR_SIZE: | |
| 3167 case SCSI_CAP_TAGGED_QING: | |
| 3168 case SCSI_CAP_DMA_MAX: | |
| 3169 case SCSI_CAP_INTERCONNECT_TYPE: | |
| 3170 rval = 0; /* Capability cannot be changed */ | |
| 3171 break; | |
| 3172 | |
| 3173 default: | |
| 3174 rval = -1; | |
| 3175 break; | |
| 3176 } | |
| 3177 return (rval); | |
| 3178 } | |
| 3179 | |
| 3180 /* | |
| 3181 * Implementations of scsi tran_destroy_pkt. | |
| 3182 * Free resources allocated by sata_scsi_init_pkt() | |
| 3183 */ | |
| 3184 static void | |
| 3185 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3186 { | |
| 3187 sata_pkt_txlate_t *spx; | |
| 3188 | |
| 3189 ASSERT(pkt != NULL); | |
| 3190 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 3191 | |
| 3192 if (spx->txlt_buf_dma_handle != NULL) { | |
| 3193 /* | |
| 3194 * Free DMA resources - cookies and handles | |
| 3195 */ | |
| 3196 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
| 3197 (void) kmem_free(spx->txlt_dma_cookie_list, | |
| 3198 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); | |
| 3199 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); | |
| 3200 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 3201 } | |
| 3202 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 3203 sata_pkt_free(spx); | |
| 3204 | |
| 3205 scsi_hba_pkt_free(ap, pkt); | |
| 3206 } | |
| 3207 | |
| 3208 /* | |
| 3209 * Implementation of scsi tran_dmafree. | |
| 3210 * Free DMA resources allocated by sata_scsi_init_pkt() | |
| 3211 */ | |
| 3212 | |
| 3213 static void | |
| 3214 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3215 { | |
| 3216 #ifndef __lock_lint | |
| 3217 _NOTE(ARGUNUSED(ap)) | |
| 3218 #endif | |
| 3219 sata_pkt_txlate_t *spx; | |
| 3220 | |
| 3221 ASSERT(pkt != NULL); | |
| 3222 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 3223 | |
| 3224 if (spx->txlt_buf_dma_handle != NULL) { | |
| 3225 /* | |
| 3226 * Free DMA resources - cookies and handles | |
| 3227 */ | |
| 3228 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
| 3229 (void) kmem_free(spx->txlt_dma_cookie_list, | |
| 3230 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); | |
| 3231 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); | |
| 3232 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 3233 } | |
| 3234 } | |
| 3235 | |
| 3236 /* | |
| 3237 * Implementation of scsi tran_sync_pkt. | |
| 3238 * | |
| 3239 * The assumption below is that pkt is unique - there is no need to check ap | |
| 3240 */ | |
| 3241 static void | |
| 3242 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) | |
| 3243 { | |
| 3244 #ifndef __lock_lint | |
| 3245 _NOTE(ARGUNUSED(ap)) | |
| 3246 #endif | |
| 3247 int rval; | |
| 3248 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; | |
| 3249 | |
| 3250 if (spx->txlt_buf_dma_handle != NULL) { | |
| 3251 if (spx->txlt_sata_pkt != NULL && | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3252 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3253 sata_data_direction != SATA_DIR_NODATA_XFER) { |
| 1258 | 3254 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3255 (spx->txlt_sata_pkt->satapkt_cmd. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3256 satacmd_flags.sata_data_direction & |
| 1258 | 3257 SATA_DIR_WRITE) ? |
| 3258 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); | |
| 3259 if (rval == DDI_SUCCESS) { | |
| 3260 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 3261 "sata_scsi_sync_pkt: sync pkt failed")); | |
| 3262 } | |
| 3263 } | |
| 3264 } | |
| 3265 } | |
| 3266 | |
| 3267 | |
| 3268 | |
| 3269 /* ******************* SATA - SCSI Translation functions **************** */ | |
| 3270 /* | |
| 3271 * SCSI to SATA pkt and command translation and SATA to SCSI status/error | |
| 3272 * translation. | |
| 3273 */ | |
| 3274 | |
| 3275 /* | |
| 3276 * Checks if a device exists and can be access and translates common | |
| 3277 * scsi_pkt data to sata_pkt data. | |
| 3278 * | |
| 3279 * Returns TRAN_ACCEPT if device exists and sata_pkt was set-up. | |
| 3280 * Returns other TRAN_XXXXX values when error occured. | |
| 3281 * | |
| 3282 * This function should be called with port mutex held. | |
| 3283 */ | |
| 3284 static int | |
| 3285 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx) | |
| 3286 { | |
| 3287 sata_drive_info_t *sdinfo; | |
| 3288 sata_device_t sata_device; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3289 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
|
3290 SATA_DIR_NODATA_XFER, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3291 /* all other values to 0/FALSE */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3292 }; |
| 1258 | 3293 |
| 3294 /* Validate address */ | |
| 3295 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, | |
| 3296 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { | |
| 3297 | |
| 3298 case -1: | |
| 3299 /* Invalid address or invalid device type */ | |
| 3300 return (TRAN_BADPKT); | |
| 3301 case 1: | |
| 3302 /* valid address but no device - it has disappeared ? */ | |
| 3303 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; | |
| 3304 return (TRAN_FATAL_ERROR); | |
| 3305 default: | |
| 3306 /* all OK */ | |
| 3307 break; | |
| 3308 } | |
| 3309 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 3310 &spx->txlt_sata_pkt->satapkt_device); | |
| 3311 | |
| 3312 /* | |
| 3313 * If device is in reset condition, reject the packet with | |
| 3314 * TRAN_BUSY | |
| 3315 */ | |
| 3316 if (sdinfo->satadrv_event_flags & | |
| 3317 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { | |
| 3318 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 3319 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3320 "sata_scsi_start: rejecting command because " | |
| 3321 "of device reset state\n", NULL); | |
| 3322 return (TRAN_BUSY); | |
| 3323 } | |
| 3324 | |
| 3325 /* | |
| 3326 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by | |
| 3327 * sata_scsi_pkt_init() because pkt init had to work also with | |
| 3328 * non-existing devices. | |
| 3329 * Now we know that the packet was set-up for a real device, so its | |
| 3330 * type is known. | |
| 3331 */ | |
| 3332 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; | |
| 3333 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3334 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; |
| 1258 | 3335 |
| 3336 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; | |
| 3337 | |
| 3338 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { | |
| 3339 /* Synchronous execution */ | |
| 3340 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | | |
| 3341 SATA_OPMODE_POLLING; | |
| 3342 } else { | |
| 3343 /* Asynchronous execution */ | |
| 3344 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | | |
| 3345 SATA_OPMODE_INTERRUPTS; | |
| 3346 } | |
| 3347 /* Convert queuing information */ | |
| 3348 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
|
3349 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
|
3350 B_TRUE; |
| 1258 | 3351 else if (spx->txlt_scsi_pkt->pkt_flags & |
| 3352 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3353 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
|
3354 B_TRUE; |
| 1258 | 3355 |
| 3356 /* Always limit pkt time */ | |
| 3357 if (spx->txlt_scsi_pkt->pkt_time == 0) | |
| 3358 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; | |
| 3359 else | |
| 3360 /* Pass on scsi_pkt time */ | |
| 3361 spx->txlt_sata_pkt->satapkt_time = | |
| 3362 spx->txlt_scsi_pkt->pkt_time; | |
| 3363 | |
| 3364 return (TRAN_ACCEPT); | |
| 3365 } | |
| 3366 | |
| 3367 | |
| 3368 /* | |
| 3369 * Translate ATA(ATAPI) Identify (Packet) Device data to SCSI Inquiry data. | |
| 3370 * SATA Identify Device data has to be valid in sata_rive_info. | |
| 3371 * Buffer has to accomodate the inquiry length (36 bytes). | |
| 3372 * | |
| 3373 * This function should be called with a port mutex held. | |
| 3374 */ | |
| 3375 static void | |
| 3376 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, | |
| 3377 sata_drive_info_t *sdinfo, uint8_t *buf) | |
| 3378 { | |
| 3379 | |
| 3380 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; | |
| 3381 struct sata_id *sid = &sdinfo->satadrv_id; | |
| 3382 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3383 /* Start with a nice clean slate */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3384 bzero((void *)inq, sizeof (struct scsi_inquiry)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3385 |
| 1258 | 3386 /* Rely on the dev_type for setting paripheral qualifier */ |
| 3387 /* Does DTYPE_RODIRECT apply to CD/DVD R/W devices ? */ | |
| 3388 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 3389 DTYPE_DIRECT : DTYPE_RODIRECT; | |
| 3390 | |
| 3391 inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0; | |
| 3392 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ | |
| 3393 inq->inq_iso = 0; /* ISO version */ | |
| 3394 inq->inq_ecma = 0; /* ECMA version */ | |
| 3395 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ | |
| 3396 inq->inq_aenc = 0; /* Async event notification cap. */ | |
| 3397 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg ??? */ | |
| 3398 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ | |
| 3399 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ | |
| 3400 inq->inq_len = 31; /* Additional length */ | |
| 3401 inq->inq_dualp = 0; /* dual port device - NO */ | |
| 3402 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ | |
| 3403 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ | |
| 3404 inq->inq_linked = 0; /* Supports linked commands - NO */ | |
| 3405 /* | |
| 3406 * Queuing support - controller has to | |
| 3407 * support some sort of command queuing. | |
| 3408 */ | |
| 3409 if (SATA_QDEPTH(sata_hba_inst) > 1) | |
| 3410 inq->inq_cmdque = 1; /* Supports command queueing - YES */ | |
| 3411 else | |
| 3412 inq->inq_cmdque = 0; /* Supports command queueing - NO */ | |
| 3413 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ | |
| 3414 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ | |
| 3415 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ | |
| 3416 | |
| 3417 #ifdef _LITTLE_ENDIAN | |
| 3418 /* Swap text fields to match SCSI format */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3419 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3420 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
|
3421 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3422 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
|
3423 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3424 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ |
| 1258 | 3425 #else |
| 3426 bcopy(sid->ai_model, inq->inq_vid, 8); /* Vendor ID */ | |
| 3427 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
|
3428 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3429 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
|
3430 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3431 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ |
| 1258 | 3432 #endif |
| 3433 } | |
| 3434 | |
| 3435 | |
| 3436 /* | |
| 3437 * Scsi response set up for invalid command (command not supported) | |
| 3438 * | |
| 3439 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3440 */ | |
| 3441 static int | |
| 3442 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) | |
| 3443 { | |
| 3444 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3445 struct scsi_extended_sense *sense; | |
| 3446 | |
| 3447 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3448 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3449 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3450 | |
| 3451 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3452 | |
| 3453 sense = sata_arq_sense(spx); | |
| 3454 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3455 sense->es_add_code = SD_SCSI_INVALID_COMMAND_CODE; | |
| 3456 | |
| 3457 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3458 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3459 | |
| 3460 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3461 scsipkt->pkt_comp != NULL) | |
| 3462 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3463 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3464 (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
|
3465 (void *)spx->txlt_scsi_pkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3466 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3467 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3468 return (TRAN_BUSY); |
| 1258 | 3469 return (TRAN_ACCEPT); |
| 3470 } | |
| 3471 | |
| 3472 /* | |
| 3473 * Scsi response setup for | |
| 3474 * emulated non-data command that requires no action/return data | |
| 3475 * | |
| 3476 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3477 */ | |
| 3478 static int | |
| 3479 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) | |
| 3480 { | |
| 3481 int rval; | |
| 3482 | |
| 3483 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3484 | |
| 3485 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3486 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3487 return (rval); | |
| 3488 } | |
| 3489 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3490 | |
| 3491 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3492 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3493 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; | |
| 3494 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; | |
| 3495 | |
| 3496 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3497 "Scsi_pkt completion reason %x\n", | |
| 3498 spx->txlt_scsi_pkt->pkt_reason); | |
| 3499 | |
| 3500 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3501 spx->txlt_scsi_pkt->pkt_comp != NULL) | |
| 3502 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3503 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3504 (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
|
3505 (void *)spx->txlt_scsi_pkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3506 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3507 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3508 return (TRAN_BUSY); |
| 1258 | 3509 return (TRAN_ACCEPT); |
| 3510 } | |
| 3511 | |
| 3512 | |
| 3513 /* | |
| 3514 * SATA translate command: Inquiry / Identify Device | |
| 3515 * Use cached Identify Device data for now, rather then issuing actual | |
| 3516 * Device Identify cmd request. If device is detached and re-attached, | |
| 3517 * asynchromous event processing should fetch and refresh Identify Device | |
| 3518 * data. | |
| 3519 * Two VPD pages are supported now: | |
| 3520 * Vital Product Data page | |
| 3521 * Unit Serial Number page | |
| 3522 * | |
| 3523 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3524 */ | |
| 3525 | |
| 3526 #define EVPD 1 /* Extended Vital Product Data flag */ | |
| 3527 #define CMDDT 2 /* Command Support Data - Obsolete */ | |
| 3528 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ | |
| 3529 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ | |
| 3530 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ | |
| 3531 | |
| 3532 static int | |
| 3533 sata_txlt_inquiry(sata_pkt_txlate_t *spx) | |
| 3534 { | |
| 3535 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3536 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 3537 sata_drive_info_t *sdinfo; | |
| 3538 struct scsi_extended_sense *sense; | |
| 3539 int count; | |
| 3540 uint8_t *p; | |
| 3541 int i, j; | |
| 3542 uint8_t page_buf[0xff]; /* Max length */ | |
| 3543 int rval; | |
| 3544 | |
| 3545 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3546 | |
| 3547 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3548 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3549 return (rval); | |
| 3550 } | |
| 3551 | |
| 3552 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 3553 &spx->txlt_sata_pkt->satapkt_device); | |
| 3554 | |
| 3555 ASSERT(sdinfo != NULL); | |
| 3556 | |
| 3557 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3558 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3559 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3560 | |
| 3561 /* Reject not supported request */ | |
| 3562 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ | |
| 3563 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3564 sense = sata_arq_sense(spx); | |
| 3565 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3566 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3567 goto done; | |
| 3568 } | |
| 3569 | |
| 3570 /* Valid Inquiry request */ | |
| 3571 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3572 | |
| 3573 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 3574 | |
| 3575 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { | |
| 3576 /* Standard Inquiry Data request */ | |
| 3577 struct scsi_inquiry inq; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3578 unsigned int bufsize; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3579 |
| 1258 | 3580 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, |
| 3581 sdinfo, (uint8_t *)&inq); | |
| 3582 /* Copy no more than requested */ | |
| 3583 count = MIN(bp->b_bcount, | |
| 3584 sizeof (struct scsi_inquiry)); | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3585 bufsize = scsipkt->pkt_cdbp[4]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3586 bufsize |= scsipkt->pkt_cdbp[3] << 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
3587 count = MIN(count, bufsize); |
| 1258 | 3588 bcopy(&inq, bp->b_un.b_addr, count); |
| 3589 | |
| 3590 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3591 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
|
3592 bufsize - count : 0; |
| 1258 | 3593 } else { |
| 3594 /* | |
| 3595 * peripheral_qualifier = 0; | |
| 3596 * | |
| 3597 * We are dealing only with HD and will be | |
| 3598 * dealing with CD/DVD devices soon | |
| 3599 */ | |
| 3600 uint8_t peripheral_device_type = | |
| 3601 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 3602 DTYPE_DIRECT : DTYPE_RODIRECT; | |
| 3603 | |
| 3604 switch ((uint_t)scsipkt->pkt_cdbp[2]) { | |
| 3605 case INQUIRY_SUP_VPD_PAGE: | |
| 3606 /* | |
| 3607 * Request for suported Vital Product Data | |
| 3608 * pages - assuming only 2 page codes | |
| 3609 * supported | |
| 3610 */ | |
| 3611 page_buf[0] = peripheral_device_type; | |
| 3612 page_buf[1] = INQUIRY_SUP_VPD_PAGE; | |
| 3613 page_buf[2] = 0; | |
| 3614 page_buf[3] = 2; /* page length */ | |
| 3615 page_buf[4] = INQUIRY_SUP_VPD_PAGE; | |
| 3616 page_buf[5] = INQUIRY_USN_PAGE; | |
| 3617 /* Copy no more than requested */ | |
| 3618 count = MIN(bp->b_bcount, 6); | |
| 3619 bcopy(page_buf, bp->b_un.b_addr, count); | |
| 3620 break; | |
| 3621 case INQUIRY_USN_PAGE: | |
| 3622 /* | |
| 3623 * Request for Unit Serial Number page | |
| 3624 */ | |
| 3625 page_buf[0] = peripheral_device_type; | |
| 3626 page_buf[1] = INQUIRY_USN_PAGE; | |
| 3627 page_buf[2] = 0; | |
| 3628 page_buf[3] = 20; /* remaining page length */ | |
| 3629 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); | |
| 3630 #ifdef _LITTLE_ENDIAN | |
| 3631 swab(p, &page_buf[4], 20); | |
| 3632 #else | |
| 3633 bcopy(p, &page_buf[4], 20); | |
| 3634 #endif | |
| 3635 for (i = 0; i < 20; i++) { | |
| 3636 if (page_buf[4 + i] == '\0' || | |
| 3637 page_buf[4 + i] == '\040') { | |
| 3638 break; | |
| 3639 } | |
| 3640 } | |
| 3641 /* | |
| 3642 * 'i' contains string length. | |
| 3643 * | |
| 3644 * Least significant character of the serial | |
| 3645 * number shall appear as the last byte, | |
| 3646 * according to SBC-3 spec. | |
| 3647 */ | |
| 3648 p = &page_buf[20 + 4 - 1]; | |
| 3649 for (j = i; j > 0; j--, p--) { | |
| 3650 *p = *(p - 20 + i); | |
| 3651 } | |
| 3652 p = &page_buf[4]; | |
| 3653 for (j = 20 - i; j > 0; j--) { | |
| 3654 *p++ = '\040'; | |
| 3655 } | |
| 3656 count = MIN(bp->b_bcount, 24); | |
| 3657 bcopy(page_buf, bp->b_un.b_addr, count); | |
| 3658 break; | |
| 3659 | |
| 3660 case INQUIRY_DEV_IDENTIFICATION_PAGE: | |
| 3661 /* | |
| 3662 * We may want to implement this page, when | |
| 3663 * identifiers are common for SATA devices | |
| 3664 * But not now. | |
| 3665 */ | |
| 3666 /*FALLTHRU*/ | |
| 3667 | |
| 3668 default: | |
| 3669 /* Request for unsupported VPD page */ | |
| 3670 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3671 sense = sata_arq_sense(spx); | |
| 3672 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3673 sense->es_add_code = | |
| 3674 SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3675 goto done; | |
| 3676 } | |
| 3677 } | |
| 3678 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3679 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? | |
| 3680 scsipkt->pkt_cdbp[4] - count : 0; | |
| 3681 } | |
| 3682 done: | |
| 3683 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3684 | |
| 3685 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3686 "Scsi_pkt completion reason %x\n", | |
| 3687 scsipkt->pkt_reason); | |
| 3688 | |
| 3689 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3690 scsipkt->pkt_comp != NULL) { |
| 1258 | 3691 /* scsi callback required */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3692 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3693 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3694 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3695 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3696 return (TRAN_BUSY); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3697 } |
| 1258 | 3698 return (TRAN_ACCEPT); |
| 3699 } | |
| 3700 | |
| 3701 /* | |
| 3702 * SATA translate command: Request Sense | |
| 3703 * emulated command (ATA version so far, no ATAPI) | |
| 3704 * Always NO SENSE, because any sense data should be reported by ARQ sense. | |
| 3705 * | |
| 3706 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3707 */ | |
| 3708 static int | |
| 3709 sata_txlt_request_sense(sata_pkt_txlate_t *spx) | |
| 3710 { | |
| 3711 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3712 struct scsi_extended_sense sense; | |
| 3713 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 3714 int rval; | |
| 3715 | |
| 3716 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3717 | |
| 3718 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3719 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3720 return (rval); | |
| 3721 } | |
| 3722 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3723 | |
| 3724 | |
| 3725 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3726 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3727 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3728 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3729 | |
| 3730 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 3731 int count = MIN(bp->b_bcount, | |
| 3732 sizeof (struct scsi_extended_sense)); | |
| 3733 bzero(&sense, sizeof (struct scsi_extended_sense)); | |
| 3734 sense.es_valid = 0; /* Valid LBA */ | |
| 3735 sense.es_class = 7; /* Response code 0x70 - current err */ | |
| 3736 sense.es_key = KEY_NO_SENSE; | |
| 3737 sense.es_add_len = 6; /* Additional length */ | |
| 3738 /* Copy no more than requested */ | |
| 3739 bcopy(&sense, bp->b_un.b_addr, count); | |
| 3740 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3741 scsipkt->pkt_resid = 0; | |
| 3742 } | |
| 3743 | |
| 3744 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3745 "Scsi_pkt completion reason %x\n", | |
| 3746 scsipkt->pkt_reason); | |
| 3747 | |
| 3748 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3749 scsipkt->pkt_comp != NULL) | |
| 3750 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3751 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3752 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3753 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3754 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3755 return (TRAN_BUSY); |
| 1258 | 3756 return (TRAN_ACCEPT); |
| 3757 } | |
| 3758 | |
| 3759 /* | |
| 3760 * SATA translate command: Test Unit Ready | |
| 3761 * At the moment this is an emulated command (ATA version so far, no ATAPI). | |
| 3762 * May be translated into Check Power Mode command in the future | |
| 3763 * | |
| 3764 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3765 */ | |
| 3766 static int | |
| 3767 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) | |
| 3768 { | |
| 3769 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3770 struct scsi_extended_sense *sense; | |
| 3771 int power_state; | |
| 3772 int rval; | |
| 3773 | |
| 3774 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3775 | |
| 3776 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3777 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3778 return (rval); | |
| 3779 } | |
| 3780 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3781 | |
| 3782 /* At this moment, emulate it rather than execute anything */ | |
| 3783 power_state = SATA_PWRMODE_ACTIVE; | |
| 3784 | |
| 3785 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3786 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3787 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3788 | |
| 3789 switch (power_state) { | |
| 3790 case SATA_PWRMODE_ACTIVE: | |
| 3791 case SATA_PWRMODE_IDLE: | |
| 3792 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3793 break; | |
| 3794 default: | |
| 3795 /* PWR mode standby */ | |
| 3796 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3797 sense = sata_arq_sense(spx); | |
| 3798 sense->es_key = KEY_NOT_READY; | |
| 3799 sense->es_add_code = SD_SCSI_LU_NOT_READY; | |
| 3800 break; | |
| 3801 } | |
| 3802 | |
| 3803 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3804 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3805 | |
| 3806 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3807 scsipkt->pkt_comp != NULL) | |
| 3808 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3809 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3810 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3811 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3812 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3813 return (TRAN_BUSY); |
| 1258 | 3814 |
| 3815 return (TRAN_ACCEPT); | |
| 3816 } | |
| 3817 | |
| 3818 | |
| 3819 /* | |
| 3820 * SATA translate command: Start Stop Unit | |
| 3821 * Translation depends on a command: | |
| 3822 * Start Unit translated into Idle Immediate | |
| 3823 * Stop Unit translated into Standby Immediate | |
| 3824 * Unload Media / NOT SUPPORTED YET | |
| 3825 * Load Media / NOT SUPPROTED YET | |
| 3826 * Power condition bits are ignored, so is Immediate bit | |
| 3827 * Requesting synchronous execution. | |
| 3828 * | |
| 3829 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 3830 * appropriate values in scsi_pkt fields. | |
| 3831 */ | |
| 3832 static int | |
| 3833 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) | |
| 3834 { | |
| 3835 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3836 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 3837 struct scsi_extended_sense *sense; | |
| 3838 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 3839 int cport = SATA_TXLT_CPORT(spx); | |
| 3840 int rval; | |
| 3841 int synch; | |
| 3842 | |
| 3843 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3844 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); | |
| 3845 | |
| 3846 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); | |
| 3847 | |
| 3848 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3849 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3850 return (rval); | |
| 3851 } | |
| 3852 | |
| 3853 if (scsipkt->pkt_cdbp[4] & 2) { | |
| 3854 /* Load/Unload Media - invalid request */ | |
| 3855 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 3856 sense = sata_arq_sense(spx); | |
| 3857 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 3858 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 3859 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3860 | |
| 3861 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3862 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3863 | |
| 3864 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3865 scsipkt->pkt_comp != NULL) | |
| 3866 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3867 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3868 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3869 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3870 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3871 return (TRAN_BUSY); |
| 1258 | 3872 |
| 3873 return (TRAN_ACCEPT); | |
| 3874 } | |
| 3875 scmd->satacmd_addr_type = 0; | |
| 3876 scmd->satacmd_sec_count_lsb = 0; | |
| 3877 scmd->satacmd_lba_low_lsb = 0; | |
| 3878 scmd->satacmd_lba_mid_lsb = 0; | |
| 3879 scmd->satacmd_lba_high_lsb = 0; | |
| 3880 scmd->satacmd_features_reg = 0; | |
| 3881 scmd->satacmd_device_reg = 0; | |
| 3882 scmd->satacmd_status_reg = 0; | |
| 3883 if (scsipkt->pkt_cdbp[4] & 1) { | |
| 3884 /* Start Unit */ | |
| 3885 scmd->satacmd_cmd_reg = SATAC_IDLE_IM; | |
| 3886 } else { | |
| 3887 /* Stop Unit */ | |
| 3888 scmd->satacmd_cmd_reg = SATAC_STANDBY_IM; | |
| 3889 } | |
| 3890 | |
| 3891 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 3892 /* Need to set-up a callback function */ | |
| 3893 spx->txlt_sata_pkt->satapkt_comp = | |
| 3894 sata_txlt_nodata_cmd_completion; | |
| 3895 synch = FALSE; | |
| 3896 } else { | |
| 3897 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; | |
| 3898 synch = TRUE; | |
| 3899 } | |
| 3900 | |
| 3901 /* Transfer command to HBA */ | |
| 3902 if (sata_hba_start(spx, &rval) != 0) { | |
| 3903 /* Pkt not accepted for execution */ | |
| 3904 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 3905 return (rval); | |
| 3906 } | |
| 3907 | |
| 3908 /* | |
| 3909 * If execution is non-synchronous, | |
| 3910 * a callback function will handle potential errors, translate | |
| 3911 * the response and will do a callback to a target driver. | |
| 3912 * If it was synchronous, check execution status using the same | |
| 3913 * framework callback. | |
| 3914 */ | |
| 3915 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 3916 if (synch) { | |
| 3917 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3918 "synchronous execution status %x\n", | |
| 3919 spx->txlt_sata_pkt->satapkt_reason); | |
| 3920 | |
| 3921 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); | |
| 3922 } | |
| 3923 return (TRAN_ACCEPT); | |
| 3924 | |
| 3925 } | |
| 3926 | |
| 3927 | |
| 3928 /* | |
| 3929 * SATA translate command: Read Capacity. | |
| 3930 * Emulated command for SATA disks. | |
| 3931 * Capacity is retrieved from cached Idenifty Device data. | |
| 3932 * Identify Device data shows effective disk capacity, not the native | |
| 3933 * capacity, which may be limitted by Set Max Address command. | |
| 3934 * This is ATA version (non-ATAPI). | |
| 3935 * | |
| 3936 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 3937 */ | |
| 3938 static int | |
| 3939 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) | |
| 3940 { | |
| 3941 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 3942 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 3943 sata_drive_info_t *sdinfo; | |
| 3944 uint64_t val; | |
| 3945 uchar_t *rbuf; | |
| 3946 int rval; | |
| 3947 | |
| 3948 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3949 "sata_txlt_read_capacity: ", NULL); | |
| 3950 | |
| 3951 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3952 | |
| 3953 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 3954 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3955 return (rval); | |
| 3956 } | |
| 3957 | |
| 3958 scsipkt->pkt_reason = CMD_CMPLT; | |
| 3959 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 3960 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 3961 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 3962 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 3963 sdinfo = sata_get_device_info( | |
| 3964 spx->txlt_sata_hba_inst, | |
| 3965 &spx->txlt_sata_pkt->satapkt_device); | |
| 3966 /* Last logical block address */ | |
| 3967 val = sdinfo->satadrv_capacity - 1; | |
| 3968 rbuf = (uchar_t *)bp->b_un.b_addr; | |
| 3969 /* Need to swap endians to match scsi format */ | |
| 3970 rbuf[0] = (val >> 24) & 0xff; | |
| 3971 rbuf[1] = (val >> 16) & 0xff; | |
| 3972 rbuf[2] = (val >> 8) & 0xff; | |
| 3973 rbuf[3] = val & 0xff; | |
| 3974 /* block size - always 512 bytes, for now */ | |
| 3975 rbuf[4] = 0; | |
| 3976 rbuf[5] = 0; | |
| 3977 rbuf[6] = 0x02; | |
| 3978 rbuf[7] = 0; | |
| 3979 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 3980 scsipkt->pkt_resid = 0; | |
| 3981 | |
| 3982 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", | |
| 3983 sdinfo->satadrv_capacity -1); | |
| 3984 } | |
| 3985 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 3986 /* | |
| 3987 * If a callback was requested, do it now. | |
| 3988 */ | |
| 3989 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 3990 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 3991 | |
| 3992 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 3993 scsipkt->pkt_comp != NULL) | |
| 3994 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3995 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3996 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3997 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3998 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
3999 return (TRAN_BUSY); |
| 1258 | 4000 |
| 4001 return (TRAN_ACCEPT); | |
| 4002 } | |
| 4003 | |
| 4004 /* | |
| 4005 * SATA translate command: Mode Sense. | |
| 4006 * Translated into appropriate SATA command or emulated. | |
| 4007 * Saved Values Page Control (03) are not supported. | |
| 4008 * | |
| 4009 * NOTE: only caching mode sense page is currently implemented. | |
| 4010 * | |
| 4011 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4012 */ | |
| 4013 | |
| 4014 static int | |
| 4015 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) | |
| 4016 { | |
| 4017 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4018 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4019 sata_drive_info_t *sdinfo; | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4020 sata_id_t *sata_id; |
| 1258 | 4021 struct scsi_extended_sense *sense; |
| 4022 int len, bdlen, count, alc_len; | |
| 4023 int pc; /* Page Control code */ | |
| 4024 uint8_t *buf; /* mode sense buffer */ | |
| 4025 int rval; | |
| 4026 | |
| 4027 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4028 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", | |
| 4029 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, | |
| 4030 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4031 | |
| 4032 buf = kmem_zalloc(1024, KM_SLEEP); | |
| 4033 | |
| 4034 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4035 | |
| 4036 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4037 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4038 kmem_free(buf, 1024); | |
| 4039 return (rval); | |
| 4040 } | |
| 4041 | |
| 4042 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4043 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4044 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4045 | |
| 4046 pc = scsipkt->pkt_cdbp[2] >> 6; | |
| 4047 | |
| 4048 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { | |
| 4049 len = 0; | |
| 4050 bdlen = 0; | |
| 4051 if (!(scsipkt->pkt_cdbp[1] & 8)) { | |
| 4052 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && | |
| 4053 (scsipkt->pkt_cdbp[0] & 0x10)) | |
| 4054 bdlen = 16; | |
| 4055 else | |
| 4056 bdlen = 8; | |
| 4057 } | |
| 4058 /* Build mode parameter header */ | |
| 4059 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4060 /* 4-byte mode parameter header */ | |
| 4061 buf[len++] = 0; /* mode data length */ | |
| 4062 buf[len++] = 0; /* medium type */ | |
| 4063 buf[len++] = 0; /* dev-specific param */ | |
| 4064 buf[len++] = bdlen; /* Block Descriptor length */ | |
| 4065 } else { | |
| 4066 /* 8-byte mode parameter header */ | |
| 4067 buf[len++] = 0; /* mode data length */ | |
| 4068 buf[len++] = 0; | |
| 4069 buf[len++] = 0; /* medium type */ | |
| 4070 buf[len++] = 0; /* dev-specific param */ | |
| 4071 if (bdlen == 16) | |
| 4072 buf[len++] = 1; /* long lba descriptor */ | |
| 4073 else | |
| 4074 buf[len++] = 0; | |
| 4075 buf[len++] = 0; | |
| 4076 buf[len++] = 0; /* Block Descriptor length */ | |
| 4077 buf[len++] = bdlen; | |
| 4078 } | |
| 4079 | |
| 4080 sdinfo = sata_get_device_info( | |
| 4081 spx->txlt_sata_hba_inst, | |
| 4082 &spx->txlt_sata_pkt->satapkt_device); | |
| 4083 | |
| 4084 /* Build block descriptor only if not disabled (DBD) */ | |
| 4085 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { | |
| 4086 /* Block descriptor - direct-access device format */ | |
| 4087 if (bdlen == 8) { | |
| 4088 /* build regular block descriptor */ | |
| 4089 buf[len++] = | |
| 4090 (sdinfo->satadrv_capacity >> 24) & 0xff; | |
| 4091 buf[len++] = | |
| 4092 (sdinfo->satadrv_capacity >> 16) & 0xff; | |
| 4093 buf[len++] = | |
| 4094 (sdinfo->satadrv_capacity >> 8) & 0xff; | |
| 4095 buf[len++] = sdinfo->satadrv_capacity & 0xff; | |
| 4096 buf[len++] = 0; /* density code */ | |
| 4097 buf[len++] = 0; | |
| 4098 if (sdinfo->satadrv_type == | |
| 4099 SATA_DTYPE_ATADISK) | |
| 4100 buf[len++] = 2; | |
| 4101 else | |
| 4102 /* ATAPI */ | |
| 4103 buf[len++] = 8; | |
| 4104 buf[len++] = 0; | |
| 4105 } else if (bdlen == 16) { | |
| 4106 /* Long LBA Accepted */ | |
| 4107 /* build long lba block descriptor */ | |
| 4108 #ifndef __lock_lint | |
| 4109 buf[len++] = | |
| 4110 (sdinfo->satadrv_capacity >> 56) & 0xff; | |
| 4111 buf[len++] = | |
| 4112 (sdinfo->satadrv_capacity >> 48) & 0xff; | |
| 4113 buf[len++] = | |
| 4114 (sdinfo->satadrv_capacity >> 40) & 0xff; | |
| 4115 buf[len++] = | |
| 4116 (sdinfo->satadrv_capacity >> 32) & 0xff; | |
| 4117 #endif | |
| 4118 buf[len++] = | |
| 4119 (sdinfo->satadrv_capacity >> 24) & 0xff; | |
| 4120 buf[len++] = | |
| 4121 (sdinfo->satadrv_capacity >> 16) & 0xff; | |
| 4122 buf[len++] = | |
| 4123 (sdinfo->satadrv_capacity >> 8) & 0xff; | |
| 4124 buf[len++] = sdinfo->satadrv_capacity & 0xff; | |
| 4125 buf[len++] = 0; | |
| 4126 buf[len++] = 0; /* density code */ | |
| 4127 buf[len++] = 0; | |
| 4128 buf[len++] = 0; | |
| 4129 if (sdinfo->satadrv_type == | |
| 4130 SATA_DTYPE_ATADISK) | |
| 4131 buf[len++] = 2; | |
| 4132 else | |
| 4133 /* ATAPI */ | |
| 4134 buf[len++] = 8; | |
| 4135 buf[len++] = 0; | |
| 4136 } | |
| 4137 } | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4138 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4139 sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4140 |
| 1258 | 4141 /* |
| 4142 * Add requested pages. | |
| 4143 * Page 3 and 4 are obsolete and we are not supporting them. | |
| 4144 * We deal now with: | |
| 4145 * caching (read/write cache control). | |
| 4146 * We should eventually deal with following mode pages: | |
| 4147 * error recovery (0x01), | |
| 4148 * power condition (0x1a), | |
| 4149 * exception control page (enables SMART) (0x1c), | |
| 4150 * enclosure management (ses), | |
| 4151 * protocol-specific port mode (port control). | |
| 4152 */ | |
| 4153 switch (scsipkt->pkt_cdbp[2] & 0x3f) { | |
| 4154 case MODEPAGE_RW_ERRRECOV: | |
| 4155 /* DAD_MODE_ERR_RECOV */ | |
| 4156 /* R/W recovery */ | |
| 4157 len += sata_build_msense_page_1(sdinfo, pc, buf+len); | |
| 4158 break; | |
| 4159 case MODEPAGE_CACHING: | |
| 4160 /* DAD_MODE_CACHE */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4161 /* Reject not supported request for saved parameters */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4162 if (pc == 3) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4163 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4164 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4165 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4166 sense->es_add_code = |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4167 SD_SCSI_SAVING_PARAMS_NOT_SUP; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4168 goto done; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4169 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4170 |
| 1258 | 4171 /* caching */ |
| 4172 len += sata_build_msense_page_8(sdinfo, pc, buf+len); | |
| 4173 break; | |
| 4174 case MODEPAGE_INFO_EXCPT: | |
| 4175 /* exception cntrl */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4176 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4177 len += sata_build_msense_page_1c(sdinfo, pc, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4178 buf+len); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4179 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4180 else |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4181 goto err; |
| 1258 | 4182 break; |
| 4183 case MODEPAGE_POWER_COND: | |
| 4184 /* DAD_MODE_POWER_COND */ | |
| 4185 /* power condition */ | |
| 4186 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); | |
| 4187 break; | |
| 4188 case MODEPAGE_ALLPAGES: | |
| 4189 /* all pages */ | |
| 4190 len += sata_build_msense_page_1(sdinfo, pc, buf+len); | |
| 4191 len += sata_build_msense_page_8(sdinfo, pc, buf+len); | |
| 4192 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
|
4193 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4194 len += sata_build_msense_page_1c(sdinfo, pc, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4195 buf+len); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4196 } |
| 1258 | 4197 break; |
| 4198 default: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4199 err: |
| 1258 | 4200 /* Invalid request */ |
| 4201 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4202 sense = sata_arq_sense(spx); | |
| 4203 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4204 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 4205 goto done; | |
| 4206 } | |
| 4207 | |
| 4208 /* fix total mode data length */ | |
| 4209 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4210 /* 4-byte mode parameter header */ | |
| 4211 buf[0] = len - 1; /* mode data length */ | |
| 4212 } else { | |
| 4213 buf[0] = (len -2) >> 8; | |
| 4214 buf[1] = (len -2) & 0xff; | |
| 4215 } | |
| 4216 | |
| 4217 | |
| 4218 /* Check allocation length */ | |
| 4219 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { | |
| 4220 alc_len = scsipkt->pkt_cdbp[4]; | |
| 4221 } else { | |
| 4222 alc_len = scsipkt->pkt_cdbp[7]; | |
| 4223 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; | |
| 4224 } | |
| 4225 /* | |
| 4226 * We do not check for possible parameters truncation | |
| 4227 * (alc_len < len) assuming that the target driver works | |
| 4228 * correctly. Just avoiding overrun. | |
| 4229 * Copy no more than requested and possible, buffer-wise. | |
| 4230 */ | |
| 4231 count = MIN(alc_len, len); | |
| 4232 count = MIN(bp->b_bcount, count); | |
| 4233 bcopy(buf, bp->b_un.b_addr, count); | |
| 4234 | |
| 4235 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4236 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; | |
| 4237 } | |
| 4238 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 4239 done: | |
| 4240 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4241 (void) kmem_free(buf, 1024); | |
| 4242 | |
| 4243 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4244 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4245 | |
| 4246 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4247 scsipkt->pkt_comp != NULL) | |
| 4248 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4249 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4250 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4251 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4252 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4253 return (TRAN_BUSY); |
| 1258 | 4254 |
| 4255 return (TRAN_ACCEPT); | |
| 4256 } | |
| 4257 | |
| 4258 | |
| 4259 /* | |
| 4260 * SATA translate command: Mode Select. | |
| 4261 * Translated into appropriate SATA command or emulated. | |
| 4262 * Saving parameters is not supported. | |
| 4263 * Changing device capacity is not supported (although theoretically | |
| 4264 * possible by executing SET FEATURES/SET MAX ADDRESS) | |
| 4265 * | |
| 4266 * Assumption is that the target driver is working correctly. | |
| 4267 * | |
| 4268 * More than one SATA command may be executed to perform operations specified | |
| 4269 * by mode select pages. The first error terminates further execution. | |
| 4270 * Operations performed successully are not backed-up in such case. | |
| 4271 * | |
| 4272 * NOTE: only caching mode select page is implemented. | |
| 4273 * Caching setup is remembered so it could be re-stored in case of | |
| 4274 * an unexpected device reset. | |
| 4275 * | |
| 4276 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 4277 */ | |
| 4278 | |
| 4279 static int | |
| 4280 sata_txlt_mode_select(sata_pkt_txlate_t *spx) | |
| 4281 { | |
| 4282 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4283 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 4284 struct scsi_extended_sense *sense; | |
| 4285 int len, pagelen, count, pllen; | |
| 4286 uint8_t *buf; /* mode select buffer */ | |
| 4287 int rval, stat; | |
| 4288 uint_t nointr_flag; | |
| 4289 int dmod = 0; | |
| 4290 | |
| 4291 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4292 "sata_txlt_mode_select, pc %x page code 0x%02x\n", | |
| 4293 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, | |
| 4294 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4295 | |
| 4296 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4297 | |
| 4298 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4299 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4300 return (rval); | |
| 4301 } | |
| 4302 | |
| 4303 rval = TRAN_ACCEPT; | |
| 4304 | |
| 4305 scsipkt->pkt_reason = CMD_CMPLT; | |
| 4306 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 4307 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 4308 | |
| 4309 /* Reject not supported request */ | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4310 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ |
| 1258 | 4311 *scsipkt->pkt_scbp = STATUS_CHECK; |
| 4312 sense = sata_arq_sense(spx); | |
| 4313 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4314 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; | |
| 4315 goto done; | |
| 4316 } | |
| 4317 | |
| 4318 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { | |
| 4319 pllen = scsipkt->pkt_cdbp[4]; | |
| 4320 } else { | |
| 4321 pllen = scsipkt->pkt_cdbp[7]; | |
| 4322 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; | |
| 4323 } | |
| 4324 | |
| 4325 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ | |
| 4326 | |
| 4327 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { | |
| 4328 buf = (uint8_t *)bp->b_un.b_addr; | |
| 4329 count = MIN(bp->b_bcount, pllen); | |
| 4330 scsipkt->pkt_state |= STATE_XFERRED_DATA; | |
| 4331 scsipkt->pkt_resid = 0; | |
| 4332 pllen = count; | |
| 4333 | |
| 4334 /* | |
| 4335 * Check the header to skip the block descriptor(s) - we | |
| 4336 * do not support setting device capacity. | |
| 4337 * Existing macros do not recognize long LBA dscriptor, | |
| 4338 * hence manual calculation. | |
| 4339 */ | |
| 4340 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { | |
| 4341 /* 6-bytes CMD, 4 bytes header */ | |
| 4342 if (count <= 4) | |
| 4343 goto done; /* header only */ | |
| 4344 len = buf[3] + 4; | |
| 4345 } else { | |
| 4346 /* 10-bytes CMD, 8 bytes header */ | |
| 4347 if (count <= 8) | |
| 4348 goto done; /* header only */ | |
| 4349 len = buf[6]; | |
| 4350 len = (len << 8) + buf[7] + 8; | |
| 4351 } | |
| 4352 if (len >= count) | |
| 4353 goto done; /* header + descriptor(s) only */ | |
| 4354 | |
| 4355 pllen -= len; /* remaining data length */ | |
| 4356 | |
| 4357 /* | |
| 4358 * We may be executing SATA command and want to execute it | |
| 4359 * in SYNCH mode, regardless of scsi_pkt setting. | |
| 4360 * Save scsi_pkt setting and indicate SYNCH mode | |
| 4361 */ | |
| 4362 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; | |
| 4363 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4364 scsipkt->pkt_comp != NULL) { | |
| 4365 scsipkt->pkt_flags |= FLAG_NOINTR; | |
| 4366 } | |
| 4367 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; | |
| 4368 | |
| 4369 /* | |
| 4370 * len is now the offset to a first mode select page | |
| 4371 * Process all pages | |
| 4372 */ | |
| 4373 while (pllen > 0) { | |
| 4374 switch ((int)buf[len]) { | |
| 4375 case MODEPAGE_CACHING: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4376 /* No support for SP (saving) */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4377 if (scsipkt->pkt_cdbp[1] & 0x01) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4378 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4379 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4380 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4381 sense->es_add_code = |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4382 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4383 goto done; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4384 } |
| 1258 | 4385 stat = sata_mode_select_page_8(spx, |
| 4386 (struct mode_cache_scsi3 *)&buf[len], | |
| 4387 pllen, &pagelen, &rval, &dmod); | |
| 4388 /* | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4389 * The pagelen value indicates the number of |
| 1258 | 4390 * parameter bytes already processed. |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4391 * The rval is the return value from |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4392 * sata_tran_start(). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4393 * The stat indicates the overall status of |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4394 * the operation(s). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4395 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4396 if (stat != SATA_SUCCESS) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4397 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4398 * Page processing did not succeed - |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4399 * all error info is already set-up, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4400 * just return |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4401 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4402 pllen = 0; /* this breaks the loop */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4403 else { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4404 len += pagelen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4405 pllen -= pagelen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4406 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4407 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4408 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4409 case MODEPAGE_INFO_EXCPT: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4410 stat = sata_mode_select_page_1c(spx, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4411 (struct mode_info_excpt_page *)&buf[len], |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4412 pllen, &pagelen, &rval, &dmod); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4413 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4414 * The pagelen value indicates the number of |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4415 * parameter bytes already processed. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
4416 * The rval is the return value from |
| 1258 | 4417 * sata_tran_start(). |
| 4418 * The stat indicates the overall status of | |
| 4419 * the operation(s). | |
| 4420 */ | |
| 4421 if (stat != SATA_SUCCESS) | |
| 4422 /* | |
| 4423 * Page processing did not succeed - | |
| 4424 * all error info is already set-up, | |
| 4425 * just return | |
| 4426 */ | |
| 4427 pllen = 0; /* this breaks the loop */ | |
| 4428 else { | |
| 4429 len += pagelen; | |
| 4430 pllen -= pagelen; | |
| 4431 } | |
| 4432 break; | |
| 4433 | |
| 4434 default: | |
| 4435 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4436 sense = sata_arq_sense(spx); | |
| 4437 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 4438 sense->es_add_code = | |
| 4439 SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; | |
| 4440 goto done; | |
| 4441 } | |
| 4442 } | |
| 4443 } | |
| 4444 done: | |
| 4445 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4446 /* | |
| 4447 * If device parameters were modified, fetch and store the new | |
| 4448 * Identify Device data. Since port mutex could have been released | |
| 4449 * for accessing HBA driver, we need to re-check device existence. | |
| 4450 */ | |
| 4451 if (dmod != 0) { | |
| 4452 sata_drive_info_t new_sdinfo, *sdinfo; | |
| 4453 int rv; | |
| 4454 | |
| 4455 new_sdinfo.satadrv_addr = | |
| 4456 spx->txlt_sata_pkt->satapkt_device.satadev_addr; | |
| 4457 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, | |
| 4458 &new_sdinfo); | |
| 4459 | |
| 4460 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4461 /* | |
| 4462 * Since port mutex could have been released when | |
| 4463 * accessing HBA driver, we need to re-check that the | |
| 4464 * framework still holds the device info structure. | |
| 4465 */ | |
| 4466 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 4467 &spx->txlt_sata_pkt->satapkt_device); | |
| 4468 if (sdinfo != NULL) { | |
| 4469 /* | |
| 4470 * Device still has info structure in the | |
| 4471 * sata framework. Copy newly fetched info | |
| 4472 */ | |
| 4473 if (rv == 0) { | |
| 4474 sdinfo->satadrv_id = new_sdinfo.satadrv_id; | |
| 4475 sata_save_drive_settings(sdinfo); | |
| 4476 } else { | |
| 4477 /* | |
| 4478 * Could not fetch new data - invalidate | |
| 4479 * sata_drive_info. That makes device | |
| 4480 * unusable. | |
| 4481 */ | |
| 4482 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 4483 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 4484 } | |
| 4485 } | |
| 4486 if (rv != 0 || sdinfo == NULL) { | |
| 4487 /* | |
| 4488 * This changes the overall mode select completion | |
| 4489 * reason to a failed one !!!!! | |
| 4490 */ | |
| 4491 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 4492 sense = sata_arq_sense(spx); | |
| 4493 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 4494 rval = TRAN_ACCEPT; | |
| 4495 } | |
| 4496 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4497 } | |
| 4498 /* Restore the scsi pkt flags */ | |
| 4499 scsipkt->pkt_flags &= ~FLAG_NOINTR; | |
| 4500 scsipkt->pkt_flags |= nointr_flag; | |
| 4501 | |
| 4502 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4503 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 4504 | |
| 4505 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 4506 scsipkt->pkt_comp != NULL) | |
| 4507 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4508 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4509 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4510 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4511 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4512 return (TRAN_BUSY); |
| 1258 | 4513 |
| 4514 return (rval); | |
| 4515 } | |
| 4516 | |
| 4517 | |
| 4518 | |
| 4519 /* | |
| 4520 * Translate command: Log Sense | |
| 4521 */ | |
| 4522 static int | |
| 4523 sata_txlt_log_sense(sata_pkt_txlate_t *spx) | |
| 4524 { | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4525 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4526 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
|
4527 sata_drive_info_t *sdinfo; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4528 struct scsi_extended_sense *sense; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4529 int len, count, alc_len; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4530 int pc; /* Page Control code */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4531 int page_code; /* Page code */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4532 uint8_t *buf; /* log sense buffer */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4533 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4534 #define MAX_LOG_SENSE_PAGE_SIZE 512 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4535 |
| 1258 | 4536 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
|
4537 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", |
| 1258 | 4538 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, |
| 4539 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); | |
| 4540 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4541 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
|
4542 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4543 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4544 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4545 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
|
4546 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4547 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4548 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4549 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4550 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4551 scsipkt->pkt_reason = CMD_CMPLT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4552 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
|
4553 STATE_SENT_CMD | STATE_GOT_STATUS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4554 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4555 pc = scsipkt->pkt_cdbp[2] >> 6; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4556 page_code = scsipkt->pkt_cdbp[2] & 0x3f; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4557 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4558 /* Reject not supported request for all but cummulative values */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4559 switch (pc) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4560 case PC_CUMMULATIVE_VALUES: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4561 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4562 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4563 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4564 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4565 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4566 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
|
4567 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4568 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4569 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4570 switch (page_code) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4571 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4572 case PAGE_CODE_SELF_TEST_RESULTS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4573 case PAGE_CODE_INFORMATION_EXCEPTIONS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4574 case PAGE_CODE_SMART_READ_DATA: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4575 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4576 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4577 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4578 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4579 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4580 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
|
4581 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4582 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4583 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4584 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
|
4585 sata_id_t *sata_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4586 len = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4587 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4588 /* Build log parameter header */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4589 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
|
4590 buf[len++] = 0; /* reserved */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4591 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
|
4592 buf[len++] = 0; /* (LSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4593 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4594 sdinfo = sata_get_device_info( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4595 spx->txlt_sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4596 &spx->txlt_sata_pkt->satapkt_device); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4597 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4598 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4599 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4600 * Add requested pages. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4601 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4602 switch (page_code) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4603 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4604 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
|
4605 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4606 case PAGE_CODE_SELF_TEST_RESULTS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4607 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4608 if ((! (sata_id->ai_cmdset84 & |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4609 SATA_SMART_SELF_TEST_SUPPORTED)) || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4610 (! (sata_id->ai_features87 & |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4611 SATA_SMART_SELF_TEST_SUPPORTED))) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4612 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4613 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4614 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4615 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4616 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4617 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4618 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4619 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4620 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
|
4621 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4622 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4623 case PAGE_CODE_INFORMATION_EXCEPTIONS: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4624 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4625 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4626 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4627 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4628 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4629 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4630 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4631 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4632 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4633 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4634 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4635 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4636 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4637 sense->es_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4638 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4639 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4640 sense->es_qual_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4641 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4642 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4643 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4644 } |
|
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 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
|
4647 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4648 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4649 case PAGE_CODE_SMART_READ_DATA: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4650 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4651 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4652 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4653 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4654 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4655 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4656 SD_SCSI_INVALID_FIELD_IN_CDB; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4657 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4658 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4659 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4660 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4661 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4662 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4663 sense->es_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4664 sense->es_add_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4665 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4666 sense->es_qual_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4667 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4668 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4669 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4670 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4671 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4672 /* This page doesn't include a page header */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4673 len = sata_build_lsense_page_30(sdinfo, buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4674 spx->txlt_sata_hba_inst); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4675 goto no_header; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4676 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4677 /* Invalid request */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4678 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4679 sense = sata_arq_sense(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4680 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4681 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
|
4682 goto done; |
|
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 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4685 /* set parameter log sense data length */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4686 buf[2] = len >> 8; /* log sense length (MSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4687 buf[3] = len & 0xff; /* log sense length (LSB) */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4688 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4689 len += SCSI_LOG_PAGE_HDR_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4690 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4691 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4692 no_header: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4693 /* Check allocation length */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4694 alc_len = scsipkt->pkt_cdbp[7]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4695 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4696 |
|
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 * We do not check for possible parameters truncation |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4699 * (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
|
4700 * correctly. Just avoiding overrun. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4701 * 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
|
4702 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4703 count = MIN(alc_len, len); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4704 count = MIN(bp->b_bcount, count); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4705 bcopy(buf, bp->b_un.b_addr, count); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4706 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4707 scsipkt->pkt_state |= STATE_XFERRED_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4708 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
|
4709 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4710 *scsipkt->pkt_scbp = STATUS_GOOD; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4711 done: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4712 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4713 (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
|
4714 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4715 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
|
4716 "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
|
4717 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4718 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4719 scsipkt->pkt_comp != NULL) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4720 /* scsi callback required */ |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4721 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4722 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4723 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4724 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
4725 return (TRAN_BUSY); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4726 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4727 return (TRAN_ACCEPT); |
| 1258 | 4728 } |
| 4729 | |
| 4730 /* | |
| 4731 * Translate command: Log Select | |
| 4732 * Not implemented at this time - returns invalid command response. | |
| 4733 */ | |
| 4734 static int | |
| 4735 sata_txlt_log_select(sata_pkt_txlate_t *spx) | |
| 4736 { | |
| 4737 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4738 "sata_txlt_log_select\n", NULL); | |
| 4739 | |
| 4740 return (sata_txlt_invalid_command(spx)); | |
| 4741 } | |
| 4742 | |
| 4743 | |
| 4744 /* | |
| 4745 * Translate command: Read (various types). | |
| 4746 * Translated into appropriate type of ATA READ command | |
| 4747 * (NO ATAPI implementation yet). | |
| 4748 * Both the device capabilities and requested operation mode are | |
| 4749 * considered. | |
| 4750 * | |
| 4751 * Following scsi cdb fields are ignored: | |
| 4752 * rdprotect, dpo, fua, fua_nv, group_number. | |
| 4753 * | |
| 4754 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework | |
| 4755 * enable variable sata_func_enable), the capability of the controller and | |
| 4756 * capability of a device are checked and if both support queueing, read | |
| 4757 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT | |
| 4758 * command rather than plain READ_XXX command. | |
| 4759 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and | |
| 4760 * both the controller and device suport such functionality, the read | |
| 4761 * request will be translated to READ_FPDMA_QUEUED command. | |
| 4762 * | |
| 4763 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 4764 * appropriate values in scsi_pkt fields. | |
| 4765 */ | |
| 4766 static int | |
| 4767 sata_txlt_read(sata_pkt_txlate_t *spx) | |
| 4768 { | |
| 4769 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4770 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 4771 sata_drive_info_t *sdinfo; | |
| 4772 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 4773 int cport = SATA_TXLT_CPORT(spx); | |
| 4774 uint16_t sec_count; | |
| 4775 uint64_t lba; | |
| 4776 int rval; | |
| 4777 int synch; | |
| 4778 | |
| 4779 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4780 | |
| 4781 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4782 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4783 return (rval); | |
| 4784 } | |
| 4785 | |
| 4786 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 4787 &spx->txlt_sata_pkt->satapkt_device); | |
| 4788 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4789 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
| 1258 | 4790 /* |
| 4791 * Build cmd block depending on the device capability and | |
| 4792 * requested operation mode. | |
| 4793 * Do not bother with non-dma mode. | |
| 4794 */ | |
| 4795 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 4796 case SCMD_READ: | |
| 4797 /* 6-byte scsi read cmd : 0x08 */ | |
| 4798 lba = (scsipkt->pkt_cdbp[1] & 0x1f); | |
| 4799 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; | |
| 4800 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4801 sec_count = scsipkt->pkt_cdbp[4]; | |
| 4802 /* sec_count 0 will be interpreted as 256 by a device */ | |
| 4803 break; | |
| 4804 case SCMD_READ_G1: | |
| 4805 /* 10-bytes scsi read command : 0x28 */ | |
| 4806 lba = scsipkt->pkt_cdbp[2]; | |
| 4807 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4808 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 4809 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 4810 sec_count = scsipkt->pkt_cdbp[7]; | |
| 4811 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 4812 break; | |
| 4813 case SCMD_READ_G5: | |
| 4814 /* 12-bytes scsi read command : 0xA8 */ | |
| 4815 lba = scsipkt->pkt_cdbp[2]; | |
| 4816 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4817 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 4818 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 4819 sec_count = scsipkt->pkt_cdbp[6]; | |
| 4820 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; | |
| 4821 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 4822 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; | |
| 4823 break; | |
| 4824 case SCMD_READ_G4: | |
| 4825 /* 16-bytes scsi read command : 0x88 */ | |
| 4826 lba = scsipkt->pkt_cdbp[2]; | |
| 4827 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 4828 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 4829 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 4830 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; | |
| 4831 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; | |
| 4832 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; | |
| 4833 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; | |
| 4834 sec_count = scsipkt->pkt_cdbp[10]; | |
| 4835 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; | |
| 4836 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; | |
| 4837 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; | |
| 4838 break; | |
| 4839 default: | |
| 4840 /* Unsupported command */ | |
| 4841 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4842 return (sata_txlt_invalid_command(spx)); | |
| 4843 } | |
| 4844 | |
| 4845 /* | |
| 4846 * Check if specified address exceeds device capacity | |
| 4847 */ | |
| 4848 if ((lba >= sdinfo->satadrv_capacity) || | |
| 4849 ((lba + sec_count) >= sdinfo->satadrv_capacity)) { | |
| 4850 /* LBA out of range */ | |
| 4851 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4852 return (sata_txlt_lba_out_of_range(spx)); | |
| 4853 } | |
| 4854 | |
| 4855 scmd->satacmd_addr_type = ATA_ADDR_LBA; | |
| 4856 scmd->satacmd_device_reg = SATA_ADH_LBA; | |
| 4857 scmd->satacmd_cmd_reg = SATAC_READ_DMA; | |
| 4858 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { | |
| 4859 scmd->satacmd_addr_type = ATA_ADDR_LBA48; | |
| 4860 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; | |
| 4861 scmd->satacmd_sec_count_msb = sec_count >> 8; | |
| 4862 #ifndef __lock_lint | |
| 4863 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; | |
| 4864 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; | |
| 4865 scmd->satacmd_lba_high_msb = lba >> 40; | |
| 4866 #endif | |
| 4867 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { | |
| 4868 scmd->satacmd_addr_type = ATA_ADDR_LBA28; | |
| 4869 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); | |
| 4870 } | |
| 4871 scmd->satacmd_sec_count_lsb = sec_count & 0xff; | |
| 4872 scmd->satacmd_lba_low_lsb = lba & 0xff; | |
| 4873 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; | |
| 4874 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; | |
| 4875 scmd->satacmd_features_reg = 0; | |
| 4876 scmd->satacmd_status_reg = 0; | |
| 4877 scmd->satacmd_error_reg = 0; | |
| 4878 | |
| 4879 /* | |
| 4880 * Check if queueing commands should be used and switch | |
| 4881 * to appropriate command if possible | |
| 4882 */ | |
| 4883 if (sata_func_enable & SATA_ENABLE_QUEUING) { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4884 boolean_t using_queuing; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4885 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4886 /* Queuing supported by controller and device? */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4887 if ((sata_func_enable & SATA_ENABLE_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4888 (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4889 SATA_DEV_F_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4890 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4891 SATA_CTLF_NCQ)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4892 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4893 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4894 /* NCQ supported - use FPDMA READ */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4895 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4896 SATAC_READ_FPDMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4897 scmd->satacmd_features_reg_ext = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4898 scmd->satacmd_sec_count_msb; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4899 scmd->satacmd_sec_count_msb = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4900 scmd->satacmd_rle_sata_cmd = NULL; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4901 } else if ((sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4902 SATA_DEV_F_TCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4903 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4904 SATA_CTLF_QCMD)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4905 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4906 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4907 /* Legacy queueing */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4908 if (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4909 SATA_DEV_F_LBA48) { |
| 1258 | 4910 scmd->satacmd_cmd_reg = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4911 SATAC_READ_DMA_QUEUED_EXT; |
| 1258 | 4912 scmd->satacmd_features_reg_ext = |
| 4913 scmd->satacmd_sec_count_msb; | |
| 4914 scmd->satacmd_sec_count_msb = 0; | |
| 4915 } else { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4916 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4917 SATAC_READ_DMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4918 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4919 } else /* Queuing not supported */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4920 using_queuing = B_FALSE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4921 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4922 /* |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4923 * 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
|
4924 * and the secount count will contain the tag. |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4925 */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
4926 if (using_queuing) { |
| 1258 | 4927 scmd->satacmd_features_reg = |
| 4928 scmd->satacmd_sec_count_lsb; | |
| 4929 scmd->satacmd_sec_count_lsb = 0; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
4930 scmd->satacmd_flags.sata_queued = B_TRUE; |
| 1258 | 4931 } |
| 4932 } | |
| 4933 | |
| 4934 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, | |
| 4935 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", | |
| 4936 scmd->satacmd_cmd_reg, lba, sec_count); | |
| 4937 | |
| 4938 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 4939 /* Need callback function */ | |
| 4940 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; | |
| 4941 synch = FALSE; | |
| 4942 } else | |
| 4943 synch = TRUE; | |
| 4944 | |
| 4945 /* Transfer command to HBA */ | |
| 4946 if (sata_hba_start(spx, &rval) != 0) { | |
| 4947 /* Pkt not accepted for execution */ | |
| 4948 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 4949 return (rval); | |
| 4950 } | |
| 4951 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 4952 /* | |
| 4953 * If execution is non-synchronous, | |
| 4954 * a callback function will handle potential errors, translate | |
| 4955 * the response and will do a callback to a target driver. | |
| 4956 * If it was synchronous, check execution status using the same | |
| 4957 * framework callback. | |
| 4958 */ | |
| 4959 if (synch) { | |
| 4960 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 4961 "synchronous execution status %x\n", | |
| 4962 spx->txlt_sata_pkt->satapkt_reason); | |
| 4963 sata_txlt_rw_completion(spx->txlt_sata_pkt); | |
| 4964 } | |
| 4965 return (TRAN_ACCEPT); | |
| 4966 } | |
| 4967 | |
| 4968 | |
| 4969 /* | |
| 4970 * SATA translate command: Write (various types) | |
| 4971 * Translated into appropriate type of ATA WRITE command | |
| 4972 * (NO ATAPI implementation yet). | |
| 4973 * Both the device capabilities and requested operation mode are | |
| 4974 * considered. | |
| 4975 * | |
| 4976 * Following scsi cdb fields are ignored: | |
| 4977 * rwprotect, dpo, fua, fua_nv, group_number. | |
| 4978 * | |
| 4979 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 4980 * appropriate values in scsi_pkt fields. | |
| 4981 */ | |
| 4982 static int | |
| 4983 sata_txlt_write(sata_pkt_txlate_t *spx) | |
| 4984 { | |
| 4985 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 4986 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 4987 sata_drive_info_t *sdinfo; | |
| 4988 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 4989 int cport = SATA_TXLT_CPORT(spx); | |
| 4990 uint16_t sec_count; | |
| 4991 uint64_t lba; | |
| 4992 int rval; | |
| 4993 int synch; | |
| 4994 | |
| 4995 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4996 | |
| 4997 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 4998 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 4999 return (rval); | |
| 5000 } | |
| 5001 | |
| 5002 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 5003 &spx->txlt_sata_pkt->satapkt_device); | |
| 5004 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5005 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; |
| 1258 | 5006 /* |
| 5007 * Build cmd block depending on the device capability and | |
| 5008 * requested operation mode. | |
| 5009 * Do not bother with non-dma mode. | |
| 5010 */ | |
| 5011 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 5012 case SCMD_WRITE: | |
| 5013 /* 6-byte scsi read cmd : 0x0A */ | |
| 5014 lba = (scsipkt->pkt_cdbp[1] & 0x1f); | |
| 5015 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; | |
| 5016 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5017 sec_count = scsipkt->pkt_cdbp[4]; | |
| 5018 /* sec_count 0 will be interpreted as 256 by a device */ | |
| 5019 break; | |
| 5020 case SCMD_WRITE_G1: | |
| 5021 /* 10-bytes scsi write command : 0x2A */ | |
| 5022 lba = scsipkt->pkt_cdbp[2]; | |
| 5023 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5024 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5025 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5026 sec_count = scsipkt->pkt_cdbp[7]; | |
| 5027 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5028 break; | |
| 5029 case SCMD_WRITE_G5: | |
| 5030 /* 12-bytes scsi read command : 0xAA */ | |
| 5031 lba = scsipkt->pkt_cdbp[2]; | |
| 5032 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5033 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5034 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5035 sec_count = scsipkt->pkt_cdbp[6]; | |
| 5036 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; | |
| 5037 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; | |
| 5038 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; | |
| 5039 break; | |
| 5040 case SCMD_WRITE_G4: | |
| 5041 /* 16-bytes scsi write command : 0x8A */ | |
| 5042 lba = scsipkt->pkt_cdbp[2]; | |
| 5043 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; | |
| 5044 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; | |
| 5045 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; | |
| 5046 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; | |
| 5047 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; | |
| 5048 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; | |
| 5049 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; | |
| 5050 sec_count = scsipkt->pkt_cdbp[10]; | |
| 5051 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; | |
| 5052 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; | |
| 5053 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; | |
| 5054 break; | |
| 5055 default: | |
| 5056 /* Unsupported command */ | |
| 5057 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5058 return (sata_txlt_invalid_command(spx)); | |
| 5059 } | |
| 5060 | |
| 5061 /* | |
| 5062 * Check if specified address and length exceeds device capacity | |
| 5063 */ | |
| 5064 if ((lba >= sdinfo->satadrv_capacity) || | |
| 5065 ((lba + sec_count) >= sdinfo->satadrv_capacity)) { | |
| 5066 /* LBA out of range */ | |
| 5067 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5068 return (sata_txlt_lba_out_of_range(spx)); | |
| 5069 } | |
| 5070 | |
| 5071 scmd->satacmd_addr_type = ATA_ADDR_LBA; | |
| 5072 scmd->satacmd_device_reg = SATA_ADH_LBA; | |
| 5073 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; | |
| 5074 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { | |
| 5075 scmd->satacmd_addr_type = ATA_ADDR_LBA48; | |
| 5076 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; | |
| 5077 scmd->satacmd_sec_count_msb = sec_count >> 8; | |
| 5078 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; | |
| 5079 #ifndef __lock_lint | |
| 5080 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; | |
| 5081 scmd->satacmd_lba_high_msb = lba >> 40; | |
| 5082 #endif | |
| 5083 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { | |
| 5084 scmd->satacmd_addr_type = ATA_ADDR_LBA28; | |
| 5085 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); | |
| 5086 } | |
| 5087 scmd->satacmd_sec_count_lsb = sec_count & 0xff; | |
| 5088 scmd->satacmd_lba_low_lsb = lba & 0xff; | |
| 5089 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; | |
| 5090 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; | |
| 5091 scmd->satacmd_features_reg = 0; | |
| 5092 scmd->satacmd_status_reg = 0; | |
| 5093 scmd->satacmd_error_reg = 0; | |
| 5094 | |
| 5095 /* | |
| 5096 * Check if queueing commands should be used and switch | |
| 5097 * to appropriate command if possible | |
| 5098 */ | |
| 5099 if (sata_func_enable & SATA_ENABLE_QUEUING) { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5100 boolean_t using_queuing; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5101 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5102 /* Queuing supported by controller and device? */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5103 if ((sata_func_enable & SATA_ENABLE_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5104 (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5105 SATA_DEV_F_NCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5106 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5107 SATA_CTLF_NCQ)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5108 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5109 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5110 /* NCQ supported - use FPDMA WRITE */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5111 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5112 SATAC_WRITE_FPDMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5113 scmd->satacmd_features_reg_ext = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5114 scmd->satacmd_sec_count_msb; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5115 scmd->satacmd_sec_count_msb = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5116 scmd->satacmd_rle_sata_cmd = NULL; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5117 } else if ((sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5118 SATA_DEV_F_TCQ) && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5119 (SATA_FEATURES(spx->txlt_sata_hba_inst) & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5120 SATA_CTLF_QCMD)) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5121 using_queuing = B_TRUE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5122 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5123 /* Legacy queueing */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5124 if (sdinfo->satadrv_features_support & |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5125 SATA_DEV_F_LBA48) { |
| 1258 | 5126 scmd->satacmd_cmd_reg = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5127 SATAC_WRITE_DMA_QUEUED_EXT; |
| 1258 | 5128 scmd->satacmd_features_reg_ext = |
| 5129 scmd->satacmd_sec_count_msb; | |
| 5130 scmd->satacmd_sec_count_msb = 0; | |
| 5131 } else { | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5132 scmd->satacmd_cmd_reg = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5133 SATAC_WRITE_DMA_QUEUED; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5134 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5135 } else /* Queuing not supported */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5136 using_queuing = B_FALSE; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5137 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
5138 if (using_queuing) { |
| 1258 | 5139 scmd->satacmd_features_reg = |
| 5140 scmd->satacmd_sec_count_lsb; | |
| 5141 scmd->satacmd_sec_count_lsb = 0; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5142 scmd->satacmd_flags.sata_queued = B_TRUE; |
| 1258 | 5143 } |
| 5144 } | |
| 5145 | |
| 5146 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5147 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", | |
| 5148 scmd->satacmd_cmd_reg, lba, sec_count); | |
| 5149 | |
| 5150 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5151 /* Need callback function */ | |
| 5152 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; | |
| 5153 synch = FALSE; | |
| 5154 } else | |
| 5155 synch = TRUE; | |
| 5156 | |
| 5157 /* Transfer command to HBA */ | |
| 5158 if (sata_hba_start(spx, &rval) != 0) { | |
| 5159 /* Pkt not accepted for execution */ | |
| 5160 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5161 return (rval); | |
| 5162 } | |
| 5163 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5164 | |
| 5165 /* | |
| 5166 * If execution is non-synchronous, | |
| 5167 * a callback function will handle potential errors, translate | |
| 5168 * the response and will do a callback to a target driver. | |
| 5169 * If it was synchronous, check execution status using the same | |
| 5170 * framework callback. | |
| 5171 */ | |
| 5172 if (synch) { | |
| 5173 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5174 "synchronous execution status %x\n", | |
| 5175 spx->txlt_sata_pkt->satapkt_reason); | |
| 5176 sata_txlt_rw_completion(spx->txlt_sata_pkt); | |
| 5177 } | |
| 5178 return (TRAN_ACCEPT); | |
| 5179 } | |
| 5180 | |
| 5181 | |
| 5182 /* | |
| 5183 * NOTE: NOT FUNCTIONAL IMPLEMENTATION. THIS IS A PLACEHOLDER for the function | |
| 5184 * that will be fixed in phase 2 of the development. | |
| 5185 * Currently ATAPI is not supported. ATAPI devices are threated as not-valid | |
| 5186 * devices. | |
| 5187 * This function is not called, since scsi_sata_start() will bail-out prior | |
| 5188 * to calling it. | |
| 5189 */ | |
| 5190 static int | |
| 5191 sata_txlt_atapi(sata_pkt_txlate_t *spx) | |
| 5192 { | |
| 5193 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5194 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5195 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 5196 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); | |
| 5197 int cport = SATA_TXLT_CPORT(spx); | |
| 5198 int rval; | |
| 5199 int synch; | |
| 5200 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; | |
| 5201 | |
| 5202 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5203 | |
| 5204 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 5205 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5206 return (rval); | |
| 5207 } | |
| 5208 | |
| 5209 /* | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5210 * scmd->satacmd_flags.sata_data_direction default - |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5211 * SATA_DIR_NODATA_XFER - is set by |
| 1258 | 5212 * sata_txlt_generic_pkt_info(). |
| 5213 */ | |
| 5214 if (scmd->satacmd_bp) { | |
| 5215 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
|
5216 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; |
| 1258 | 5217 } else { |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5218 scmd->satacmd_flags.sata_data_direction = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5219 SATA_DIR_WRITE; |
| 1258 | 5220 } |
| 5221 } | |
| 5222 | |
| 5223 scmd->satacmd_acdb_len = scsi_cdb_size[GETGROUP(cdbp)]; | |
| 5224 scmd->satacmd_cmd_reg = SATAC_PACKET; | |
| 5225 bcopy(cdbp, scmd->satacmd_acdb, 16); | |
| 5226 | |
| 5227 /* | |
| 5228 * For non-read/write commands we need to | |
| 5229 * map buffer | |
| 5230 */ | |
| 5231 switch ((uint_t)scsipkt->pkt_cdbp[0]) { | |
| 5232 case SCMD_READ: | |
| 5233 case SCMD_READ_G1: | |
| 5234 case SCMD_READ_G5: | |
| 5235 case SCMD_READ_G4: | |
| 5236 case SCMD_WRITE: | |
| 5237 case SCMD_WRITE_G1: | |
| 5238 case SCMD_WRITE_G5: | |
| 5239 case SCMD_WRITE_G4: | |
| 5240 break; | |
| 5241 default: | |
| 5242 if (bp->b_flags & (B_PHYS | B_PAGEIO)) | |
| 5243 bp_mapin(bp); | |
| 5244 break; | |
| 5245 } | |
| 5246 | |
| 5247 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5248 /* Need callback function */ | |
| 5249 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; | |
| 5250 synch = FALSE; | |
| 5251 } else | |
| 5252 synch = TRUE; | |
| 5253 | |
| 5254 /* Transfer command to HBA */ | |
| 5255 if (sata_hba_start(spx, &rval) != 0) { | |
| 5256 /* Pkt not accepted for execution */ | |
| 5257 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5258 return (rval); | |
| 5259 } | |
| 5260 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 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_atapi_completion(spx->txlt_sata_pkt); | |
| 5273 } | |
| 5274 return (TRAN_ACCEPT); | |
| 5275 } | |
| 5276 | |
| 5277 /* | |
| 5278 * Translate command: Synchronize Cache. | |
| 5279 * Translates into Flush Cache command. | |
| 5280 * (NO ATAPI implementation yet). | |
| 5281 * | |
| 5282 * NOTE: We should check if Flush Cache is supported by the device (ATAPI | |
| 5283 * devices) | |
| 5284 * | |
| 5285 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and | |
| 5286 * appropriate values in scsi_pkt fields. | |
| 5287 */ | |
| 5288 static int | |
| 5289 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) | |
| 5290 { | |
| 5291 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 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 | |
| 5297 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5298 | |
| 5299 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { | |
| 5300 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); | |
| 5301 return (rval); | |
| 5302 } | |
| 5303 | |
| 5304 scmd->satacmd_addr_type = 0; | |
| 5305 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; | |
| 5306 scmd->satacmd_device_reg = 0; | |
| 5307 scmd->satacmd_sec_count_lsb = 0; | |
| 5308 scmd->satacmd_lba_low_lsb = 0; | |
| 5309 scmd->satacmd_lba_mid_lsb = 0; | |
| 5310 scmd->satacmd_lba_high_lsb = 0; | |
| 5311 scmd->satacmd_features_reg = 0; | |
| 5312 scmd->satacmd_status_reg = 0; | |
| 5313 scmd->satacmd_error_reg = 0; | |
| 5314 | |
| 5315 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5316 "sata_txlt_synchronize_cache\n", NULL); | |
| 5317 | |
| 5318 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { | |
| 5319 /* Need to set-up a callback function */ | |
| 5320 spx->txlt_sata_pkt->satapkt_comp = | |
| 5321 sata_txlt_nodata_cmd_completion; | |
| 5322 synch = FALSE; | |
| 5323 } else | |
| 5324 synch = TRUE; | |
| 5325 | |
| 5326 /* Transfer command to HBA */ | |
| 5327 if (sata_hba_start(spx, &rval) != 0) { | |
| 5328 /* Pkt not accepted for execution */ | |
| 5329 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5330 return (rval); | |
| 5331 } | |
| 5332 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); | |
| 5333 | |
| 5334 /* | |
| 5335 * If execution non-synchronous, it had to be completed | |
| 5336 * a callback function will handle potential errors, translate | |
| 5337 * the response and will do a callback to a target driver. | |
| 5338 * If it was synchronous, check status, using the same | |
| 5339 * framework callback. | |
| 5340 */ | |
| 5341 if (synch) { | |
| 5342 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5343 "synchronous execution status %x\n", | |
| 5344 spx->txlt_sata_pkt->satapkt_reason); | |
| 5345 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); | |
| 5346 } | |
| 5347 return (TRAN_ACCEPT); | |
| 5348 } | |
| 5349 | |
| 5350 /* | |
| 5351 * Send pkt to SATA HBA driver | |
| 5352 * | |
| 5353 * This function may be called only if the operation is requested by scsi_pkt, | |
| 5354 * i.e. scsi_pkt is not NULL. | |
| 5355 * | |
| 5356 * This function has to be called with cport mutex held. It does release | |
| 5357 * the mutex when it calls HBA driver sata_tran_start function and | |
| 5358 * re-acquires it afterwards. | |
| 5359 * | |
| 5360 * If return value is 0, pkt was accepted, -1 otherwise | |
| 5361 * rval is set to appropriate sata_scsi_start return value. | |
| 5362 * | |
| 5363 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not | |
| 5364 * have called the sata_pkt callback function for this packet. | |
| 5365 * | |
| 5366 * The scsi callback has to be performed by the caller of this routine. | |
| 5367 * | |
| 5368 * Note 2: No port multiplier support for now. | |
| 5369 */ | |
| 5370 static int | |
| 5371 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) | |
| 5372 { | |
| 5373 int stat; | |
| 5374 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; | |
| 5375 sata_drive_info_t *sdinfo; | |
| 5376 sata_device_t sata_device; | |
| 5377 uint8_t cmd; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5378 struct sata_cmd_flags cmd_flags; |
| 1258 | 5379 |
| 5380 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 5381 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(spx->txlt_sata_hba_inst, | |
| 5382 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport))); | |
| 5383 | |
| 5384 sdinfo = sata_get_device_info(sata_hba_inst, | |
| 5385 &spx->txlt_sata_pkt->satapkt_device); | |
| 5386 ASSERT(sdinfo != NULL); | |
| 5387 | |
| 5388 /* Clear device reset state? */ | |
| 5389 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
|
5390 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5391 sata_clear_dev_reset = B_TRUE; |
| 1258 | 5392 sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET; |
| 5393 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5394 "sata_hba_start: clearing device reset state\n", NULL); | |
| 5395 } | |
| 5396 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; | |
| 5397 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; | |
| 5398 sata_device = spx->txlt_sata_pkt->satapkt_device; /* local copy */ | |
| 5399 | |
| 5400 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5401 sdinfo->satadrv_addr.cport))); | |
| 5402 | |
| 5403 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5404 "Sata cmd 0x%2x\n", cmd); | |
| 5405 | |
| 5406 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), | |
| 5407 spx->txlt_sata_pkt); | |
| 5408 | |
| 5409 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5410 sdinfo->satadrv_addr.cport))); | |
| 5411 /* | |
| 5412 * If sata pkt was accepted and executed in asynchronous mode, i.e. | |
| 5413 * with the sata callback, the sata_pkt could be already destroyed | |
| 5414 * by the time we check ther return status from the hba_start() | |
| 5415 * function, because sata_scsi_destroy_pkt() could have been already | |
| 5416 * called (perhaps in the interrupt context). So, in such case, there | |
| 5417 * should be no references to it. In other cases, sata_pkt still | |
| 5418 * exists. | |
| 5419 */ | |
| 5420 switch (stat) { | |
| 5421 case SATA_TRAN_ACCEPTED: | |
| 5422 /* | |
| 5423 * pkt accepted for execution. | |
| 5424 * If it was executed synchronously, it is already completed | |
| 5425 * and pkt completion_reason indicates completion status. | |
| 5426 */ | |
| 5427 *rval = TRAN_ACCEPT; | |
| 5428 return (0); | |
| 5429 | |
| 5430 case SATA_TRAN_QUEUE_FULL: | |
| 5431 /* | |
| 5432 * Controller detected queue full condition. | |
| 5433 */ | |
| 5434 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, | |
| 5435 "sata_hba_start: queue full\n", NULL); | |
| 5436 | |
| 5437 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 5438 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; | |
| 5439 | |
| 5440 *rval = TRAN_BUSY; | |
| 5441 break; | |
| 5442 | |
| 5443 case SATA_TRAN_PORT_ERROR: | |
| 5444 /* | |
| 5445 * Communication/link with device or general port error | |
| 5446 * detected before pkt execution begun. | |
| 5447 */ | |
| 5448 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == | |
| 5449 SATA_ADDR_CPORT) | |
| 5450 sata_log(sata_hba_inst, CE_CONT, | |
| 5451 "port %d error", | |
| 5452 sata_device.satadev_addr.cport); | |
| 5453 else | |
| 5454 sata_log(sata_hba_inst, CE_CONT, | |
| 5455 "port %d pmport %d error\n", | |
| 5456 sata_device.satadev_addr.cport, | |
| 5457 sata_device.satadev_addr.pmport); | |
| 5458 | |
| 5459 /* | |
| 5460 * Update the port/device structure. | |
| 5461 * sata_pkt should be still valid. Since port error is | |
| 5462 * returned, sata_device content should reflect port | |
| 5463 * state - it means, that sata address have been changed, | |
| 5464 * because original packet's sata address refered to a device | |
| 5465 * attached to some port. | |
| 5466 */ | |
| 5467 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 5468 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; | |
| 5469 *rval = TRAN_FATAL_ERROR; | |
| 5470 break; | |
| 5471 | |
| 5472 case SATA_TRAN_CMD_UNSUPPORTED: | |
| 5473 /* | |
| 5474 * Command rejected by HBA as unsupported. It was HBA driver | |
| 5475 * that rejected the command, command was not sent to | |
| 5476 * an attached device. | |
| 5477 */ | |
| 5478 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5479 sdinfo->satadrv_addr.cport))); | |
| 5480 (void) sata_txlt_invalid_command(spx); | |
| 5481 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 5482 sdinfo->satadrv_addr.cport))); | |
| 5483 | |
| 5484 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) | |
| 5485 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5486 "sat_hba_start: cmd 0x%2x rejected " | |
| 5487 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); | |
| 5488 | |
| 5489 *rval = TRAN_ACCEPT; | |
| 5490 break; | |
| 5491 | |
| 5492 case SATA_TRAN_BUSY: | |
| 5493 /* | |
| 5494 * Command rejected by HBA because other operation prevents | |
| 5495 * accepting the packet, or device is in RESET condition. | |
| 5496 */ | |
| 5497 if (sdinfo != NULL) { | |
| 5498 sdinfo->satadrv_state = | |
| 5499 spx->txlt_sata_pkt->satapkt_device.satadev_state; | |
| 5500 | |
| 5501 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { | |
| 5502 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5503 "sata_hba_start: cmd 0x%2x rejected " | |
| 5504 "because of device reset condition\n", | |
| 5505 cmd); | |
| 5506 } else { | |
| 5507 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 5508 "sata_hba_start: cmd 0x%2x rejected " | |
| 5509 "with SATA_TRAN_BUSY status\n", | |
| 5510 cmd); | |
| 5511 } | |
| 5512 } | |
| 5513 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; | |
| 5514 *rval = TRAN_BUSY; | |
| 5515 break; | |
| 5516 | |
| 5517 default: | |
| 5518 /* Unrecognized HBA response */ | |
| 5519 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 5520 "sata_hba_start: unrecognized HBA response " | |
| 5521 "to cmd : 0x%2x resp 0x%x", cmd, rval)); | |
| 5522 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; | |
| 5523 *rval = TRAN_FATAL_ERROR; | |
| 5524 break; | |
| 5525 } | |
| 5526 | |
| 5527 /* | |
| 5528 * If we got here, the packet was rejected. | |
| 5529 * Check if we need to remember reset state clearing request | |
| 5530 */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
5531 if (cmd_flags.sata_clear_dev_reset) { |
| 1258 | 5532 /* |
| 5533 * Check if device is still configured - it may have | |
| 5534 * disapeared from the configuration | |
| 5535 */ | |
| 5536 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 5537 if (sdinfo != NULL) { | |
| 5538 /* | |
| 5539 * Restore the flag that requests clearing of | |
| 5540 * the device reset state, | |
| 5541 * so the next sata packet may carry it to HBA. | |
| 5542 */ | |
| 5543 sdinfo->satadrv_event_flags |= | |
| 5544 SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 5545 } | |
| 5546 } | |
| 5547 return (-1); | |
| 5548 } | |
| 5549 | |
| 5550 /* | |
| 5551 * Scsi response setup for invalid LBA | |
| 5552 * | |
| 5553 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. | |
| 5554 */ | |
| 5555 static int | |
| 5556 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) | |
| 5557 { | |
| 5558 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5559 struct scsi_extended_sense *sense; | |
| 5560 | |
| 5561 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5562 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5563 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5564 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 5565 | |
| 5566 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 5567 sense = sata_arq_sense(spx); | |
| 5568 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 5569 sense->es_add_code = SD_SCSI_LBA_OUT_OF_RANGE; | |
| 5570 | |
| 5571 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5572 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 5573 | |
| 5574 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 5575 scsipkt->pkt_comp != NULL) | |
| 5576 /* scsi callback required */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5577 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5578 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5579 TQ_SLEEP) == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5580 /* Scheduling the callback failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
5581 return (TRAN_BUSY); |
| 1258 | 5582 return (TRAN_ACCEPT); |
| 5583 } | |
| 5584 | |
| 5585 | |
| 5586 /* | |
| 5587 * Analyze device status and error registers and translate them into | |
| 5588 * appropriate scsi sense codes. | |
| 5589 * NOTE: non-packet commands only for now | |
| 5590 */ | |
| 5591 static void | |
| 5592 sata_decode_device_error(sata_pkt_txlate_t *spx, | |
| 5593 struct scsi_extended_sense *sense) | |
| 5594 { | |
| 5595 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; | |
| 5596 | |
| 5597 ASSERT(sense != NULL); | |
| 5598 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 5599 SATA_STATUS_ERR); | |
| 5600 | |
| 5601 | |
| 5602 if (err_reg & SATA_ERROR_ICRC) { | |
| 5603 sense->es_key = KEY_ABORTED_COMMAND; | |
| 5604 sense->es_add_code = 0x08; /* Communication failure */ | |
| 5605 return; | |
| 5606 } | |
| 5607 | |
| 5608 if (err_reg & SATA_ERROR_UNC) { | |
| 5609 sense->es_key = KEY_MEDIUM_ERROR; | |
| 5610 /* Information bytes (LBA) need to be set by a caller */ | |
| 5611 return; | |
| 5612 } | |
| 5613 | |
| 5614 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ | |
| 5615 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { | |
| 5616 sense->es_key = KEY_UNIT_ATTENTION; | |
| 5617 sense->es_add_code = 0x3a; /* No media present */ | |
| 5618 return; | |
| 5619 } | |
| 5620 | |
| 5621 if (err_reg & SATA_ERROR_IDNF) { | |
| 5622 if (err_reg & SATA_ERROR_ABORT) { | |
| 5623 sense->es_key = KEY_ABORTED_COMMAND; | |
| 5624 } else { | |
| 5625 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 5626 sense->es_add_code = 0x21; /* LBA out of range */ | |
| 5627 } | |
| 5628 return; | |
| 5629 } | |
| 5630 | |
| 5631 if (err_reg & SATA_ERROR_ABORT) { | |
| 5632 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 5633 sense->es_key = KEY_ABORTED_COMMAND; | |
| 5634 return; | |
| 5635 } | |
| 5636 } | |
| 5637 | |
| 5638 /* | |
| 5639 * Extract error LBA from sata_pkt.satapkt_cmd register fields | |
| 5640 */ | |
| 5641 static void | |
| 5642 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) | |
| 5643 { | |
| 5644 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 5645 | |
| 5646 *lba = 0; | |
| 5647 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { | |
| 5648 *lba = sata_cmd->satacmd_lba_high_msb; | |
| 5649 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; | |
| 5650 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; | |
| 5651 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { | |
| 5652 *lba = sata_cmd->satacmd_device_reg & 0xf; | |
| 5653 } | |
| 5654 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; | |
| 5655 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; | |
| 5656 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; | |
| 5657 } | |
| 5658 | |
| 5659 /* | |
| 5660 * This is fixed sense format - if LBA exceeds the info field size, | |
| 5661 * no valid info will be returned (valid bit in extended sense will | |
| 5662 * be set to 0). | |
| 5663 */ | |
| 5664 static struct scsi_extended_sense * | |
| 5665 sata_arq_sense(sata_pkt_txlate_t *spx) | |
| 5666 { | |
| 5667 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5668 struct scsi_arq_status *arqs; | |
| 5669 struct scsi_extended_sense *sense; | |
| 5670 | |
| 5671 /* Fill ARQ sense data */ | |
| 5672 scsipkt->pkt_state |= STATE_ARQ_DONE; | |
| 5673 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; | |
| 5674 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; | |
| 5675 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; | |
| 5676 arqs->sts_rqpkt_reason = CMD_CMPLT; | |
| 5677 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5678 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5679 arqs->sts_rqpkt_resid = 0; | |
| 5680 sense = &arqs->sts_sensedata; | |
| 5681 bzero(sense, sizeof (struct scsi_extended_sense)); | |
| 5682 sense->es_valid = 1; /* Valid sense */ | |
| 5683 sense->es_class = 7; /* Response code 0x70 - current err */ | |
| 5684 sense->es_key = KEY_NO_SENSE; | |
| 5685 sense->es_info_1 = 0; | |
| 5686 sense->es_info_2 = 0; | |
| 5687 sense->es_info_3 = 0; | |
| 5688 sense->es_info_4 = 0; | |
| 5689 sense->es_add_len = 6; /* Additional length */ | |
| 5690 sense->es_cmd_info[0] = 0; | |
| 5691 sense->es_cmd_info[1] = 0; | |
| 5692 sense->es_cmd_info[2] = 0; | |
| 5693 sense->es_cmd_info[3] = 0; | |
| 5694 sense->es_add_code = 0; | |
| 5695 sense->es_qual_code = 0; | |
| 5696 return (sense); | |
| 5697 } | |
| 5698 | |
| 5699 | |
| 5700 /* | |
| 5701 * Translate completion status of SATA read/write commands into scsi response. | |
| 5702 * pkt completion_reason is checked to determine the completion status. | |
| 5703 * Do scsi callback if necessary. | |
| 5704 * | |
| 5705 * Note: this function may be called also for synchronously executed | |
| 5706 * commands. | |
| 5707 * This function may be used only if scsi_pkt is non-NULL. | |
| 5708 */ | |
| 5709 static void | |
| 5710 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) | |
| 5711 { | |
| 5712 sata_pkt_txlate_t *spx = | |
| 5713 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 5714 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; | |
| 5715 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5716 struct scsi_extended_sense *sense; | |
| 5717 uint64_t lba; | |
| 5718 | |
| 5719 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { | |
| 5720 /* Normal completion */ | |
| 5721 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5722 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; | |
| 5723 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5724 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 5725 } else { | |
| 5726 /* | |
| 5727 * Something went wrong - analyze return | |
| 5728 */ | |
| 5729 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5730 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5731 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5732 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 5733 sense = sata_arq_sense(spx); | |
| 5734 ASSERT(sense != NULL); | |
| 5735 | |
| 5736 /* | |
| 5737 * 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
|
5738 * extract from device registers the failing LBA. |
| 1258 | 5739 */ |
| 5740 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { | |
| 5741 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && | |
| 5742 (scmd->satacmd_lba_mid_msb != 0 || | |
| 5743 scmd->satacmd_lba_high_msb != 0)) { | |
| 5744 /* | |
| 5745 * We have problem reporting this cmd LBA | |
| 5746 * in fixed sense data format, because of | |
| 5747 * the size of the scsi LBA fields. | |
| 5748 */ | |
| 5749 sense->es_valid = 0; | |
| 5750 } else { | |
| 5751 sata_extract_error_lba(spx, &lba); | |
| 5752 sense->es_info_1 = (lba & 0xFF000000) >> 24; | |
| 5753 sense->es_info_1 = (lba & 0xFF0000) >> 16; | |
| 5754 sense->es_info_1 = (lba & 0xFF00) >> 8; | |
| 5755 sense->es_info_1 = lba & 0xFF; | |
| 5756 } | |
| 5757 } else { | |
| 5758 /* Invalid extended sense info */ | |
| 5759 sense->es_valid = 0; | |
| 5760 } | |
| 5761 | |
| 5762 switch (sata_pkt->satapkt_reason) { | |
| 5763 case SATA_PKT_PORT_ERROR: | |
| 5764 /* We may want to handle DEV GONE state as well */ | |
| 5765 /* | |
| 5766 * We have no device data. Assume no data transfered. | |
| 5767 */ | |
| 5768 sense->es_key = KEY_HARDWARE_ERROR; | |
| 5769 break; | |
| 5770 | |
| 5771 case SATA_PKT_DEV_ERROR: | |
| 5772 if (sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 5773 SATA_STATUS_ERR) { | |
| 5774 /* | |
| 5775 * determine dev error reason from error | |
| 5776 * reg content | |
| 5777 */ | |
| 5778 sata_decode_device_error(spx, sense); | |
| 5779 if (sense->es_key == KEY_MEDIUM_ERROR) { | |
| 5780 switch (scmd->satacmd_cmd_reg) { | |
| 5781 case SATAC_READ_DMA: | |
| 5782 case SATAC_READ_DMA_EXT: | |
| 5783 case SATAC_READ_DMA_QUEUED: | |
| 5784 case SATAC_READ_DMA_QUEUED_EXT: | |
| 5785 case SATAC_READ_FPDMA_QUEUED: | |
| 5786 /* Unrecovered read error */ | |
| 5787 sense->es_add_code = | |
| 5788 SD_SCSI_UNREC_READ_ERROR; | |
| 5789 break; | |
| 5790 case SATAC_WRITE_DMA: | |
| 5791 case SATAC_WRITE_DMA_EXT: | |
| 5792 case SATAC_WRITE_DMA_QUEUED: | |
| 5793 case SATAC_WRITE_DMA_QUEUED_EXT: | |
| 5794 case SATAC_WRITE_FPDMA_QUEUED: | |
| 5795 /* Write error */ | |
| 5796 sense->es_add_code = | |
| 5797 SD_SCSI_WRITE_ERROR; | |
| 5798 break; | |
| 5799 default: | |
| 5800 /* Internal error */ | |
| 5801 SATA_LOG_D(( | |
| 5802 spx->txlt_sata_hba_inst, | |
| 5803 CE_WARN, | |
| 5804 "sata_txlt_rw_completion :" | |
| 5805 "internal error - invalid " | |
| 5806 "command 0x%2x", | |
| 5807 scmd->satacmd_cmd_reg)); | |
| 5808 break; | |
| 5809 } | |
| 5810 } | |
| 5811 break; | |
| 5812 } | |
| 5813 /* No extended sense key - no info available */ | |
| 5814 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5815 break; | |
| 5816 | |
| 5817 case SATA_PKT_TIMEOUT: | |
| 5818 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ | |
| 5819 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5820 /* No extended sense key ? */ | |
| 5821 break; | |
| 5822 | |
| 5823 case SATA_PKT_ABORTED: | |
| 5824 scsipkt->pkt_reason = CMD_ABORTED; | |
| 5825 /* No extended sense key ? */ | |
| 5826 break; | |
| 5827 | |
| 5828 case SATA_PKT_RESET: | |
| 5829 scsipkt->pkt_reason = CMD_RESET; | |
| 5830 break; | |
| 5831 | |
| 5832 default: | |
| 5833 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 5834 "sata_txlt_rw_completion: " | |
| 5835 "invalid packet completion reason")); | |
| 5836 scsipkt->pkt_reason = CMD_TRAN_ERR; | |
| 5837 break; | |
| 5838 } | |
| 5839 } | |
| 5840 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5841 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 5842 | |
| 5843 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 5844 scsipkt->pkt_comp != NULL) | |
| 5845 /* scsi callback required */ | |
| 5846 (*scsipkt->pkt_comp)(scsipkt); | |
| 5847 | |
| 5848 } | |
| 5849 | |
| 5850 /* | |
| 5851 * NON FUNCTIONAL IMPLEMENTATION. THIS IS A PLACE HOLDER. | |
| 5852 * ATAPI devices are not supported currently (are not be attached recognized | |
| 5853 * as valid devices). | |
| 5854 * Will be fixed in phase 2 of the development. | |
| 5855 */ | |
| 5856 static void | |
| 5857 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) | |
| 5858 { | |
| 5859 sata_pkt_txlate_t *spx = | |
| 5860 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 5861 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5862 struct scsi_arq_status *arqs; | |
| 5863 | |
| 5864 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { | |
| 5865 /* Normal completion */ | |
| 5866 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5867 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; | |
| 5868 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5869 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 5870 scsipkt->pkt_resid = 0; | |
| 5871 } else { | |
| 5872 /* | |
| 5873 * Something went wrong - analyze return | |
| 5874 */ | |
| 5875 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5876 STATE_SENT_CMD | STATE_GOT_STATUS | STATE_ARQ_DONE; | |
| 5877 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5878 | |
| 5879 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; | |
| 5880 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; | |
| 5881 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; | |
| 5882 arqs->sts_rqpkt_reason = CMD_CMPLT; | |
| 5883 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5884 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5885 arqs->sts_rqpkt_resid = 0; | |
| 5886 | |
| 5887 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, | |
| 5888 &arqs->sts_sensedata, SATA_ATAPI_RQSENSE_LEN); | |
| 5889 } | |
| 5890 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5891 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 5892 | |
| 5893 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 5894 scsipkt->pkt_comp != NULL) { | |
| 5895 /* scsi callback required */ | |
| 5896 (*scsipkt->pkt_comp)(scsipkt); | |
| 5897 } | |
| 5898 } | |
| 5899 | |
| 5900 | |
| 5901 /* | |
| 5902 * Translate completion status of non-data commands (i.e. commands returning | |
| 5903 * no data). | |
| 5904 * pkt completion_reason is checked to determine the completion status. | |
| 5905 * Do scsi callback if necessary (FLAG_NOINTR == 0) | |
| 5906 * | |
| 5907 * Note: this function may be called also for synchronously executed | |
| 5908 * commands. | |
| 5909 * This function may be used only if scsi_pkt is non-NULL. | |
| 5910 */ | |
| 5911 | |
| 5912 static void | |
| 5913 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) | |
| 5914 { | |
| 5915 sata_pkt_txlate_t *spx = | |
| 5916 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; | |
| 5917 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 5918 struct scsi_extended_sense *sense; | |
| 5919 | |
| 5920 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | | |
| 5921 STATE_SENT_CMD | STATE_GOT_STATUS; | |
| 5922 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { | |
| 5923 /* Normal completion */ | |
| 5924 scsipkt->pkt_reason = CMD_CMPLT; | |
| 5925 *scsipkt->pkt_scbp = STATUS_GOOD; | |
| 5926 } else { | |
| 5927 /* Something went wrong */ | |
| 5928 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5929 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 5930 sense = sata_arq_sense(spx); | |
| 5931 switch (sata_pkt->satapkt_reason) { | |
| 5932 case SATA_PKT_PORT_ERROR: | |
| 5933 /* | |
| 5934 * We have no device data. Assume no data transfered. | |
| 5935 */ | |
| 5936 sense->es_key = KEY_HARDWARE_ERROR; | |
| 5937 break; | |
| 5938 | |
| 5939 case SATA_PKT_DEV_ERROR: | |
| 5940 if (sata_pkt->satapkt_cmd.satacmd_status_reg & | |
| 5941 SATA_STATUS_ERR) { | |
| 5942 /* | |
| 5943 * determine dev error reason from error | |
| 5944 * reg content | |
| 5945 */ | |
| 5946 sata_decode_device_error(spx, sense); | |
| 5947 break; | |
| 5948 } | |
| 5949 /* No extended sense key - no info available */ | |
| 5950 break; | |
| 5951 | |
| 5952 case SATA_PKT_TIMEOUT: | |
| 5953 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ | |
| 5954 scsipkt->pkt_reason = CMD_INCOMPLETE; | |
| 5955 /* No extended sense key ? */ | |
| 5956 break; | |
| 5957 | |
| 5958 case SATA_PKT_ABORTED: | |
| 5959 scsipkt->pkt_reason = CMD_ABORTED; | |
| 5960 /* No extended sense key ? */ | |
| 5961 break; | |
| 5962 | |
| 5963 case SATA_PKT_RESET: | |
| 5964 /* pkt aborted by an explicit reset from a host */ | |
| 5965 scsipkt->pkt_reason = CMD_RESET; | |
| 5966 break; | |
| 5967 | |
| 5968 default: | |
| 5969 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 5970 "sata_txlt_nodata_cmd_completion: " | |
| 5971 "invalid packet completion reason %d", | |
| 5972 sata_pkt->satapkt_reason)); | |
| 5973 scsipkt->pkt_reason = CMD_TRAN_ERR; | |
| 5974 break; | |
| 5975 } | |
| 5976 | |
| 5977 } | |
| 5978 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, | |
| 5979 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); | |
| 5980 | |
| 5981 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && | |
| 5982 scsipkt->pkt_comp != NULL) | |
| 5983 /* scsi callback required */ | |
| 5984 (*scsipkt->pkt_comp)(scsipkt); | |
| 5985 } | |
| 5986 | |
| 5987 | |
| 5988 /* | |
| 5989 * Build Mode sense R/W recovery page | |
| 5990 * NOT IMPLEMENTED | |
| 5991 */ | |
| 5992 | |
| 5993 static int | |
| 5994 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 5995 { | |
| 5996 #ifndef __lock_lint | |
| 5997 _NOTE(ARGUNUSED(sdinfo)) | |
| 5998 _NOTE(ARGUNUSED(pcntrl)) | |
| 5999 _NOTE(ARGUNUSED(buf)) | |
| 6000 #endif | |
| 6001 return (0); | |
| 6002 } | |
| 6003 | |
| 6004 /* | |
| 6005 * Build Mode sense caching page - scsi-3 implementation. | |
| 6006 * Page length distinguishes previous format from scsi-3 format. | |
| 6007 * buf must have space for 0x12 bytes. | |
| 6008 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. | |
| 6009 * | |
| 6010 */ | |
| 6011 static int | |
| 6012 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6013 { | |
| 6014 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; | |
| 6015 sata_id_t *sata_id = &sdinfo->satadrv_id; | |
| 6016 | |
| 6017 /* | |
| 6018 * Most of the fields are set to 0, being not supported and/or disabled | |
| 6019 */ | |
| 6020 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); | |
| 6021 | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6022 /* Saved paramters not supported */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6023 if (pcntrl == 3) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6024 return (0); |
| 1258 | 6025 if (pcntrl == 0 || pcntrl == 2) { |
| 6026 /* | |
| 6027 * For now treat current and default parameters as same | |
| 6028 * That may have to change, if target driver will complain | |
| 6029 */ | |
| 6030 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ | |
| 6031 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; | |
| 6032 | |
| 6033 if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 6034 !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) { | |
| 6035 page->dra = 1; /* Read Ahead disabled */ | |
| 6036 page->rcd = 1; /* Read Cache disabled */ | |
| 6037 } | |
| 6038 if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) && | |
| 6039 (sata_id->ai_features85 & SATA_WRITE_CACHE)) | |
| 6040 page->wce = 1; /* Write Cache enabled */ | |
| 6041 } else { | |
| 6042 /* Changeable parameters */ | |
| 6043 page->mode_page.code = MODEPAGE_CACHING; | |
| 6044 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; | |
| 6045 if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) { | |
| 6046 page->dra = 1; | |
| 6047 page->rcd = 1; | |
| 6048 } | |
| 6049 if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE) | |
| 6050 page->wce = 1; | |
| 6051 } | |
| 6052 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + | |
| 6053 sizeof (struct mode_page)); | |
| 6054 } | |
| 6055 | |
| 6056 /* | |
| 6057 * Build Mode sense exception cntrl page | |
| 6058 */ | |
| 6059 static int | |
| 6060 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6061 { | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6062 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
|
6063 sata_id_t *sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6064 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6065 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6066 * 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
|
6067 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6068 bzero(buf, PAGELENGTH_INFO_EXCPT); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6069 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6070 page->mode_page.code = MODEPAGE_INFO_EXCPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6071 page->mode_page.length = PAGELENGTH_INFO_EXCPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6072 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6073 /* Indicate that this is page is saveable */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6074 page->mode_page.ps = 1; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6075 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6076 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6077 * 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
|
6078 * 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
|
6079 * 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
|
6080 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6081 if (pcntrl != 1) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6082 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
|
6083 page->mrie = MRIE_ONLY_ON_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6084 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6085 else |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6086 page->dexcpt = 1; /* Only changeable parameter */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6087 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6088 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page)); |
| 1258 | 6089 } |
| 6090 | |
| 6091 | |
| 6092 /* | |
| 6093 * Build Mode sense power condition page | |
| 6094 * NOT IMPLEMENTED. | |
| 6095 */ | |
| 6096 static int | |
| 6097 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) | |
| 6098 { | |
| 6099 #ifndef __lock_lint | |
| 6100 _NOTE(ARGUNUSED(sdinfo)) | |
| 6101 _NOTE(ARGUNUSED(pcntrl)) | |
| 6102 _NOTE(ARGUNUSED(buf)) | |
| 6103 #endif | |
| 6104 return (0); | |
| 6105 } | |
| 6106 | |
| 6107 | |
| 6108 /* | |
| 6109 * Process mode select caching page 8 (scsi3 format only). | |
| 6110 * Read Ahead (same as read cache) and Write Cache may be turned on and off | |
| 6111 * if these features are supported by the device. If these features are not | |
| 6112 * supported, quietly ignore them. | |
| 6113 * This function fails only if the SET FEATURE command sent to | |
| 6114 * the device fails. The page format is not varified, assuming that the | |
| 6115 * target driver operates correctly - if parameters length is too short, | |
| 6116 * we just drop the page. | |
| 6117 * Two command may be sent if both Read Cache/Read Ahead and Write Cache | |
| 6118 * setting have to be changed. | |
| 6119 * SET FEATURE command is executed synchronously, i.e. we wait here until | |
| 6120 * it is completed, regardless of the scsi pkt directives. | |
| 6121 * | |
| 6122 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. | |
| 6123 * changing DRA will change RCD. | |
| 6124 * | |
| 6125 * More than one SATA command may be executed to perform operations specified | |
| 6126 * by mode select pages. The first error terminates further execution. | |
| 6127 * Operations performed successully are not backed-up in such case. | |
| 6128 * | |
| 6129 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. | |
| 6130 * If operation resulted in changing device setup, dmod flag should be set to | |
| 6131 * one (1). If parameters were not changed, dmod flag should be set to 0. | |
| 6132 * Upon return, if operation required sending command to the device, the rval | |
| 6133 * should be set to the value returned by sata_hba_start. If operation | |
| 6134 * did not require device access, rval should be set to TRAN_ACCEPT. | |
| 6135 * The pagelen should be set to the length of the page. | |
| 6136 * | |
| 6137 * This function has to be called with a port mutex held. | |
| 6138 * | |
| 6139 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. | |
| 6140 */ | |
| 6141 int | |
| 6142 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, | |
| 6143 int parmlen, int *pagelen, int *rval, int *dmod) | |
| 6144 { | |
| 6145 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; | |
| 6146 sata_drive_info_t *sdinfo; | |
| 6147 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; | |
| 6148 sata_id_t *sata_id; | |
| 6149 struct scsi_extended_sense *sense; | |
| 6150 int wce, dra; /* Current settings */ | |
| 6151 | |
| 6152 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, | |
| 6153 &spx->txlt_sata_pkt->satapkt_device); | |
| 6154 sata_id = &sdinfo->satadrv_id; | |
| 6155 *dmod = 0; | |
| 6156 | |
| 6157 /* Verify parameters length. If too short, drop it */ | |
| 6158 if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + | |
| 6159 sizeof (struct mode_page) < parmlen) { | |
| 6160 *scsipkt->pkt_scbp = STATUS_CHECK; | |
| 6161 sense = sata_arq_sense(spx); | |
| 6162 sense->es_key = KEY_ILLEGAL_REQUEST; | |
| 6163 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; | |
| 6164 *pagelen = parmlen; | |
| 6165 *rval = TRAN_ACCEPT; | |
| 6166 return (SATA_FAILURE); | |
| 6167 } | |
| 6168 | |
| 6169 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); | |
| 6170 | |
| 6171 /* | |
| 6172 * We can manipulate only write cache and read ahead | |
| 6173 * (read cache) setting. | |
| 6174 */ | |
| 6175 if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 6176 !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 6177 /* | |
| 6178 * None of the features is supported - ignore | |
| 6179 */ | |
| 6180 *rval = TRAN_ACCEPT; | |
| 6181 return (SATA_SUCCESS); | |
| 6182 } | |
| 6183 | |
| 6184 /* Current setting of Read Ahead (and Read Cache) */ | |
| 6185 if (sata_id->ai_features85 & SATA_LOOK_AHEAD) | |
| 6186 dra = 0; /* 0 == not disabled */ | |
| 6187 else | |
| 6188 dra = 1; | |
| 6189 /* Current setting of Write Cache */ | |
| 6190 if (sata_id->ai_features85 & SATA_WRITE_CACHE) | |
| 6191 wce = 1; | |
| 6192 else | |
| 6193 wce = 0; | |
| 6194 | |
| 6195 if (page->dra == dra && page->wce == wce && page->rcd == dra) { | |
| 6196 /* nothing to do */ | |
| 6197 *rval = TRAN_ACCEPT; | |
| 6198 return (SATA_SUCCESS); | |
| 6199 } | |
| 6200 /* | |
| 6201 * Need to flip some setting | |
| 6202 * Set-up Internal SET FEATURES command(s) | |
| 6203 */ | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6204 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; |
| 1258 | 6205 scmd->satacmd_addr_type = 0; |
| 6206 scmd->satacmd_device_reg = 0; | |
| 6207 scmd->satacmd_status_reg = 0; | |
| 6208 scmd->satacmd_error_reg = 0; | |
| 6209 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; | |
| 6210 if (page->dra != dra || page->rcd != dra) { | |
| 6211 /* Need to flip read ahead setting */ | |
| 6212 if (dra == 0) | |
| 6213 /* Disable read ahead / read cache */ | |
| 6214 scmd->satacmd_features_reg = | |
| 6215 SATAC_SF_DISABLE_READ_AHEAD; | |
| 6216 else | |
| 6217 /* Enable read ahead / read cache */ | |
| 6218 scmd->satacmd_features_reg = | |
| 6219 SATAC_SF_ENABLE_READ_AHEAD; | |
| 6220 | |
| 6221 /* Transfer command to HBA */ | |
| 6222 if (sata_hba_start(spx, rval) != 0) | |
| 6223 /* | |
| 6224 * Pkt not accepted for execution. | |
| 6225 */ | |
| 6226 return (SATA_FAILURE); | |
| 6227 | |
| 6228 *dmod = 1; | |
| 6229 | |
| 6230 /* Now process return */ | |
| 6231 if (spx->txlt_sata_pkt->satapkt_reason != | |
| 6232 SATA_PKT_COMPLETED) { | |
| 6233 goto failure; /* Terminate */ | |
| 6234 } | |
| 6235 } | |
| 6236 | |
| 6237 /* Note that the packet is not removed, so it could be re-used */ | |
| 6238 if (page->wce != wce) { | |
| 6239 /* Need to flip Write Cache setting */ | |
| 6240 if (page->wce == 1) | |
| 6241 /* Enable write cache */ | |
| 6242 scmd->satacmd_features_reg = | |
| 6243 SATAC_SF_ENABLE_WRITE_CACHE; | |
| 6244 else | |
| 6245 /* Disable write cache */ | |
| 6246 scmd->satacmd_features_reg = | |
| 6247 SATAC_SF_DISABLE_WRITE_CACHE; | |
| 6248 | |
| 6249 /* Transfer command to HBA */ | |
| 6250 if (sata_hba_start(spx, rval) != 0) | |
| 6251 /* | |
| 6252 * Pkt not accepted for execution. | |
| 6253 */ | |
| 6254 return (SATA_FAILURE); | |
| 6255 | |
| 6256 *dmod = 1; | |
| 6257 | |
| 6258 /* Now process return */ | |
| 6259 if (spx->txlt_sata_pkt->satapkt_reason != | |
| 6260 SATA_PKT_COMPLETED) { | |
| 6261 goto failure; | |
| 6262 } | |
| 6263 } | |
| 6264 return (SATA_SUCCESS); | |
| 6265 | |
| 6266 failure: | |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6267 sata_xlate_errors(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6268 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6269 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6270 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6271 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6272 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6273 * Process mode select informational exceptions control page 0x1c |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6274 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6275 * The only changeable bit is dexcpt (disable exceptions). |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6276 * MRIE (method of reporting informational exceptions) must be |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6277 * "only on request". |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6278 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6279 * 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
|
6280 * 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
|
6281 * 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
|
6282 * 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
|
6283 * 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
|
6284 * 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
|
6285 * 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
|
6286 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6287 * 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
|
6288 * |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6289 * 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
|
6290 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6291 static int |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6292 sata_mode_select_page_1c( |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6293 sata_pkt_txlate_t *spx, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6294 struct mode_info_excpt_page *page, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6295 int parmlen, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6296 int *pagelen, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6297 int *rval, |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6298 int *dmod) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6299 { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6300 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6301 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
|
6302 sata_drive_info_t *sdinfo; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6303 sata_id_t *sata_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6304 struct scsi_extended_sense *sense; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6305 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6306 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
|
6307 &spx->txlt_sata_pkt->satapkt_device); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6308 sata_id = &sdinfo->satadrv_id; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6309 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6310 *dmod = 0; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6311 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6312 /* Verify parameters length. If too short, drop it */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6313 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
|
6314 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
|
6315 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6316 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6317 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6318 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
|
6319 *pagelen = parmlen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6320 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6321 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6322 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6323 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6324 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6325 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6326 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6327 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6328 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6329 sense->es_key = KEY_ILLEGAL_REQUEST; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6330 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
|
6331 *pagelen = parmlen; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6332 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6333 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6334 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6335 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6336 /* 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
|
6337 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
|
6338 /* nothing to do */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6339 *rval = TRAN_ACCEPT; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6340 return (SATA_SUCCESS); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6341 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6342 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6343 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
|
6344 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6345 /* Build SMART_ENABLE or SMART_DISABLE command */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6346 scmd->satacmd_addr_type = 0; /* N/A */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6347 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
|
6348 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
|
6349 scmd->satacmd_features_reg = page->dexcpt ? |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6350 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6351 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6352 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6353 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6354 /* Transfer command to HBA */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6355 if (sata_hba_start(spx, rval) != 0) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6356 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6357 * Pkt not accepted for execution. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6358 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6359 return (SATA_FAILURE); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6360 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6361 *dmod = 1; /* At least may have been modified */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6362 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6363 /* Now process return */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6364 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
|
6365 return (SATA_SUCCESS); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6366 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6367 /* Packet did not complete successfully */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6368 sata_xlate_errors(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
6369 |
| 1258 | 6370 return (SATA_FAILURE); |
| 6371 } | |
| 6372 | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6373 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6374 * 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
|
6375 * SCSI LOG SENSE page 0 (supported log pages) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6376 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6377 * 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
|
6378 * (supported log pages, self-test results, informational exceptions |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6379 * and Sun vendor specific ATA SMART data). |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6380 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6381 * 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
|
6382 * in which to create the page information. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6383 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6384 * 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
|
6385 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6386 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6387 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
|
6388 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6389 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6390 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
|
6391 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
|
6392 sata_id_t *sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6393 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6394 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6395 lpp->param_code[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6396 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
|
6397 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6398 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6399 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6400 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
|
6401 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6402 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6403 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6404 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6405 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6406 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6407 ++num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6408 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6409 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6410 lpp->param_len = num_pages_supported; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6411 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6412 return ((&lpp->param_values[0] - (uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6413 num_pages_supported); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6414 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6415 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6416 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6417 * 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
|
6418 * SCSI LOG SENSE page 0x10 (self-test results) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6419 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6420 * 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
|
6421 * 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
|
6422 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6423 * 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
|
6424 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6425 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6426 sata_build_lsense_page_10( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6427 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6428 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6429 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6430 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6431 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6432 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6433 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6434 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
|
6435 struct smart_ext_selftest_log *ext_selftest_log; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6436 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6437 ext_selftest_log = kmem_zalloc( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6438 sizeof (struct smart_ext_selftest_log), KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6439 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6440 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
|
6441 ext_selftest_log, 0); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6442 if (rval == 0) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6443 int index, start_index; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6444 struct smart_ext_selftest_log_entry *entry; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6445 static const struct smart_ext_selftest_log_entry empty = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6446 {0}; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6447 uint16_t block_num; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6448 int count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6449 boolean_t only_one_block = B_FALSE; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6450 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6451 index = ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6452 smart_ext_selftest_log_index[0]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6453 index |= ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6454 smart_ext_selftest_log_index[1] << 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6455 if (index == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6456 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6457 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6458 --index; /* Correct for 0 origin */ |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6459 start_index = index; /* remember where we started */ |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6460 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
|
6461 if (block_num != 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6462 rval = sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6463 sata_hba_inst, sdinfo, ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6464 block_num); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6465 if (rval != 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6466 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6467 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6468 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6469 entry = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6470 &ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6471 smart_ext_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6472 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6473 for (count = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6474 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6475 ++count) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6476 uint8_t status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6477 uint8_t code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6478 uint8_t sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6479 uint8_t add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6480 uint8_t add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6481 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6482 /* If this is an unused entry, we are done */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6483 if (bcmp(entry, &empty, sizeof (empty)) == 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6484 /* Broken firmware on some disks */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6485 if (index + 1 == |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6486 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6487 --entry; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6488 --index; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6489 if (bcmp(entry, &empty, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6490 sizeof (empty)) == 0) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6491 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6492 } else |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6493 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6494 } |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6495 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6496 if (only_one_block && |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6497 start_index == index) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6498 goto out; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6499 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6500 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6501 lpp->param_code[1] = count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6502 lpp->param_ctrl_flags = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6503 LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6504 lpp->param_len = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6505 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6506 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6507 status = entry->smart_ext_selftest_log_status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6508 status >>= 4; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6509 switch (status) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6510 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6511 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6512 sense_key = KEY_NO_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6513 add_sense_code = SD_SCSI_NO_ADD_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6514 add_sense_code_qual = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6515 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6516 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6517 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6518 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6519 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6520 add_sense_code_qual = SCSI_COMPONENT_81; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6521 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6522 case 2: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6523 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6524 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6525 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6526 add_sense_code_qual = SCSI_COMPONENT_82; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6527 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6528 case 3: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6529 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6530 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6531 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6532 add_sense_code_qual = SCSI_COMPONENT_83; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6533 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6534 case 4: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6535 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6536 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6537 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6538 add_sense_code_qual = SCSI_COMPONENT_84; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6539 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6540 case 5: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6541 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6542 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6543 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6544 add_sense_code_qual = SCSI_COMPONENT_85; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6545 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6546 case 6: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6547 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6548 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6549 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6550 add_sense_code_qual = SCSI_COMPONENT_86; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6551 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6552 case 7: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6553 sense_key = KEY_MEDIUM_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6554 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6555 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6556 add_sense_code_qual = SCSI_COMPONENT_87; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6557 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6558 case 8: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6559 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6560 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6561 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6562 add_sense_code_qual = SCSI_COMPONENT_88; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6563 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6564 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6565 code = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6566 status |= (code << 4); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6567 lpp->param_values[0] = status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6568 lpp->param_values[1] = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6569 lpp->param_values[2] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6570 smart_ext_selftest_log_timestamp[1]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6571 lpp->param_values[3] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6572 smart_ext_selftest_log_timestamp[0]; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6573 if (status != 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6574 lpp->param_values[4] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6575 lpp->param_values[5] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6576 lpp->param_values[6] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6577 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6578 [5]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6579 lpp->param_values[7] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6580 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6581 [4]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6582 lpp->param_values[8] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6583 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6584 [3]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6585 lpp->param_values[9] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6586 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6587 [2]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6588 lpp->param_values[10] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6589 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6590 [1]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6591 lpp->param_values[11] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6592 smart_ext_selftest_log_failing_lba |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6593 [0]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6594 } else { /* No bad block address */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6595 lpp->param_values[4] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6596 lpp->param_values[5] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6597 lpp->param_values[6] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6598 lpp->param_values[7] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6599 lpp->param_values[8] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6600 lpp->param_values[9] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6601 lpp->param_values[10] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6602 lpp->param_values[11] = 0xff; |
|
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 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6605 lpp->param_values[12] = sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6606 lpp->param_values[13] = add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6607 lpp->param_values[14] = add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6608 lpp->param_values[15] = 0; /* undefined */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6609 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6610 lpp = (struct log_parameter *) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6611 (((uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6612 SCSI_LOG_PARAM_HDR_LEN + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6613 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6614 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6615 --index; /* Back up to previous entry */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6616 if (index < 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6617 if (block_num > 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6618 --block_num; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6619 } else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6620 struct read_log_ext_directory |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6621 logdir; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6622 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6623 rval = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6624 sata_read_log_ext_directory( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6625 sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6626 &logdir); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6627 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6628 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6629 if ((logdir.read_log_ext_vers |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6630 [0] == 0) && |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6631 (logdir.read_log_ext_vers |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6632 [1] == 0)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6633 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6634 block_num = |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6635 logdir.read_log_ext_nblks |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6636 [EXT_SMART_SELFTEST_LOG_PAGE |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6637 - 1][0]; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6638 block_num |= logdir. |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6639 read_log_ext_nblks |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6640 [EXT_SMART_SELFTEST_LOG_PAGE |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6641 - 1][1] << 8; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6642 --block_num; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6643 only_one_block = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6644 (block_num == 0); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6645 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6646 rval = sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6647 sata_hba_inst, sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6648 ext_selftest_log, block_num); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6649 if (rval != 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6650 goto out; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6651 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6652 index = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6653 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6654 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6655 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6656 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6657 entry = &ext_selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6658 smart_ext_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6659 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6660 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6661 out: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6662 kmem_free(ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6663 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6664 } else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6665 struct smart_selftest_log *selftest_log; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6666 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6667 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
|
6668 KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6669 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6670 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
|
6671 selftest_log); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6672 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6673 if (rval == 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6674 int index; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6675 int count; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6676 struct smart_selftest_log_entry *entry; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6677 static const struct smart_selftest_log_entry empty = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6678 { 0 }; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6679 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6680 index = selftest_log->smart_selftest_log_index; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6681 if (index == 0) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6682 goto done; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6683 --index; /* Correct for 0 origin */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6684 entry = &selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6685 smart_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6686 for (count = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6687 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6688 ++count) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6689 uint8_t status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6690 uint8_t code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6691 uint8_t sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6692 uint8_t add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6693 uint8_t add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6694 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6695 if (bcmp(entry, &empty, sizeof (empty)) == 0) |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6696 goto done; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6697 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6698 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6699 lpp->param_code[1] = count; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6700 lpp->param_ctrl_flags = |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6701 LOG_CTRL_LP | LOG_CTRL_LBIN; |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6702 lpp->param_len = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6703 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6704 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6705 status = entry->smart_selftest_log_status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6706 status >>= 4; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6707 switch (status) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6708 case 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6709 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6710 sense_key = KEY_NO_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6711 add_sense_code = SD_SCSI_NO_ADD_SENSE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6712 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6713 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6714 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6715 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6716 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6717 add_sense_code_qual = SCSI_COMPONENT_81; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6718 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6719 case 2: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6720 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6721 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6722 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6723 add_sense_code_qual = SCSI_COMPONENT_82; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6724 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6725 case 3: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6726 sense_key = KEY_ABORTED_COMMAND; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6727 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6728 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6729 add_sense_code_qual = SCSI_COMPONENT_83; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6730 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6731 case 4: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6732 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6733 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6734 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6735 add_sense_code_qual = SCSI_COMPONENT_84; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6736 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6737 case 5: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6738 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6739 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6740 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6741 add_sense_code_qual = SCSI_COMPONENT_85; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6742 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6743 case 6: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6744 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6745 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6746 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6747 add_sense_code_qual = SCSI_COMPONENT_86; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6748 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6749 case 7: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6750 sense_key = KEY_MEDIUM_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6751 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6752 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6753 add_sense_code_qual = SCSI_COMPONENT_87; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6754 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6755 case 8: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6756 sense_key = KEY_HARDWARE_ERROR; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6757 add_sense_code = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6758 DIAGNOSTIC_FAILURE_ON_COMPONENT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6759 add_sense_code_qual = SCSI_COMPONENT_88; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6760 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6761 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6762 code = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6763 status |= (code << 4); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6764 lpp->param_values[0] = status; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6765 lpp->param_values[1] = 0; /* unspecified */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6766 lpp->param_values[2] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6767 smart_selftest_log_timestamp[1]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6768 lpp->param_values[3] = entry-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6769 smart_selftest_log_timestamp[0]; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6770 if (status != 0) { |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6771 lpp->param_values[4] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6772 lpp->param_values[5] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6773 lpp->param_values[6] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6774 lpp->param_values[7] = 0; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6775 lpp->param_values[8] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6776 smart_selftest_log_failing_lba[3]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6777 lpp->param_values[9] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6778 smart_selftest_log_failing_lba[2]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6779 lpp->param_values[10] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6780 smart_selftest_log_failing_lba[1]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6781 lpp->param_values[11] = entry-> |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6782 smart_selftest_log_failing_lba[0]; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6783 } else { /* No block address */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6784 lpp->param_values[4] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6785 lpp->param_values[5] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6786 lpp->param_values[6] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6787 lpp->param_values[7] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6788 lpp->param_values[8] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6789 lpp->param_values[9] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6790 lpp->param_values[10] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6791 lpp->param_values[11] = 0xff; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6792 } |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6793 lpp->param_values[12] = sense_key; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6794 lpp->param_values[13] = add_sense_code; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6795 lpp->param_values[14] = add_sense_code_qual; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6796 lpp->param_values[15] = 0; /* undefined */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6797 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6798 lpp = (struct log_parameter *) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6799 (((uint8_t *)lpp) + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6800 SCSI_LOG_PARAM_HDR_LEN + |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6801 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6802 --index; /* back up to previous entry */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6803 if (index < 0) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6804 index = |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6805 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6806 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6807 entry = &selftest_log-> |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6808 smart_selftest_log_entries[index]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6809 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6810 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6811 done: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6812 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
|
6813 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6814 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6815 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
|
6816 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6817 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6818 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6819 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6820 * 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
|
6821 * SCSI LOG SENSE page 0x10 (informational exceptions) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6822 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6823 * 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
|
6824 * 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
|
6825 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6826 * 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
|
6827 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6828 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6829 sata_build_lsense_page_2f( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6830 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6831 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6832 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6833 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6834 struct log_parameter *lpp = (struct log_parameter *)buf; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6835 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6836 uint8_t *smart_data; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6837 uint8_t temp; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6838 sata_id_t *sata_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6839 #define SMART_NO_TEMP 0xff |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6840 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6841 lpp->param_code[0] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6842 lpp->param_code[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6843 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
|
6844 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6845 /* 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
|
6846 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
|
6847 switch (rval) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6848 case 1: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6849 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6850 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; |
|
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 0: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6853 case -1: /* failed to get data */ |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6854 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
|
6855 lpp->param_values[1] = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6856 break; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6857 #if defined(SATA_DEBUG) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6858 default: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6859 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
|
6860 /* NOTREACHED */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6861 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6862 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6863 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6864 sata_id = &sdinfo->satadrv_id; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6865 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
|
6866 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6867 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6868 /* Now get the temperature */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6869 smart_data = kmem_zalloc(512, KM_SLEEP); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6870 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
|
6871 SCT_STATUS_LOG_PAGE, 1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6872 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6873 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6874 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6875 temp = smart_data[200]; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6876 if (temp & 0x80) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6877 if (temp & 0x7f) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6878 temp = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6879 else |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6880 temp = SMART_NO_TEMP; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6881 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6882 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6883 kmem_free(smart_data, 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6884 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6885 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6886 lpp->param_values[2] = temp; /* most recent temperature */ |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
6887 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
|
6888 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6889 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6890 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6891 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6892 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
|
6893 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6894 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6895 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6896 * 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
|
6897 * 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
|
6898 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6899 * 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
|
6900 * 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
|
6901 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6902 * 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
|
6903 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6904 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6905 sata_build_lsense_page_30( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6906 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6907 uint8_t *buf, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6908 sata_hba_inst_t *sata_hba_inst) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6909 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6910 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
|
6911 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6912 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6913 /* Now do the SMART READ DATA */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6914 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
|
6915 if (rval == -1) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6916 return (0); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6917 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
6918 return (sizeof (struct smart_data)); |
|
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 |
| 1258 | 6921 |
| 6922 | |
| 6923 | |
| 6924 | |
| 6925 /* ************************** LOCAL FUNCTIONS ************************** */ | |
| 6926 | |
| 6927 /* | |
| 6928 * Validate sata_tran info | |
| 6929 * SATA_FAILURE returns if structure is inconsistent or structure revision | |
| 6930 * does not match one used by the framework. | |
| 6931 * | |
| 6932 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains | |
| 6933 * required function pointers. | |
| 6934 * Returns SATA_FAILURE otherwise. | |
| 6935 */ | |
| 6936 static int | |
| 6937 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) | |
| 6938 { | |
| 6939 if (sata_tran->sata_tran_hba_rev != SATA_TRAN_HBA_REV) { | |
| 6940 sata_log(NULL, CE_WARN, | |
| 6941 "sata: invalid sata_hba_tran version %d for driver %s", | |
| 6942 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); | |
| 6943 return (SATA_FAILURE); | |
| 6944 } | |
| 6945 | |
| 6946 if (dip != sata_tran->sata_tran_hba_dip) { | |
| 6947 SATA_LOG_D((NULL, CE_WARN, | |
| 6948 "sata: inconsistent sata_tran_hba_dip " | |
| 6949 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); | |
| 6950 return (SATA_FAILURE); | |
| 6951 } | |
| 6952 | |
| 6953 if (sata_tran->sata_tran_probe_port == NULL || | |
| 6954 sata_tran->sata_tran_start == NULL || | |
| 6955 sata_tran->sata_tran_abort == NULL || | |
| 6956 sata_tran->sata_tran_reset_dport == NULL) { | |
| 6957 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " | |
| 6958 "required functions")); | |
| 6959 } | |
| 6960 return (SATA_SUCCESS); | |
| 6961 } | |
| 6962 | |
| 6963 /* | |
| 6964 * Remove HBA instance from sata_hba_list. | |
| 6965 */ | |
| 6966 static void | |
| 6967 sata_remove_hba_instance(dev_info_t *dip) | |
| 6968 { | |
| 6969 sata_hba_inst_t *sata_hba_inst; | |
| 6970 | |
| 6971 mutex_enter(&sata_mutex); | |
| 6972 for (sata_hba_inst = sata_hba_list; | |
| 6973 sata_hba_inst != (struct sata_hba_inst *)NULL; | |
| 6974 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 6975 if (sata_hba_inst->satahba_dip == dip) | |
| 6976 break; | |
| 6977 } | |
| 6978 | |
| 6979 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { | |
| 6980 #ifdef SATA_DEBUG | |
| 6981 cmn_err(CE_WARN, "sata_remove_hba_instance: " | |
| 6982 "unknown HBA instance\n"); | |
| 6983 #endif | |
| 6984 ASSERT(FALSE); | |
| 6985 } | |
| 6986 if (sata_hba_inst == sata_hba_list) { | |
| 6987 sata_hba_list = sata_hba_inst->satahba_next; | |
| 6988 if (sata_hba_list) { | |
| 6989 sata_hba_list->satahba_prev = | |
| 6990 (struct sata_hba_inst *)NULL; | |
| 6991 } | |
| 6992 if (sata_hba_inst == sata_hba_list_tail) { | |
| 6993 sata_hba_list_tail = NULL; | |
| 6994 } | |
| 6995 } else if (sata_hba_inst == sata_hba_list_tail) { | |
| 6996 sata_hba_list_tail = sata_hba_inst->satahba_prev; | |
| 6997 if (sata_hba_list_tail) { | |
| 6998 sata_hba_list_tail->satahba_next = | |
| 6999 (struct sata_hba_inst *)NULL; | |
| 7000 } | |
| 7001 } else { | |
| 7002 sata_hba_inst->satahba_prev->satahba_next = | |
| 7003 sata_hba_inst->satahba_next; | |
| 7004 sata_hba_inst->satahba_next->satahba_prev = | |
| 7005 sata_hba_inst->satahba_prev; | |
| 7006 } | |
| 7007 mutex_exit(&sata_mutex); | |
| 7008 } | |
| 7009 | |
| 7010 | |
| 7011 | |
| 7012 | |
| 7013 | |
| 7014 /* | |
| 7015 * Probe all SATA ports of the specified HBA instance. | |
| 7016 * This function is called only from sata_hba_attach(). It does not have to | |
| 7017 * be protected by controller mutex, because the hba_attached flag is not set | |
| 7018 * yet and no one would be touching this HBA instance other then this thread. | |
| 7019 * Determines if port is active and what type of the device is attached | |
| 7020 * (if any). Allocates necessary structures for each port. | |
| 7021 * Creates attachment point minor node for each non-failed port. | |
| 7022 */ | |
| 7023 | |
| 7024 static void | |
| 7025 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) | |
| 7026 { | |
| 7027 dev_info_t *dip = SATA_DIP(sata_hba_inst); | |
| 7028 int ncport, npmport; | |
| 7029 sata_cport_info_t *cportinfo; | |
| 7030 sata_drive_info_t *drive; | |
| 7031 sata_pmult_info_t *pminfo; | |
| 7032 sata_pmport_info_t *pmportinfo; | |
| 7033 sata_device_t sata_device; | |
| 7034 int rval; | |
| 7035 dev_t minor_number; | |
| 7036 char name[16]; | |
| 7037 | |
| 7038 /* | |
| 7039 * Probe controller ports first, to find port status and | |
| 7040 * any port multiplier attached. | |
| 7041 */ | |
| 7042 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 7043 /* allocate cport structure */ | |
| 7044 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); | |
| 7045 ASSERT(cportinfo != NULL); | |
| 7046 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); | |
| 7047 | |
| 7048 mutex_enter(&cportinfo->cport_mutex); | |
| 7049 | |
| 7050 cportinfo->cport_addr.cport = ncport; | |
| 7051 cportinfo->cport_addr.pmport = 0; | |
| 7052 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; | |
| 7053 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; | |
| 7054 cportinfo->cport_state |= SATA_STATE_PROBING; | |
| 7055 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; | |
| 7056 | |
| 7057 /* | |
| 7058 * Regardless if a port is usable or not, create | |
| 7059 * an attachment point | |
| 7060 */ | |
| 7061 mutex_exit(&cportinfo->cport_mutex); | |
| 7062 minor_number = | |
| 7063 SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0); | |
| 7064 (void) sprintf(name, "%d", ncport); | |
| 7065 if (ddi_create_minor_node(dip, name, S_IFCHR, | |
| 7066 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != | |
| 7067 DDI_SUCCESS) { | |
| 7068 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " | |
| 7069 "cannot create sata attachment point for port %d", | |
| 7070 ncport); | |
| 7071 } | |
| 7072 | |
| 7073 /* Probe port */ | |
| 7074 sata_device.satadev_addr.cport = ncport; | |
| 7075 sata_device.satadev_addr.pmport = 0; | |
| 7076 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 7077 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 7078 | |
| 7079 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7080 (dip, &sata_device); | |
| 7081 | |
| 7082 mutex_enter(&cportinfo->cport_mutex); | |
| 7083 sata_update_port_scr(&cportinfo->cport_scr, &sata_device); | |
| 7084 if (rval != SATA_SUCCESS) { | |
| 7085 /* Something went wrong? Fail the port */ | |
| 7086 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 7087 mutex_exit(&cportinfo->cport_mutex); | |
| 7088 continue; | |
| 7089 } | |
| 7090 cportinfo->cport_state &= ~SATA_STATE_PROBING; | |
| 7091 cportinfo->cport_state |= SATA_STATE_PROBED; | |
| 7092 cportinfo->cport_dev_type = sata_device.satadev_type; | |
| 7093 | |
| 7094 cportinfo->cport_state |= SATA_STATE_READY; | |
| 7095 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { | |
| 7096 mutex_exit(&cportinfo->cport_mutex); | |
| 7097 continue; | |
| 7098 } | |
| 7099 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 7100 /* | |
| 7101 * There is some device attached. | |
| 7102 * Allocate device info structure | |
| 7103 */ | |
| 7104 mutex_exit(&cportinfo->cport_mutex); | |
| 7105 drive = kmem_zalloc(sizeof (sata_drive_info_t), | |
| 7106 KM_SLEEP); | |
| 7107 mutex_enter(&cportinfo->cport_mutex); | |
| 7108 SATA_CPORTINFO_DRV_INFO(cportinfo) = drive; | |
| 7109 drive->satadrv_addr = cportinfo->cport_addr; | |
| 7110 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; | |
| 7111 drive->satadrv_type = cportinfo->cport_dev_type; | |
| 7112 drive->satadrv_state = SATA_STATE_UNKNOWN; | |
| 7113 } else { | |
| 7114 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); | |
| 7115 mutex_exit(&cportinfo->cport_mutex); | |
| 7116 pminfo = kmem_zalloc(sizeof (sata_pmult_info_t), | |
| 7117 KM_SLEEP); | |
| 7118 mutex_enter(&cportinfo->cport_mutex); | |
| 7119 ASSERT(pminfo != NULL); | |
| 7120 SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo; | |
| 7121 pminfo->pmult_addr.cport = cportinfo->cport_addr.cport; | |
| 7122 pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT; | |
| 7123 pminfo->pmult_addr.qual = SATA_ADDR_PMPORT; | |
| 7124 pminfo->pmult_num_dev_ports = | |
| 7125 sata_device.satadev_add_info; | |
| 7126 mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER, | |
| 7127 NULL); | |
| 7128 pminfo->pmult_state = SATA_STATE_PROBING; | |
| 7129 | |
| 7130 /* Probe Port Multiplier ports */ | |
| 7131 for (npmport = 0; | |
| 7132 npmport < pminfo->pmult_num_dev_ports; | |
| 7133 npmport++) { | |
| 7134 mutex_exit(&cportinfo->cport_mutex); | |
| 7135 pmportinfo = kmem_zalloc( | |
| 7136 sizeof (sata_pmport_info_t), KM_SLEEP); | |
| 7137 mutex_enter(&cportinfo->cport_mutex); | |
| 7138 ASSERT(pmportinfo != NULL); | |
| 7139 pmportinfo->pmport_addr.cport = ncport; | |
| 7140 pmportinfo->pmport_addr.pmport = npmport; | |
| 7141 pmportinfo->pmport_addr.qual = | |
| 7142 SATA_ADDR_PMPORT; | |
| 7143 pminfo->pmult_dev_port[npmport] = pmportinfo; | |
| 7144 mutex_init(&pmportinfo->pmport_mutex, NULL, | |
| 7145 MUTEX_DRIVER, NULL); | |
| 7146 | |
| 7147 sata_device.satadev_addr.pmport = npmport; | |
| 7148 sata_device.satadev_addr.qual = | |
| 7149 SATA_ADDR_PMPORT; | |
| 7150 | |
| 7151 mutex_exit(&cportinfo->cport_mutex); | |
| 7152 /* Create an attachment point */ | |
| 7153 minor_number = SATA_MAKE_AP_MINOR( | |
| 7154 ddi_get_instance(dip), ncport, npmport, 1); | |
| 7155 (void) sprintf(name, "%d.%d", ncport, npmport); | |
| 7156 if (ddi_create_minor_node(dip, name, S_IFCHR, | |
| 7157 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, | |
| 7158 0) != DDI_SUCCESS) { | |
| 7159 sata_log(sata_hba_inst, CE_WARN, | |
| 7160 "sata_hba_attach: " | |
| 7161 "cannot create sata attachment " | |
| 7162 "point for port %d pmult port %d", | |
| 7163 ncport, npmport); | |
| 7164 } | |
| 7165 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7166 (dip, &sata_device); | |
| 7167 mutex_enter(&cportinfo->cport_mutex); | |
| 7168 | |
| 7169 /* sata_update_port_info() */ | |
| 7170 sata_update_port_scr(&pmportinfo->pmport_scr, | |
| 7171 &sata_device); | |
| 7172 | |
| 7173 if (rval != SATA_SUCCESS) { | |
| 7174 pmportinfo->pmport_state = | |
| 7175 SATA_PSTATE_FAILED; | |
| 7176 continue; | |
| 7177 } | |
| 7178 pmportinfo->pmport_state &= | |
| 7179 ~SATA_STATE_PROBING; | |
| 7180 pmportinfo->pmport_state |= SATA_STATE_PROBED; | |
| 7181 pmportinfo->pmport_dev_type = | |
| 7182 sata_device.satadev_type; | |
| 7183 | |
| 7184 pmportinfo->pmport_state |= SATA_STATE_READY; | |
| 7185 if (pmportinfo->pmport_dev_type == | |
| 7186 SATA_DTYPE_NONE) | |
| 7187 continue; | |
| 7188 | |
| 7189 /* Port multipliers cannot be chained */ | |
| 7190 ASSERT(pmportinfo->pmport_dev_type != | |
| 7191 SATA_DTYPE_PMULT); | |
| 7192 /* | |
| 7193 * There is something attached to Port | |
| 7194 * Multiplier device port | |
| 7195 * Allocate device info structure | |
| 7196 */ | |
| 7197 mutex_exit(&cportinfo->cport_mutex); | |
| 7198 drive = kmem_zalloc( | |
| 7199 sizeof (sata_drive_info_t), KM_SLEEP); | |
| 7200 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7201 (dip, &sata_device); | |
| 7202 mutex_enter(&cportinfo->cport_mutex); | |
| 7203 | |
| 7204 /* sata_update_port_info() */ | |
| 7205 sata_update_port_scr(&pmportinfo->pmport_scr, | |
| 7206 &sata_device); | |
| 7207 | |
| 7208 pmportinfo->pmport_sata_drive = drive; | |
| 7209 drive->satadrv_addr.cport = | |
| 7210 pmportinfo->pmport_addr.cport; | |
| 7211 drive->satadrv_addr.pmport = npmport; | |
| 7212 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; | |
| 7213 drive->satadrv_type = pmportinfo-> | |
| 7214 pmport_dev_type; | |
| 7215 drive->satadrv_state = SATA_STATE_UNKNOWN; | |
| 7216 } | |
| 7217 pmportinfo->pmport_state = | |
| 7218 SATA_STATE_PROBED | SATA_STATE_READY; | |
| 7219 } | |
| 7220 mutex_exit(&cportinfo->cport_mutex); | |
| 7221 } | |
| 7222 } | |
| 7223 | |
| 7224 | |
| 7225 | |
| 7226 /* | |
| 7227 * Create SATA device nodes for specified HBA instance (SCSI target | |
| 7228 * device nodes). | |
| 7229 * This function is called only from sata_hba_attach(). The hba_attached flag | |
| 7230 * is not set yet, so no ports or device data structures would be touched | |
| 7231 * by anyone other then this thread, therefore per-port mutex protection is | |
| 7232 * not needed. | |
| 7233 * The assumption is that there are no target and attachment point minor nodes | |
| 7234 * created by the boot subsystems, so we do not need to prune device tree. | |
| 7235 * An AP (Attachement Point) node is created for each SATA device port even | |
| 7236 * when there is no device attached. | |
| 7237 * A target node is created when there is a supported type of device attached, | |
| 7238 * but may be removed if it cannot be put online. | |
| 7239 * | |
| 7240 * This function cannot be called from an interrupt context. | |
| 7241 * | |
| 7242 * ONLY DISK TARGET NODES ARE CREATED NOW | |
| 7243 */ | |
| 7244 static void | |
| 7245 sata_make_device_nodes(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst) | |
| 7246 { | |
| 7247 int ncport, npmport; | |
| 7248 sata_cport_info_t *cportinfo; | |
| 7249 sata_pmult_info_t *pminfo; | |
| 7250 sata_pmport_info_t *pmportinfo; | |
| 7251 dev_info_t *cdip; /* child dip */ | |
| 7252 sata_device_t sata_device; | |
| 7253 int rval; | |
| 7254 | |
| 7255 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7256 * Walk through pre-probed sata ports info in sata_hba_inst structure |
| 1258 | 7257 */ |
| 7258 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 7259 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); | |
| 7260 mutex_enter(&cportinfo->cport_mutex); | |
| 7261 if (!(cportinfo->cport_state & SATA_STATE_PROBED)) { | |
| 7262 mutex_exit(&cportinfo->cport_mutex); | |
| 7263 continue; | |
| 7264 } | |
| 7265 if (cportinfo->cport_state == SATA_PSTATE_FAILED) { | |
| 7266 mutex_exit(&cportinfo->cport_mutex); | |
| 7267 continue; | |
| 7268 } | |
| 7269 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { | |
| 7270 /* No device attached to the controller port */ | |
| 7271 mutex_exit(&cportinfo->cport_mutex); | |
| 7272 continue; | |
| 7273 } | |
| 7274 /* | |
| 7275 * Some device is attached to a controller port. | |
| 7276 * We rely on controllers distinquishing between no-device, | |
| 7277 * attached port multiplier and other kind of attached device. | |
| 7278 * We need to get Identify Device data and determine | |
| 7279 * positively the dev type before trying to attach | |
| 7280 * the target driver. | |
| 7281 */ | |
| 7282 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 7283 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 7284 /* | |
| 7285 * Not port multiplier. | |
| 7286 */ | |
| 7287 sata_device.satadev_addr = cportinfo->cport_addr; | |
| 7288 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; | |
| 7289 mutex_exit(&cportinfo->cport_mutex); | |
| 7290 rval = sata_probe_device(sata_hba_inst, &sata_device); | |
| 7291 if (rval != SATA_SUCCESS || | |
| 7292 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) | |
| 7293 continue; | |
| 7294 | |
| 7295 mutex_enter(&cportinfo->cport_mutex); | |
| 7296 if ((sata_device.satadev_type & | |
| 7297 SATA_VALID_DEV_TYPE) == 0) { | |
| 7298 /* | |
| 7299 * Could not determine device type or | |
| 7300 * a device is not supported. | |
| 7301 * Degrade this device to unknown. | |
| 7302 */ | |
| 7303 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7304 mutex_exit(&cportinfo->cport_mutex); | |
| 7305 continue; | |
| 7306 } | |
| 7307 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
|
7308 mutex_exit(&cportinfo->cport_mutex); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7309 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7310 if (sata_initialize_device(sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7311 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7312 /* Retry */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7313 (void) sata_initialize_device(sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7314 SATA_CPORTINFO_DRV_INFO(cportinfo)); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7315 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7316 mutex_enter(&cportinfo->cport_mutex); |
| 1258 | 7317 sata_show_drive_info(sata_hba_inst, |
| 7318 SATA_CPORTINFO_DRV_INFO(cportinfo)); | |
| 7319 mutex_exit(&cportinfo->cport_mutex); | |
| 7320 cdip = sata_create_target_node(pdip, sata_hba_inst, | |
| 7321 &sata_device.satadev_addr); | |
| 7322 mutex_enter(&cportinfo->cport_mutex); | |
| 7323 if (cdip == NULL) { | |
| 7324 /* | |
| 7325 * Attaching target node failed. | |
| 7326 * We retain sata_drive_info structure... | |
| 7327 */ | |
| 7328 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 7329 satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 7330 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 7331 satadrv_state = SATA_STATE_UNKNOWN; | |
| 7332 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7333 mutex_exit(&cportinfo->cport_mutex); | |
| 7334 continue; | |
| 7335 } | |
| 7336 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 7337 satadrv_state = SATA_STATE_READY; | |
| 7338 } else { | |
| 7339 /* This must be Port Multiplier type */ | |
| 7340 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { | |
| 7341 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7342 "sata_make_device_nodes: " | |
| 7343 "unknown dev type %x", | |
| 7344 cportinfo->cport_dev_type)); | |
| 7345 mutex_exit(&cportinfo->cport_mutex); | |
| 7346 continue; | |
| 7347 } | |
| 7348 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); | |
| 7349 for (npmport = 0; | |
| 7350 npmport < pminfo->pmult_num_dev_ports; | |
| 7351 npmport++) { | |
| 7352 pmportinfo = pminfo->pmult_dev_port[npmport]; | |
| 7353 if (pmportinfo->pmport_state & | |
| 7354 SATA_PSTATE_FAILED) { | |
| 7355 continue; | |
| 7356 } | |
| 7357 if (pmportinfo->pmport_dev_type & | |
| 7358 SATA_DTYPE_NONE) | |
| 7359 /* No device attached */ | |
| 7360 continue; | |
| 7361 | |
| 7362 sata_device.satadev_addr = | |
| 7363 pmportinfo->pmport_addr; | |
| 7364 sata_device.satadev_addr.qual = | |
| 7365 SATA_ADDR_DPMPORT; | |
| 7366 mutex_exit(&cportinfo->cport_mutex); | |
| 7367 rval = sata_probe_device(sata_hba_inst, | |
| 7368 &sata_device); | |
| 7369 if (rval != SATA_SUCCESS || | |
| 7370 sata_device.satadev_type == | |
| 7371 SATA_DTYPE_UNKNOWN) { | |
| 7372 mutex_enter(&cportinfo->cport_mutex); | |
| 7373 continue; | |
| 7374 } | |
| 7375 mutex_enter(&cportinfo->cport_mutex); | |
| 7376 if ((sata_device.satadev_type & | |
| 7377 SATA_VALID_DEV_TYPE) == 0) { | |
| 7378 /* | |
| 7379 * Could not determine device type. | |
| 7380 * Degrade this device to unknown. | |
| 7381 */ | |
| 7382 pmportinfo->pmport_dev_type = | |
| 7383 SATA_DTYPE_UNKNOWN; | |
| 7384 continue; | |
| 7385 } | |
| 7386 pmportinfo->pmport_dev_type = | |
| 7387 sata_device.satadev_type; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7388 mutex_exit(&cportinfo->cport_mutex); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7389 if (sata_initialize_device(sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7390 pmportinfo->pmport_sata_drive) != |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7391 SATA_SUCCESS) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7392 /* Retry */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7393 (void) sata_initialize_device( |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7394 sata_hba_inst, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7395 pmportinfo->pmport_sata_drive); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7396 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7397 mutex_enter(&cportinfo->cport_mutex); |
| 1258 | 7398 sata_show_drive_info(sata_hba_inst, |
| 7399 pmportinfo->pmport_sata_drive); | |
| 7400 mutex_exit(&cportinfo->cport_mutex); | |
| 7401 cdip = sata_create_target_node(pdip, | |
| 7402 sata_hba_inst, &sata_device.satadev_addr); | |
| 7403 mutex_enter(&cportinfo->cport_mutex); | |
| 7404 if (cdip == NULL) { | |
| 7405 /* | |
| 7406 * Attaching target node failed. | |
| 7407 * We retain sata_drive_info | |
| 7408 * structure... | |
| 7409 */ | |
| 7410 pmportinfo->pmport_sata_drive-> | |
| 7411 satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 7412 pmportinfo->pmport_sata_drive-> | |
| 7413 satadrv_state = SATA_STATE_UNKNOWN; | |
| 7414 pmportinfo->pmport_dev_type = | |
| 7415 SATA_DTYPE_UNKNOWN; | |
| 7416 continue; | |
| 7417 } | |
| 7418 pmportinfo->pmport_sata_drive-> | |
| 7419 satadrv_state |= SATA_STATE_READY; | |
| 7420 } | |
| 7421 } | |
| 7422 mutex_exit(&cportinfo->cport_mutex); | |
| 7423 } | |
| 7424 } | |
| 7425 | |
| 7426 | |
| 7427 | |
| 7428 /* | |
| 7429 * Create scsi target node for attached device, create node properties and | |
| 7430 * attach the node. | |
| 7431 * The node could be removed if the device onlining fails. | |
| 7432 * | |
| 7433 * A dev_info_t pointer is returned if operation is successful, NULL is | |
| 7434 * returned otherwise. | |
| 7435 */ | |
| 7436 | |
| 7437 static dev_info_t * | |
| 7438 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, | |
| 7439 sata_address_t *sata_addr) | |
| 7440 { | |
| 7441 dev_info_t *cdip = NULL; | |
| 7442 int rval; | |
| 7443 char *nname = NULL; | |
| 7444 char **compatible = NULL; | |
| 7445 int ncompatible; | |
| 7446 struct scsi_inquiry inq; | |
| 7447 sata_device_t sata_device; | |
| 7448 sata_drive_info_t *sdinfo; | |
| 7449 int target; | |
| 7450 int i; | |
| 7451 | |
| 7452 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 7453 sata_device.satadev_addr = *sata_addr; | |
| 7454 | |
| 7455 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); | |
| 7456 | |
| 7457 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); | |
| 7458 | |
| 7459 target = SATA_TO_SCSI_TARGET(sata_addr->cport, | |
| 7460 sata_addr->pmport, sata_addr->qual); | |
| 7461 | |
| 7462 if (sdinfo == NULL) { | |
| 7463 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 7464 sata_addr->cport))); | |
| 7465 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7466 "sata_create_target_node: no sdinfo for target %x", | |
| 7467 target)); | |
| 7468 return (NULL); | |
| 7469 } | |
| 7470 | |
| 7471 /* | |
| 7472 * create scsi inquiry data, expected by | |
| 7473 * scsi_hba_nodename_compatible_get() | |
| 7474 */ | |
| 7475 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, (uint8_t *)&inq); | |
| 7476 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); | |
| 7477 | |
| 7478 /* determine the node name and compatible */ | |
| 7479 scsi_hba_nodename_compatible_get(&inq, NULL, | |
| 7480 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); | |
| 7481 | |
| 7482 #ifdef SATA_DEBUG | |
| 7483 if (sata_debug_flags & SATA_DBG_NODES) { | |
| 7484 if (nname == NULL) { | |
| 7485 cmn_err(CE_NOTE, "sata_create_target_node: " | |
| 7486 "cannot determine nodename for target %d\n", | |
| 7487 target); | |
| 7488 } else { | |
| 7489 cmn_err(CE_WARN, "sata_create_target_node: " | |
| 7490 "target %d nodename: %s\n", target, nname); | |
| 7491 } | |
| 7492 if (compatible == NULL) { | |
| 7493 cmn_err(CE_WARN, | |
| 7494 "sata_create_target_node: no compatible name\n"); | |
| 7495 } else { | |
| 7496 for (i = 0; i < ncompatible; i++) { | |
| 7497 cmn_err(CE_WARN, "sata_create_target_node: " | |
| 7498 "compatible name: %s\n", compatible[i]); | |
| 7499 } | |
| 7500 } | |
| 7501 } | |
| 7502 #endif | |
| 7503 | |
| 7504 /* if nodename can't be determined, log error and exit */ | |
| 7505 if (nname == NULL) { | |
| 7506 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7507 "sata_create_target_node: cannot determine nodename " | |
| 7508 "for target %d\n", target)); | |
| 7509 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 7510 return (NULL); | |
| 7511 } | |
| 7512 /* | |
| 7513 * Create scsi target node | |
| 7514 */ | |
| 7515 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); | |
| 7516 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, | |
| 7517 "device-type", "scsi"); | |
| 7518 | |
| 7519 if (rval != DDI_PROP_SUCCESS) { | |
| 7520 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7521 "updating device_type prop failed %d", rval)); | |
| 7522 goto fail; | |
| 7523 } | |
| 7524 | |
| 7525 /* | |
| 7526 * Create target node properties: target & lun | |
| 7527 */ | |
| 7528 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); | |
| 7529 if (rval != DDI_PROP_SUCCESS) { | |
| 7530 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7531 "updating target prop failed %d", rval)); | |
| 7532 goto fail; | |
| 7533 } | |
| 7534 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); | |
| 7535 if (rval != DDI_PROP_SUCCESS) { | |
| 7536 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7537 "updating target prop failed %d", rval)); | |
| 7538 goto fail; | |
| 7539 } | |
| 7540 | |
| 7541 /* decorate the node with compatible */ | |
| 7542 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", | |
| 7543 compatible, ncompatible) != DDI_PROP_SUCCESS) { | |
| 7544 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 7545 "sata_create_target_node: FAIL compatible props cdip 0x%p", | |
| 7546 (void *)cdip)); | |
| 7547 goto fail; | |
| 7548 } | |
| 7549 | |
| 7550 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7551 * Set default write cache mode |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7552 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7553 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
|
7554 if (rval != SATA_SUCCESS) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7555 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
|
7556 "cannot set deafult write cache mode for " |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7557 "device at port %d", sata_addr->cport); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7558 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7559 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7560 /* |
| 1258 | 7561 * Now, try to attach the driver. If probing of the device fails, |
| 7562 * the target node may be removed | |
| 7563 */ | |
| 7564 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); | |
| 7565 | |
| 7566 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 7567 | |
| 7568 if (rval == NDI_SUCCESS) | |
| 7569 return (cdip); | |
| 7570 | |
| 7571 /* target node was removed - are we sure? */ | |
| 7572 return (NULL); | |
| 7573 | |
| 7574 fail: | |
| 7575 scsi_hba_nodename_compatible_free(nname, compatible); | |
| 7576 ddi_prop_remove_all(cdip); | |
| 7577 rval = ndi_devi_free(cdip); | |
| 7578 if (rval != NDI_SUCCESS) { | |
| 7579 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7580 "node removal failed %d", rval)); | |
| 7581 } | |
| 7582 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " | |
| 7583 "cannot create target node for device at port %d", | |
| 7584 sata_addr->cport); | |
| 7585 return (NULL); | |
| 7586 } | |
| 7587 | |
| 7588 | |
| 7589 | |
| 7590 /* | |
| 7591 * Re-probe sata port, check for a device and attach necessary info | |
| 7592 * structures when necessary. Identify Device data is fetched, if possible. | |
| 7593 * Assumption: sata address is already validated. | |
| 7594 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of | |
| 7595 * the presence of a device and its type. | |
| 7596 * SATA_FAILURE is returned if one of the operations failed. | |
| 7597 */ | |
| 7598 static int | |
| 7599 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) | |
| 7600 { | |
| 7601 sata_cport_info_t *cportinfo; | |
| 7602 sata_drive_info_t *sdinfo; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7603 boolean_t init_device = B_FALSE; |
| 1258 | 7604 int rval; |
| 7605 | |
| 7606 /* We only care about host sata cport for now */ | |
| 7607 cportinfo = SATA_CPORT_INFO(sata_hba_inst, | |
| 7608 sata_device->satadev_addr.cport); | |
| 7609 /* probe port */ | |
| 7610 mutex_enter(&cportinfo->cport_mutex); | |
| 7611 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; | |
| 7612 cportinfo->cport_state |= SATA_STATE_PROBING; | |
| 7613 mutex_exit(&cportinfo->cport_mutex); | |
| 7614 | |
| 7615 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 7616 (SATA_DIP(sata_hba_inst), sata_device); | |
| 7617 | |
| 7618 mutex_enter(&cportinfo->cport_mutex); | |
| 7619 if (rval != SATA_SUCCESS) { | |
| 7620 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 7621 mutex_exit(&cportinfo->cport_mutex); | |
| 7622 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_hba_ioctl: " | |
| 7623 "connect: port probbing failed")); | |
| 7624 return (SATA_FAILURE); | |
| 7625 } | |
| 7626 | |
| 7627 /* | |
| 7628 * update sata port state and set device type | |
| 7629 */ | |
| 7630 sata_update_port_info(sata_hba_inst, sata_device); | |
| 7631 cportinfo->cport_state |= SATA_STATE_PROBED; | |
| 7632 | |
| 7633 /* | |
| 7634 * Sanity check - Port is active? Is the link active? | |
| 7635 * Is there any device attached? | |
| 7636 */ | |
| 7637 if ((cportinfo->cport_state & | |
| 7638 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || | |
| 7639 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != | |
| 7640 SATA_PORT_DEVLINK_UP) { | |
| 7641 /* | |
| 7642 * Port in non-usable state or no link active/no device. | |
| 7643 * Free info structure if necessary (direct attached drive | |
| 7644 * only, for now! | |
| 7645 */ | |
| 7646 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 7647 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 7648 /* Add here differentiation for device attached or not */ | |
| 7649 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 7650 mutex_exit(&cportinfo->cport_mutex); | |
| 7651 if (sdinfo != NULL) | |
| 7652 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 7653 return (SATA_SUCCESS); | |
| 7654 } | |
| 7655 | |
| 7656 cportinfo->cport_state |= SATA_STATE_READY; | |
| 7657 cportinfo->cport_dev_type = sata_device->satadev_type; | |
| 7658 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 7659 | |
| 7660 /* | |
| 7661 * If we are re-probing the port, there may be | |
| 7662 * sata_drive_info structure attached | |
| 7663 * (or sata_pm_info, if PMult is supported). | |
| 7664 */ | |
| 7665 if (sata_device->satadev_type == SATA_DTYPE_NONE) { | |
| 7666 /* | |
| 7667 * There is no device, so remove device info structure, | |
| 7668 * if necessary. Direct attached drive only! | |
| 7669 */ | |
| 7670 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 7671 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 7672 if (sdinfo != NULL) { | |
| 7673 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 7674 sata_log(sata_hba_inst, CE_WARN, | |
| 7675 "SATA device detached " | |
| 7676 "from port %d", cportinfo->cport_addr.cport); | |
| 7677 } | |
| 7678 mutex_exit(&cportinfo->cport_mutex); | |
| 7679 return (SATA_SUCCESS); | |
| 7680 } | |
| 7681 | |
| 7682 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { | |
| 7683 if (sdinfo == NULL) { | |
| 7684 /* | |
| 7685 * There is some device attached, but there is | |
| 7686 * no sata_drive_info structure - allocate one | |
| 7687 */ | |
| 7688 mutex_exit(&cportinfo->cport_mutex); | |
| 7689 sdinfo = kmem_zalloc( | |
| 7690 sizeof (sata_drive_info_t), KM_SLEEP); | |
| 7691 mutex_enter(&cportinfo->cport_mutex); | |
| 7692 /* | |
| 7693 * Recheck, if port state did not change when we | |
| 7694 * released mutex. | |
| 7695 */ | |
| 7696 if (cportinfo->cport_state & SATA_STATE_READY) { | |
| 7697 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; | |
| 7698 sdinfo->satadrv_addr = cportinfo->cport_addr; | |
| 7699 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; | |
| 7700 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 7701 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 7702 } else { | |
| 7703 /* | |
| 7704 * Port is not in ready state, we | |
| 7705 * cannot attach a device. | |
| 7706 */ | |
| 7707 mutex_exit(&cportinfo->cport_mutex); | |
| 7708 kmem_free(sdinfo, sizeof (sata_drive_info_t)); | |
| 7709 return (SATA_SUCCESS); | |
| 7710 } | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7711 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7712 * Since we are adding device, presumably new one, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7713 * indicate that it should be initalized, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7714 * as well as some internal framework states). |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7715 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7716 init_device = B_TRUE; |
| 1258 | 7717 } |
| 7718 | |
| 7719 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7720 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; | |
| 7721 } else { | |
| 7722 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; | |
| 7723 mutex_exit(&cportinfo->cport_mutex); | |
| 7724 return (SATA_SUCCESS); | |
| 7725 } | |
| 7726 mutex_exit(&cportinfo->cport_mutex); | |
| 7727 /* | |
| 7728 * Figure out what kind of device we are really | |
| 7729 * dealing with. | |
| 7730 */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7731 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
|
7732 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7733 /* Set initial device features, if necessary */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7734 if (rval == SATA_SUCCESS && init_device == B_TRUE) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7735 if (sata_initialize_device(sata_hba_inst, sdinfo) != |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7736 SATA_SUCCESS) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7737 /* retry */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7738 (void) sata_initialize_device(sata_hba_inst, sdinfo); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7739 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7740 return (rval); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7741 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7742 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7743 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7744 * Initialize device |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7745 * Specified device is initialized to a default state. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7746 * 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
|
7747 * 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
|
7748 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7749 * Only SATA disks are initialized for now. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7750 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7751 * 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
|
7752 * SATA_FAILURE otherwise |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7753 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7754 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7755 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
|
7756 sata_drive_info_t *sdinfo) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7757 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7758 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7759 sata_save_drive_settings(sdinfo); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7760 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7761 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7762 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7763 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
|
7764 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7765 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7766 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7767 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7768 * Initialize write cache mode. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7769 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7770 * 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
|
7771 * static variable: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7772 * 1 - enable |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7773 * 0 - disable |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7774 * any other value - current drive setting |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7775 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7776 * 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
|
7777 * 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
|
7778 * 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
|
7779 * SATA_FAILURE otherwise. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7780 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7781 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7782 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
|
7783 sata_drive_info_t *sdinfo) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7784 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7785 if (sata_write_cache == 1) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7786 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7787 else if (sata_write_cache == 0) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7788 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7789 /* |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7790 * 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
|
7791 * 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
|
7792 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7793 * Now set the write cache mode |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7794 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
7795 return (sata_set_drive_features(sata_hba_inst, sdinfo, 0)); |
| 1258 | 7796 } |
| 7797 | |
| 7798 | |
| 7799 /* | |
| 7800 * Validate sata address. | |
| 7801 * Specified cport, pmport and qualifier has to match | |
| 7802 * passed sata_scsi configuration info. | |
| 7803 * The presence of an attached device is not verified. | |
| 7804 * | |
| 7805 * Returns 0 when address is valid, -1 otherwise. | |
| 7806 */ | |
| 7807 static int | |
| 7808 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, | |
| 7809 int pmport, int qual) | |
| 7810 { | |
| 7811 if (qual == SATA_ADDR_DCPORT && pmport != 0) | |
| 7812 goto invalid_address; | |
| 7813 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 7814 goto invalid_address; | |
| 7815 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && | |
| 7816 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || | |
| 7817 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || | |
| 7818 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) | |
| 7819 goto invalid_address; | |
| 7820 | |
| 7821 return (0); | |
| 7822 | |
| 7823 invalid_address: | |
| 7824 return (-1); | |
| 7825 | |
| 7826 } | |
| 7827 | |
| 7828 /* | |
| 7829 * Validate scsi address | |
| 7830 * SCSI target address is translated into SATA cport/pmport and compared | |
| 7831 * with a controller port/device configuration. LUN has to be 0. | |
| 7832 * Returns 0 if a scsi target refers to an attached device, | |
| 7833 * returns 1 if address is valid but device is not attached, | |
| 7834 * returns -1 if bad address or device is of an unsupported type. | |
| 7835 * Upon return sata_device argument is set. | |
| 7836 */ | |
| 7837 static int | |
| 7838 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, | |
| 7839 struct scsi_address *ap, sata_device_t *sata_device) | |
| 7840 { | |
| 7841 int cport, pmport, qual, rval; | |
| 7842 | |
| 7843 rval = -1; /* Invalid address */ | |
| 7844 if (ap->a_lun != 0) | |
| 7845 goto out; | |
| 7846 | |
| 7847 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); | |
| 7848 cport = SCSI_TO_SATA_CPORT(ap->a_target); | |
| 7849 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); | |
| 7850 | |
| 7851 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) | |
| 7852 goto out; | |
| 7853 | |
| 7854 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == | |
| 7855 0) { | |
| 7856 | |
| 7857 sata_cport_info_t *cportinfo; | |
| 7858 sata_pmult_info_t *pmultinfo; | |
| 7859 sata_drive_info_t *sdinfo = NULL; | |
| 7860 | |
| 7861 rval = 1; /* Valid sata address */ | |
| 7862 | |
| 7863 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); | |
| 7864 if (qual == SATA_ADDR_DCPORT) { | |
| 7865 if (cportinfo == NULL || | |
| 7866 cportinfo->cport_dev_type == SATA_DTYPE_NONE) | |
| 7867 goto out; | |
| 7868 | |
| 7869 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT || | |
| 7870 (cportinfo->cport_dev_type & | |
| 7871 SATA_VALID_DEV_TYPE) == 0) { | |
| 7872 rval = -1; | |
| 7873 goto out; | |
| 7874 } | |
| 7875 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 7876 | |
| 7877 } else if (qual == SATA_ADDR_DPMPORT) { | |
| 7878 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); | |
| 7879 if (pmultinfo == NULL) { | |
| 7880 rval = -1; | |
| 7881 goto out; | |
| 7882 } | |
| 7883 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == | |
| 7884 NULL || | |
| 7885 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, | |
| 7886 pmport) == SATA_DTYPE_NONE) | |
| 7887 goto out; | |
| 7888 | |
| 7889 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, | |
| 7890 pmport); | |
| 7891 } else { | |
| 7892 rval = -1; | |
| 7893 goto out; | |
| 7894 } | |
| 7895 if ((sdinfo == NULL) || | |
| 7896 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) | |
| 7897 goto out; | |
| 7898 | |
| 7899 sata_device->satadev_type = sdinfo->satadrv_type; | |
| 7900 sata_device->satadev_addr.qual = qual; | |
| 7901 sata_device->satadev_addr.cport = cport; | |
| 7902 sata_device->satadev_addr.pmport = pmport; | |
| 7903 sata_device->satadev_rev = SATA_DEVICE_REV_1; | |
| 7904 return (0); | |
| 7905 } | |
| 7906 out: | |
| 7907 if (rval == 1) { | |
| 7908 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, | |
| 7909 "sata_validate_scsi_address: no valid target %x lun %x", | |
| 7910 ap->a_target, ap->a_lun); | |
| 7911 } | |
| 7912 return (rval); | |
| 7913 } | |
| 7914 | |
| 7915 /* | |
| 7916 * Find dip corresponding to passed device number | |
| 7917 * | |
| 7918 * Returns NULL if invalid device number is passed or device cannot be found, | |
| 7919 * Returns dip is device is found. | |
| 7920 */ | |
| 7921 static dev_info_t * | |
| 7922 sata_devt_to_devinfo(dev_t dev) | |
| 7923 { | |
| 7924 dev_info_t *dip; | |
| 7925 #ifndef __lock_lint | |
| 7926 struct devnames *dnp; | |
| 7927 major_t major = getmajor(dev); | |
| 7928 int instance = SATA_MINOR2INSTANCE(getminor(dev)); | |
| 7929 | |
| 7930 if (major >= devcnt) | |
| 7931 return (NULL); | |
| 7932 | |
| 7933 dnp = &devnamesp[major]; | |
| 7934 LOCK_DEV_OPS(&(dnp->dn_lock)); | |
| 7935 dip = dnp->dn_head; | |
| 7936 while (dip && (ddi_get_instance(dip) != instance)) { | |
| 7937 dip = ddi_get_next(dip); | |
| 7938 } | |
| 7939 UNLOCK_DEV_OPS(&(dnp->dn_lock)); | |
| 7940 #endif | |
| 7941 | |
| 7942 return (dip); | |
| 7943 } | |
| 7944 | |
| 7945 | |
| 7946 /* | |
| 7947 * Probe device. | |
| 7948 * This function issues Identify Device command and initialize local | |
| 7949 * sata_drive_info structure if the device can be identified. | |
| 7950 * The device type is determined by examining Identify Device | |
| 7951 * command response. | |
| 7952 * If the sata_hba_inst has linked drive info structure for this | |
| 7953 * device address, the Identify Device data is stored into sata_drive_info | |
| 7954 * structure linked to the port info structure. | |
| 7955 * | |
| 7956 * sata_device has to refer to the valid sata port(s) for HBA described | |
| 7957 * by sata_hba_inst structure. | |
| 7958 * | |
| 7959 * Returns: SATA_SUCCESS if device type was successfully probed and port-linked | |
| 7960 * drive info structure was updated; | |
| 7961 * SATA_FAILURE if there is no device, or device was not probed | |
| 7962 * successully. | |
| 7963 * If a device cannot be identified, sata_device's dev_state and dev_type | |
| 7964 * fields are set to unknown. | |
| 7965 * | |
| 7966 */ | |
| 7967 | |
| 7968 static int | |
| 7969 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) | |
| 7970 { | |
| 7971 sata_drive_info_t *sdinfo; | |
| 7972 sata_drive_info_t new_sdinfo; /* local drive info struct */ | |
| 7973 int retry_cnt; | |
| 7974 | |
| 7975 ASSERT((SATA_CPORT_STATE(sata_hba_inst, | |
| 7976 sata_device->satadev_addr.cport) & | |
| 7977 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); | |
| 7978 | |
| 7979 sata_device->satadev_type = SATA_DTYPE_NONE; | |
| 7980 | |
| 7981 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 7982 sata_device->satadev_addr.cport))); | |
| 7983 | |
| 7984 /* Get pointer to port-linked sata device info structure */ | |
| 7985 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 7986 if (sdinfo != NULL) { | |
| 7987 sdinfo->satadrv_state &= | |
| 7988 ~(SATA_STATE_PROBED | SATA_STATE_READY); | |
| 7989 sdinfo->satadrv_state |= SATA_STATE_PROBING; | |
| 7990 } else { | |
| 7991 /* No device to probe */ | |
| 7992 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 7993 sata_device->satadev_addr.cport))); | |
| 7994 sata_device->satadev_type = SATA_DTYPE_NONE; | |
| 7995 sata_device->satadev_state = SATA_STATE_UNKNOWN; | |
| 7996 return (SATA_FAILURE); | |
| 7997 } | |
| 7998 /* | |
| 7999 * Need to issue both types of identify device command and | |
| 8000 * determine device type by examining retreived data/status. | |
| 8001 * First, ATA Identify Device. | |
| 8002 */ | |
| 8003 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); | |
| 8004 new_sdinfo.satadrv_addr = sata_device->satadev_addr; | |
| 8005 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8006 sata_device->satadev_addr.cport))); | |
| 8007 for (retry_cnt = 0; retry_cnt <= SATA_DEVICE_IDENTIFY_RETRY; | |
| 8008 retry_cnt++) { | |
| 8009 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; | |
| 8010 if (sata_identify_device(sata_hba_inst, &new_sdinfo) == 0) { | |
| 8011 /* Got something responding to ATA Identify Device */ | |
| 8012 sata_device->satadev_type = new_sdinfo.satadrv_type; | |
| 8013 break; | |
| 8014 } | |
| 8015 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { | |
| 8016 /* | |
| 8017 * HBA supports ATAPI - try to issue Identify Packet | |
| 8018 * Device command. | |
| 8019 */ | |
| 8020 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD; | |
| 8021 if (sata_identify_device(sata_hba_inst, | |
| 8022 &new_sdinfo) == 0) { | |
| 8023 /* | |
| 8024 * Got something responding to Identify Packet | |
| 8025 * Device cmd. | |
| 8026 */ | |
| 8027 /* Set UDMA mode here as well ? - phase 2 */ | |
| 8028 sata_device->satadev_type = | |
| 8029 new_sdinfo.satadrv_type; | |
| 8030 break; | |
| 8031 } | |
| 8032 } | |
| 8033 } | |
| 8034 if (retry_cnt <= SATA_DEVICE_IDENTIFY_RETRY) { | |
| 8035 /* save device info, if possible */ | |
| 8036 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8037 sata_device->satadev_addr.cport))); | |
| 8038 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 8039 if (sdinfo == NULL) { | |
| 8040 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8041 sata_device->satadev_addr.cport))); | |
| 8042 return (SATA_FAILURE); | |
| 8043 } | |
| 8044 /* | |
| 8045 * Copy drive info into the port-linked drive info structure. | |
| 8046 */ | |
| 8047 *sdinfo = new_sdinfo; | |
| 8048 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; | |
| 8049 sdinfo->satadrv_state |= SATA_STATE_PROBED; | |
| 8050 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) | |
| 8051 SATA_CPORT_DEV_TYPE(sata_hba_inst, | |
| 8052 sata_device->satadev_addr.cport) = | |
| 8053 sdinfo->satadrv_type; | |
| 8054 else /* SATA_ADDR_DPMPORT */ | |
| 8055 SATA_PMPORT_DEV_TYPE(sata_hba_inst, | |
| 8056 sata_device->satadev_addr.cport, | |
| 8057 sata_device->satadev_addr.pmport) = | |
| 8058 sdinfo->satadrv_type; | |
| 8059 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8060 sata_device->satadev_addr.cport))); | |
| 8061 return (SATA_SUCCESS); | |
| 8062 } | |
| 8063 | |
| 8064 failure: | |
| 8065 /* | |
| 8066 * Looks like we cannot determine the device type. | |
| 8067 */ | |
| 8068 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8069 sata_device->satadev_addr.cport))); | |
| 8070 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 8071 if (sdinfo != NULL) { | |
| 8072 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; | |
| 8073 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8074 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; | |
| 8075 sdinfo->satadrv_state = SATA_STATE_PROBED; | |
| 8076 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) | |
| 8077 SATA_CPORT_DEV_TYPE(sata_hba_inst, | |
| 8078 sata_device->satadev_addr.cport) = | |
| 8079 SATA_DTYPE_UNKNOWN; | |
| 8080 else { | |
| 8081 /* SATA_ADDR_DPMPORT */ | |
| 8082 if ((SATA_PMULT_INFO(sata_hba_inst, | |
| 8083 sata_device->satadev_addr.cport) != NULL) && | |
| 8084 (SATA_PMPORT_INFO(sata_hba_inst, | |
| 8085 sata_device->satadev_addr.cport, | |
| 8086 sata_device->satadev_addr.pmport) != NULL)) | |
| 8087 SATA_PMPORT_DEV_TYPE(sata_hba_inst, | |
| 8088 sata_device->satadev_addr.cport, | |
| 8089 sata_device->satadev_addr.pmport) = | |
| 8090 SATA_DTYPE_UNKNOWN; | |
| 8091 } | |
| 8092 } | |
| 8093 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, | |
| 8094 sata_device->satadev_addr.cport))); | |
| 8095 return (SATA_FAILURE); | |
| 8096 } | |
| 8097 | |
| 8098 | |
| 8099 /* | |
| 8100 * Get pointer to sata_drive_info structure. | |
| 8101 * | |
| 8102 * The sata_device has to contain address (cport, pmport and qualifier) for | |
| 8103 * specified sata_scsi structure. | |
| 8104 * | |
| 8105 * Returns NULL if device address is not valid for this HBA configuration. | |
| 8106 * Otherwise, returns a pointer to sata_drive_info structure. | |
| 8107 * | |
| 8108 * This function should be called with a port mutex held. | |
| 8109 */ | |
| 8110 static sata_drive_info_t * | |
| 8111 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, | |
| 8112 sata_device_t *sata_device) | |
| 8113 { | |
| 8114 uint8_t cport = sata_device->satadev_addr.cport; | |
| 8115 uint8_t pmport = sata_device->satadev_addr.pmport; | |
| 8116 uint8_t qual = sata_device->satadev_addr.qual; | |
| 8117 | |
| 8118 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 8119 return (NULL); | |
| 8120 | |
| 8121 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & | |
| 8122 (SATA_STATE_PROBED | SATA_STATE_READY))) | |
| 8123 /* Port not probed yet */ | |
| 8124 return (NULL); | |
| 8125 | |
| 8126 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) | |
| 8127 return (NULL); | |
| 8128 | |
| 8129 if (qual == SATA_ADDR_DCPORT) { | |
| 8130 /* Request for a device on a controller port */ | |
| 8131 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == | |
| 8132 SATA_DTYPE_PMULT) | |
| 8133 /* Port multiplier attached */ | |
| 8134 return (NULL); | |
| 8135 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); | |
| 8136 } | |
| 8137 if (qual == SATA_ADDR_DPMPORT) { | |
| 8138 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != | |
| 8139 SATA_DTYPE_PMULT) | |
| 8140 return (NULL); | |
| 8141 | |
| 8142 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) | |
| 8143 return (NULL); | |
| 8144 | |
| 8145 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); | |
| 8146 } | |
| 8147 | |
| 8148 /* we should not get here */ | |
| 8149 return (NULL); | |
| 8150 } | |
| 8151 | |
| 8152 | |
| 8153 /* | |
| 8154 * sata_identify_device. | |
| 8155 * Send Identify Device command to SATA HBA driver. | |
| 8156 * If command executes successfully, update sata_drive_info structure pointed | |
| 8157 * to by sdinfo argument, including Identify Device data. | |
| 8158 * If command fails, invalidate data in sata_drive_info. | |
| 8159 * | |
| 8160 * Cannot be called from interrupt level. | |
| 8161 * | |
| 8162 * Returns 0 if device was identified as supported device, -1 otherwise. | |
| 8163 */ | |
| 8164 static int | |
| 8165 sata_identify_device(sata_hba_inst_t *sata_hba_inst, | |
| 8166 sata_drive_info_t *sdinfo) | |
| 8167 { | |
| 8168 uint16_t cfg_word; | |
| 8169 int i; | |
| 8170 | |
| 8171 /* fetch device identify data */ | |
| 8172 if (sata_fetch_device_identify_data(sata_hba_inst, sdinfo) != 0) | |
| 8173 goto fail_unknown; | |
| 8174 | |
| 8175 cfg_word = sdinfo->satadrv_id.ai_config; | |
| 8176 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK && | |
| 8177 (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) { | |
| 8178 /* Change device type to reflect Identify Device data */ | |
| 8179 if (((cfg_word & SATA_ATAPI_TYPE_MASK) == | |
| 8180 SATA_ATAPI_TYPE) && | |
| 8181 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) == | |
| 8182 SATA_ATAPI_CDROM_DEV)) { | |
| 8183 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; | |
| 8184 } else { | |
| 8185 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8186 } | |
| 8187 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD && | |
| 8188 (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) || | |
| 8189 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) { | |
| 8190 /* Change device type to reflect Identify Device data ! */ | |
| 8191 if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) == | |
| 8192 SATA_ATA_TYPE) { | |
| 8193 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; | |
| 8194 } else { | |
| 8195 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8196 } | |
| 8197 } | |
| 8198 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { | |
| 8199 if (sdinfo->satadrv_capacity == 0) { | |
| 8200 /* Non-LBA disk. Too bad... */ | |
| 8201 sata_log(sata_hba_inst, CE_WARN, | |
| 8202 "SATA disk device at port %d does not support LBA", | |
| 8203 sdinfo->satadrv_addr.cport); | |
| 8204 goto fail_unknown; | |
| 8205 } | |
| 8206 } | |
| 8207 /* Check for Ultra DMA modes 6 through 0 being supported */ | |
| 8208 for (i = 6; i >= 0; --i) { | |
| 8209 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) | |
| 8210 break; | |
| 8211 } | |
| 8212 /* | |
| 8213 * At least UDMA 4 mode has to be supported. If mode 4 or | |
| 8214 * higher are not supported by the device, fail this | |
| 8215 * device. | |
| 8216 */ | |
| 8217 if (i < 4) { | |
| 8218 /* No required Ultra DMA mode supported */ | |
| 8219 sata_log(sata_hba_inst, CE_WARN, | |
| 8220 "SATA disk device at port %d does not support UDMA " | |
| 8221 "mode 4 or higher", sdinfo->satadrv_addr.cport); | |
| 8222 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 8223 "mode 4 or higher required, %d supported", i)); | |
| 8224 goto fail_unknown; | |
| 8225 } | |
| 8226 | |
| 8227 return (0); | |
| 8228 | |
| 8229 fail_unknown: | |
| 8230 /* Invalidate sata_drive_info ? */ | |
| 8231 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; | |
| 8232 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; | |
| 8233 return (-1); | |
| 8234 } | |
| 8235 | |
| 8236 /* | |
| 8237 * Log/display device information | |
| 8238 */ | |
| 8239 static void | |
| 8240 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, | |
| 8241 sata_drive_info_t *sdinfo) | |
| 8242 { | |
| 8243 int valid_version; | |
| 8244 char msg_buf[MAXPATHLEN]; | |
| 8245 | |
| 8246 /* Show HBA path */ | |
| 8247 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); | |
| 8248 | |
| 8249 cmn_err(CE_CONT, "?%s :\n", msg_buf); | |
| 8250 | |
| 8251 if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) { | |
| 8252 (void) sprintf(msg_buf, | |
| 8253 "Unsupported SATA device type (cfg 0x%x) at ", | |
| 8254 sdinfo->satadrv_id.ai_config); | |
| 8255 } else { | |
| 8256 (void) sprintf(msg_buf, "SATA %s device at", | |
| 8257 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? | |
| 8258 "disk":"CD/DVD (ATAPI)"); | |
| 8259 } | |
| 8260 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) | |
| 8261 cmn_err(CE_CONT, "?\t%s port %d\n", | |
| 8262 msg_buf, sdinfo->satadrv_addr.cport); | |
| 8263 else | |
| 8264 cmn_err(CE_CONT, "?\t%s port %d pmport %d\n", | |
| 8265 msg_buf, sdinfo->satadrv_addr.cport, | |
| 8266 sdinfo->satadrv_addr.pmport); | |
| 8267 | |
| 8268 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, | |
| 8269 sizeof (sdinfo->satadrv_id.ai_model)); | |
| 8270 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); | |
| 8271 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; | |
| 8272 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); | |
| 8273 | |
| 8274 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, | |
| 8275 sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 8276 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); | |
| 8277 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; | |
| 8278 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); | |
| 8279 | |
| 8280 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, | |
| 8281 sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 8282 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); | |
| 8283 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
|
8284 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); |
| 1258 | 8285 |
| 8286 #ifdef SATA_DEBUG | |
| 8287 if (sdinfo->satadrv_id.ai_majorversion != 0 && | |
| 8288 sdinfo->satadrv_id.ai_majorversion != 0xffff) { | |
| 8289 int i; | |
| 8290 for (i = 14; i >= 2; i--) { | |
| 8291 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { | |
| 8292 valid_version = i; | |
| 8293 break; | |
| 8294 } | |
| 8295 } | |
| 8296 cmn_err(CE_CONT, | |
| 8297 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", | |
| 8298 valid_version, | |
| 8299 sdinfo->satadrv_id.ai_majorversion, | |
| 8300 sdinfo->satadrv_id.ai_minorversion); | |
| 8301 } | |
| 8302 #endif | |
| 8303 /* Log some info */ | |
| 8304 cmn_err(CE_CONT, "?\tsupported features:\n"); | |
| 8305 msg_buf[0] = '\0'; | |
| 8306 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) | |
| 8307 (void) strlcat(msg_buf, "48-bit LBA", MAXPATHLEN); | |
| 8308 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) | |
| 8309 (void) strlcat(msg_buf, "28-bit LBA", MAXPATHLEN); | |
| 8310 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) | |
| 8311 (void) strlcat(msg_buf, ", DMA", MAXPATHLEN); | |
| 8312 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) | |
| 8313 (void) strlcat(msg_buf, ", Native Command Queueing", | |
| 8314 MAXPATHLEN); | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
8315 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) |
| 1258 | 8316 (void) strlcat(msg_buf, ", Queuing", MAXPATHLEN); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
8317 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
|
8318 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
8319 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
8320 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
|
8321 (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
|
8322 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); |
| 1258 | 8323 cmn_err(CE_CONT, "?\t %s\n", msg_buf); |
| 8324 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) | |
| 8325 cmn_err(CE_CONT, "?\tSATA1 & SATA2 compatible\n"); | |
| 8326 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) | |
| 8327 cmn_err(CE_CONT, "?\tSATA1 compatible\n"); | |
| 8328 | |
| 8329 #ifdef __i386 | |
| 8330 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", | |
| 8331 sdinfo->satadrv_capacity); | |
| 8332 #else | |
| 8333 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", | |
| 8334 sdinfo->satadrv_capacity); | |
| 8335 #endif | |
| 8336 cmn_err(CE_CONT, "?%s", msg_buf); | |
| 8337 } | |
| 8338 | |
| 8339 | |
| 8340 /* | |
| 8341 * sata_save_drive_settings extracts current setting of the device and stores | |
| 8342 * it for future reference, in case the device setup would need to be restored | |
| 8343 * after the device reset. | |
| 8344 * | |
| 8345 * At the moment only read ahead and write cache settings are saved, if the | |
| 8346 * device supports these features at all. | |
| 8347 */ | |
| 8348 static void | |
| 8349 sata_save_drive_settings(sata_drive_info_t *sdinfo) | |
| 8350 { | |
| 8351 if (!(sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 8352 !(sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 8353 /* None of the features is supported - do nothing */ | |
| 8354 return; | |
| 8355 } | |
| 8356 | |
| 8357 /* Current setting of Read Ahead (and Read Cache) */ | |
| 8358 if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD) | |
| 8359 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; | |
| 8360 else | |
| 8361 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; | |
| 8362 | |
| 8363 /* Current setting of Write Cache */ | |
| 8364 if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE) | |
| 8365 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; | |
| 8366 else | |
| 8367 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; | |
| 8368 } | |
| 8369 | |
| 8370 | |
| 8371 /* | |
| 8372 * sata_check_capacity function determines a disk capacity | |
| 8373 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. | |
| 8374 * | |
| 8375 * NOTE: CHS mode is not supported! If a device does not support LBA, | |
| 8376 * this function is not called. | |
| 8377 * | |
| 8378 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 | |
| 8379 */ | |
| 8380 static uint64_t | |
| 8381 sata_check_capacity(sata_drive_info_t *sdinfo) | |
| 8382 { | |
| 8383 uint64_t capacity = 0; | |
| 8384 int i; | |
| 8385 | |
| 8386 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || | |
| 8387 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) | |
| 8388 /* Capacity valid only for LBA-addressable disk devices */ | |
| 8389 return (0); | |
| 8390 | |
| 8391 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && | |
| 8392 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && | |
| 8393 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { | |
| 8394 /* LBA48 mode supported and enabled */ | |
| 8395 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | | |
| 8396 SATA_DEV_F_LBA28; | |
| 8397 for (i = 3; i >= 0; --i) { | |
| 8398 capacity <<= 16; | |
| 8399 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; | |
| 8400 } | |
| 8401 } else { | |
| 8402 capacity = sdinfo->satadrv_id.ai_addrsec[1]; | |
| 8403 capacity <<= 16; | |
| 8404 capacity += sdinfo->satadrv_id.ai_addrsec[0]; | |
| 8405 if (capacity >= 0x1000000) | |
| 8406 /* LBA28 mode */ | |
| 8407 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; | |
| 8408 } | |
| 8409 return (capacity); | |
| 8410 } | |
| 8411 | |
| 8412 | |
| 8413 /* | |
| 8414 * Allocate consistent buffer for DMA transfer | |
| 8415 * | |
| 8416 * Cannot be called from interrupt level or with mutex held - it may sleep. | |
| 8417 * | |
| 8418 * Returns pointer to allocated buffer structure, or NULL if allocation failed. | |
| 8419 */ | |
| 8420 static struct buf * | |
| 8421 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) | |
| 8422 { | |
| 8423 struct scsi_address ap; | |
| 8424 struct buf *bp; | |
| 8425 ddi_dma_attr_t cur_dma_attr; | |
| 8426 | |
| 8427 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 8428 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; | |
| 8429 ap.a_target = SATA_TO_SCSI_TARGET( | |
| 8430 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, | |
| 8431 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, | |
| 8432 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); | |
| 8433 ap.a_lun = 0; | |
| 8434 | |
| 8435 bp = scsi_alloc_consistent_buf(&ap, NULL, len, | |
| 8436 B_READ, SLEEP_FUNC, NULL); | |
| 8437 | |
| 8438 if (bp != NULL) { | |
| 8439 /* Allocate DMA resources for this buffer */ | |
| 8440 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; | |
| 8441 /* | |
| 8442 * We use a local version of the dma_attr, to account | |
| 8443 * for a device addressing limitations. | |
| 8444 * sata_adjust_dma_attr() will handle sdinfo == NULL which | |
| 8445 * will cause dma attributes to be adjusted to a lowest | |
| 8446 * acceptable level. | |
| 8447 */ | |
| 8448 sata_adjust_dma_attr(NULL, | |
| 8449 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); | |
| 8450 | |
| 8451 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, | |
| 8452 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { | |
| 8453 scsi_free_consistent_buf(bp); | |
| 8454 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 8455 bp = NULL; | |
| 8456 } | |
| 8457 } | |
| 8458 return (bp); | |
| 8459 } | |
| 8460 | |
| 8461 /* | |
| 8462 * Release local buffer (consistent buffer for DMA transfer) allocated | |
| 8463 * via sata_alloc_local_buffer(). | |
| 8464 */ | |
| 8465 static void | |
| 8466 sata_free_local_buffer(sata_pkt_txlate_t *spx) | |
| 8467 { | |
| 8468 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 8469 ASSERT(spx->txlt_dma_cookie_list != NULL); | |
| 8470 ASSERT(spx->txlt_dma_cookie_list_len != 0); | |
| 8471 ASSERT(spx->txlt_buf_dma_handle != NULL); | |
| 8472 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); | |
| 8473 | |
| 8474 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; | |
| 8475 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; | |
| 8476 | |
| 8477 /* Free DMA resources */ | |
| 8478 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); | |
| 8479 ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 8480 spx->txlt_buf_dma_handle = 0; | |
| 8481 | |
| 8482 kmem_free(spx->txlt_dma_cookie_list, | |
| 8483 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); | |
| 8484 spx->txlt_dma_cookie_list = NULL; | |
| 8485 spx->txlt_dma_cookie_list_len = 0; | |
| 8486 | |
| 8487 /* Free buffer */ | |
| 8488 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); | |
| 8489 } | |
| 8490 | |
| 8491 | |
| 8492 | |
| 8493 | |
| 8494 /* | |
| 8495 * Allocate sata_pkt | |
| 8496 * Pkt structure version and embedded strcutures version are initialized. | |
| 8497 * sata_pkt and sata_pkt_txlate structures are cross-linked. | |
| 8498 * | |
| 8499 * Since this may be called in interrupt context by sata_scsi_init_pkt, | |
| 8500 * callback argument determines if it can sleep or not. | |
| 8501 * Hence, it should not be called from interrupt context. | |
| 8502 * | |
| 8503 * If successful, non-NULL pointer to a sata pkt is returned. | |
| 8504 * Upon failure, NULL pointer is returned. | |
| 8505 */ | |
| 8506 static sata_pkt_t * | |
| 8507 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) | |
| 8508 { | |
| 8509 sata_pkt_t *spkt; | |
| 8510 int kmsflag; | |
| 8511 | |
| 8512 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; | |
| 8513 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); | |
| 8514 if (spkt == NULL) { | |
| 8515 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8516 "sata_pkt_alloc: failed")); | |
| 8517 return (NULL); | |
| 8518 } | |
| 8519 spkt->satapkt_rev = SATA_PKT_REV; | |
| 8520 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; | |
| 8521 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; | |
| 8522 spkt->satapkt_framework_private = spx; | |
| 8523 spx->txlt_sata_pkt = spkt; | |
| 8524 return (spkt); | |
| 8525 } | |
| 8526 | |
| 8527 /* | |
| 8528 * Free sata pkt allocated via sata_pkt_alloc() | |
| 8529 */ | |
| 8530 static void | |
| 8531 sata_pkt_free(sata_pkt_txlate_t *spx) | |
| 8532 { | |
| 8533 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 8534 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); | |
| 8535 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); | |
| 8536 spx->txlt_sata_pkt = NULL; | |
| 8537 } | |
| 8538 | |
| 8539 | |
| 8540 /* | |
| 8541 * Adjust DMA attributes. | |
| 8542 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary | |
| 8543 * from 8 bits to 16 bits, depending on a command being used. | |
| 8544 * Limiting max block count arbitrarily to 256 for all read/write | |
| 8545 * commands may affects performance, so check both the device and | |
| 8546 * controller capability before adjusting dma attributes. | |
| 8547 * For ATAPI CD/DVD dma granularity has to be adjusted as well, | |
| 8548 * because these devices support block size of 2k rather | |
| 8549 * then 512 bytes. | |
| 8550 */ | |
| 8551 void | |
| 8552 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, | |
| 8553 ddi_dma_attr_t *adj_dma_attr) | |
| 8554 { | |
| 8555 uint32_t count_max; | |
| 8556 | |
| 8557 /* Copy original attributes */ | |
| 8558 *adj_dma_attr = *dma_attr; | |
| 8559 | |
| 8560 /* | |
| 8561 * Things to consider: device addressing capability, | |
| 8562 * "excessive" controller DMA capabilities. | |
| 8563 * If a device is being probed/initialized, there are | |
| 8564 * no device info - use default limits then. | |
| 8565 */ | |
| 8566 if (sdinfo == NULL) { | |
| 8567 count_max = dma_attr->dma_attr_granular * 0x100; | |
| 8568 if (dma_attr->dma_attr_count_max > count_max) | |
| 8569 adj_dma_attr->dma_attr_count_max = count_max; | |
| 8570 if (dma_attr->dma_attr_maxxfer > count_max) | |
| 8571 adj_dma_attr->dma_attr_maxxfer = count_max; | |
| 8572 return; | |
| 8573 } | |
| 8574 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 8575 /* arbitrarily modify controller dma granularity */ | |
| 8576 adj_dma_attr->dma_attr_granular = SATA_ATAPI_SECTOR_SIZE; | |
| 8577 } | |
| 8578 | |
| 8579 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { | |
| 8580 /* | |
| 8581 * 16-bit sector count may be used - we rely on | |
| 8582 * the assumption that only read and write cmds | |
| 8583 * will request more than 256 sectors worth of data | |
| 8584 */ | |
| 8585 count_max = adj_dma_attr->dma_attr_granular * 0x10000; | |
| 8586 } else { | |
| 8587 /* | |
| 8588 * 8-bit sector count will be used - default limits | |
| 8589 * for dma attributes | |
| 8590 */ | |
| 8591 count_max = adj_dma_attr->dma_attr_granular * 0x100; | |
| 8592 } | |
| 8593 | |
| 8594 | |
| 8595 /* | |
| 8596 * Adjust controler dma attributes, if necessary | |
| 8597 */ | |
| 8598 if (dma_attr->dma_attr_count_max > count_max) | |
| 8599 adj_dma_attr->dma_attr_count_max = count_max; | |
| 8600 if (dma_attr->dma_attr_maxxfer > count_max) | |
| 8601 adj_dma_attr->dma_attr_maxxfer = count_max; | |
| 8602 } | |
| 8603 | |
| 8604 | |
| 8605 /* | |
| 8606 * Allocate DMA resources for the buffer | |
| 8607 * This function handles initial DMA resource allocation as well as | |
| 8608 * DMA window shift and may be called repeatedly for the same DMA window | |
| 8609 * until all DMA cookies in the DMA window are processed. | |
| 8610 * | |
| 8611 * Returns DDI_SUCCESS upon successful operation, | |
| 8612 * returns failure code returned by failing commands or DDI_FAILURE when | |
| 8613 * internal cleanup failed. | |
| 8614 */ | |
| 8615 static int | |
| 8616 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, | |
| 8617 int (*callback)(caddr_t), caddr_t arg, | |
| 8618 ddi_dma_attr_t *cur_dma_attr) | |
| 8619 { | |
| 8620 int rval; | |
| 8621 ddi_dma_cookie_t cookie; | |
| 8622 off_t offset; | |
| 8623 size_t size; | |
| 8624 int max_sg_len, req_sg_len, i; | |
| 8625 uint_t dma_flags; | |
| 8626 struct buf *bp; | |
| 8627 uint64_t max_txfer_len; | |
| 8628 uint64_t cur_txfer_len; | |
| 8629 | |
| 8630 ASSERT(spx->txlt_sata_pkt != NULL); | |
| 8631 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; | |
| 8632 ASSERT(bp != NULL); | |
| 8633 | |
| 8634 | |
| 8635 if (spx->txlt_buf_dma_handle == NULL) { | |
| 8636 /* | |
| 8637 * No DMA resources allocated so far - this is a first call | |
| 8638 * for this sata pkt. | |
| 8639 */ | |
| 8640 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), | |
| 8641 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); | |
| 8642 | |
| 8643 if (rval != DDI_SUCCESS) { | |
| 8644 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8645 "sata_dma_buf_setup: no buf DMA resources %x", | |
| 8646 rval)); | |
| 8647 return (rval); | |
| 8648 } | |
| 8649 | |
| 8650 if (bp->b_flags & B_READ) | |
| 8651 dma_flags = DDI_DMA_READ; | |
| 8652 else | |
| 8653 dma_flags = DDI_DMA_WRITE; | |
| 8654 | |
| 8655 if (flags & PKT_CONSISTENT) | |
| 8656 dma_flags |= DDI_DMA_CONSISTENT; | |
| 8657 | |
| 8658 if (flags & PKT_DMA_PARTIAL) | |
| 8659 dma_flags |= DDI_DMA_PARTIAL; | |
| 8660 | |
| 8661 rval = ddi_dma_buf_bind_handle(spx->txlt_buf_dma_handle, | |
| 8662 bp, dma_flags, callback, arg, | |
| 8663 &cookie, &spx->txlt_curwin_num_dma_cookies); | |
| 8664 | |
| 8665 switch (rval) { | |
| 8666 case DDI_DMA_PARTIAL_MAP: | |
| 8667 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 8668 "sata_dma_buf_setup: DMA Partial Map\n", NULL); | |
| 8669 /* | |
| 8670 * Partial DMA mapping. | |
| 8671 * Retrieve number of DMA windows for this request. | |
| 8672 */ | |
| 8673 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, | |
| 8674 &spx->txlt_num_dma_win) != DDI_SUCCESS) { | |
| 8675 (void) ddi_dma_unbind_handle( | |
| 8676 spx->txlt_buf_dma_handle); | |
| 8677 (void) ddi_dma_free_handle( | |
| 8678 &spx->txlt_buf_dma_handle); | |
| 8679 spx->txlt_buf_dma_handle = NULL; | |
| 8680 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8681 "sata_dma_buf_setup: numwin failed\n")); | |
| 8682 return (DDI_FAILURE); | |
| 8683 } | |
| 8684 spx->txlt_cur_dma_win = 0; | |
| 8685 break; | |
| 8686 | |
| 8687 case DDI_DMA_MAPPED: | |
| 8688 /* DMA fully mapped */ | |
| 8689 spx->txlt_num_dma_win = 1; | |
| 8690 spx->txlt_cur_dma_win = 0; | |
| 8691 break; | |
| 8692 | |
| 8693 default: | |
| 8694 /* DMA mapping failed */ | |
| 8695 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); | |
| 8696 spx->txlt_buf_dma_handle = NULL; | |
| 8697 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8698 "sata_dma_buf_setup: buf dma handle binding " | |
| 8699 "failed %x\n", rval)); | |
| 8700 return (rval); | |
| 8701 } | |
| 8702 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 8703 spx->txlt_dma_cookie_list = NULL; | |
| 8704 } else { | |
| 8705 /* | |
| 8706 * DMA setup is reused. Check if we need to process more | |
| 8707 * cookies in current window, or to get next window, if any. | |
| 8708 */ | |
| 8709 | |
| 8710 ASSERT(spx->txlt_curwin_processed_dma_cookies <= | |
| 8711 spx->txlt_curwin_num_dma_cookies); | |
| 8712 | |
| 8713 if (spx->txlt_curwin_processed_dma_cookies == | |
| 8714 spx->txlt_curwin_num_dma_cookies) { | |
| 8715 /* | |
| 8716 * All cookies from current DMA window were processed. | |
| 8717 * Get next DMA window. | |
| 8718 */ | |
| 8719 spx->txlt_cur_dma_win++; | |
| 8720 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { | |
| 8721 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, | |
| 8722 spx->txlt_cur_dma_win, &offset, &size, | |
| 8723 &cookie, | |
| 8724 &spx->txlt_curwin_num_dma_cookies); | |
| 8725 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 8726 | |
| 8727 } else { | |
| 8728 /* No more windows! End of request! */ | |
| 8729 /* What to do? - panic for now */ | |
| 8730 ASSERT(spx->txlt_cur_dma_win >= | |
| 8731 spx->txlt_num_dma_win); | |
| 8732 | |
| 8733 spx->txlt_curwin_num_dma_cookies = 0; | |
| 8734 spx->txlt_curwin_processed_dma_cookies = 0; | |
| 8735 spx->txlt_sata_pkt-> | |
| 8736 satapkt_cmd.satacmd_num_dma_cookies = 0; | |
| 8737 return (DDI_SUCCESS); | |
| 8738 } | |
| 8739 } | |
| 8740 } | |
| 8741 /* There better be at least one DMA cookie */ | |
| 8742 ASSERT((spx->txlt_curwin_num_dma_cookies - | |
| 8743 spx->txlt_curwin_processed_dma_cookies) > 0); | |
| 8744 | |
| 8745 if (spx->txlt_curwin_processed_dma_cookies == 0) { | |
| 8746 /* | |
| 8747 * Processing a new DMA window - set-up dma cookies list. | |
| 8748 * We may reuse previously allocated cookie array if it is | |
| 8749 * possible. | |
| 8750 */ | |
| 8751 if (spx->txlt_dma_cookie_list != NULL && | |
| 8752 spx->txlt_dma_cookie_list_len < | |
| 8753 spx->txlt_curwin_num_dma_cookies) { | |
| 8754 /* | |
| 8755 * New DMA window contains more cookies than | |
| 8756 * the previous one. We need larger cookie list - free | |
| 8757 * the old one. | |
| 8758 */ | |
| 8759 (void) kmem_free(spx->txlt_dma_cookie_list, | |
| 8760 spx->txlt_dma_cookie_list_len * | |
| 8761 sizeof (ddi_dma_cookie_t)); | |
| 8762 spx->txlt_dma_cookie_list = NULL; | |
| 8763 spx->txlt_dma_cookie_list_len = 0; | |
| 8764 } | |
| 8765 if (spx->txlt_dma_cookie_list == NULL) { | |
| 8766 /* Allocate new dma cookie array */ | |
| 8767 spx->txlt_dma_cookie_list = kmem_zalloc( | |
| 8768 sizeof (ddi_dma_cookie_t) * | |
| 8769 spx->txlt_curwin_num_dma_cookies, KM_SLEEP); | |
| 8770 spx->txlt_dma_cookie_list_len = | |
| 8771 spx->txlt_curwin_num_dma_cookies; | |
| 8772 } | |
| 8773 /* | |
| 8774 * Copy all DMA cookies into local list, so we will know their | |
| 8775 * dma_size in advance of setting the sata_pkt. | |
| 8776 * One cookie was already fetched, so copy it. | |
| 8777 */ | |
| 8778 *(&spx->txlt_dma_cookie_list[0]) = cookie; | |
| 8779 for (i = 1; i < spx->txlt_curwin_num_dma_cookies; i++) { | |
| 8780 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, &cookie); | |
| 8781 *(&spx->txlt_dma_cookie_list[i]) = cookie; | |
| 8782 } | |
| 8783 } else { | |
| 8784 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 8785 "sata_dma_buf_setup: sliding within DMA window, " | |
| 8786 "cur cookie %d, total cookies %d\n", | |
| 8787 spx->txlt_curwin_processed_dma_cookies, | |
| 8788 spx->txlt_curwin_num_dma_cookies); | |
| 8789 } | |
| 8790 | |
| 8791 /* | |
| 8792 * Set-up sata_pkt cookie list. | |
| 8793 * No single cookie transfer size would exceed max transfer size of | |
| 8794 * an ATA command used for addressed device (tha adjustment of the dma | |
| 8795 * attributes took care of this). But there may be more | |
| 8796 * then one cookie, so the cmd cookie list has to be | |
| 8797 * constrained by both a maximum scatter gather list length and | |
| 8798 * a maximum transfer size restriction of an ATA command. | |
| 8799 */ | |
| 8800 | |
| 8801 max_sg_len = cur_dma_attr->dma_attr_sgllen; | |
| 8802 req_sg_len = MIN(max_sg_len, | |
| 8803 (spx->txlt_curwin_num_dma_cookies - | |
| 8804 spx->txlt_curwin_processed_dma_cookies)); | |
| 8805 | |
| 8806 ASSERT(req_sg_len > 0); | |
| 8807 | |
| 8808 max_txfer_len = MAX((cur_dma_attr->dma_attr_granular * 0x100), | |
| 8809 cur_dma_attr->dma_attr_maxxfer); | |
| 8810 | |
| 8811 /* One cookie should be always available */ | |
| 8812 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = | |
| 8813 &spx->txlt_dma_cookie_list[spx->txlt_curwin_processed_dma_cookies]; | |
| 8814 | |
| 8815 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; | |
| 8816 | |
| 8817 cur_txfer_len = | |
| 8818 (uint64_t)spx->txlt_dma_cookie_list[ | |
| 8819 spx->txlt_curwin_processed_dma_cookies].dmac_size; | |
| 8820 | |
| 8821 spx->txlt_curwin_processed_dma_cookies++; | |
| 8822 | |
| 8823 ASSERT(cur_txfer_len <= max_txfer_len); | |
| 8824 | |
| 8825 /* Add more cookies to the scatter-gather list */ | |
| 8826 for (i = 1; i < req_sg_len; i++) { | |
| 8827 if (cur_txfer_len < max_txfer_len) { | |
| 8828 /* | |
| 8829 * Check if the next cookie could be used by | |
| 8830 * this sata_pkt. | |
| 8831 */ | |
| 8832 if ((cur_txfer_len + | |
| 8833 spx->txlt_dma_cookie_list[ | |
| 8834 spx->txlt_curwin_processed_dma_cookies]. | |
| 8835 dmac_size) <= max_txfer_len) { | |
| 8836 /* Yes, transfer lenght is within bounds */ | |
| 8837 spx->txlt_sata_pkt-> | |
| 8838 satapkt_cmd.satacmd_num_dma_cookies++; | |
| 8839 cur_txfer_len += | |
| 8840 spx->txlt_dma_cookie_list[ | |
| 8841 spx->txlt_curwin_processed_dma_cookies]. | |
| 8842 dmac_size; | |
| 8843 spx->txlt_curwin_processed_dma_cookies++; | |
| 8844 } else { | |
| 8845 /* No, transfer would exceed max lenght. */ | |
| 8846 SATADBG3(SATA_DBG_DMA_SETUP, | |
| 8847 spx->txlt_sata_hba_inst, | |
| 8848 "ncookies %d, size 0x%lx, " | |
| 8849 "max_size 0x%lx\n", | |
| 8850 spx->txlt_sata_pkt-> | |
| 8851 satapkt_cmd.satacmd_num_dma_cookies, | |
| 8852 cur_txfer_len, max_txfer_len); | |
| 8853 break; | |
| 8854 } | |
| 8855 } else { | |
| 8856 /* Cmd max transfer length reached */ | |
| 8857 SATADBG3(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, | |
| 8858 "Max transfer length? " | |
| 8859 "ncookies %d, size 0x%lx, max_size 0x%lx\n", | |
| 8860 spx->txlt_sata_pkt-> | |
| 8861 satapkt_cmd.satacmd_num_dma_cookies, | |
| 8862 cur_txfer_len, max_txfer_len); | |
| 8863 break; | |
| 8864 } | |
| 8865 } | |
| 8866 | |
| 8867 ASSERT(cur_txfer_len != 0); | |
| 8868 spx->txlt_total_residue -= cur_txfer_len; | |
| 8869 | |
| 8870 return (DDI_SUCCESS); | |
| 8871 } | |
| 8872 | |
| 8873 /* | |
| 8874 * Fetch Device Identify data. | |
| 8875 * Send DEVICE IDENTIFY command to a device and get the device identify data. | |
| 8876 * The device_info structure has to be set to device type (for selecting proper | |
| 8877 * device identify command). | |
| 8878 * | |
| 8879 * Returns 0 if success, -1 otherwise. | |
| 8880 * | |
| 8881 * Cannot be called in an interrupt context. | |
| 8882 */ | |
| 8883 | |
| 8884 static int | |
| 8885 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, | |
| 8886 sata_drive_info_t *sdinfo) | |
| 8887 { | |
| 8888 struct buf *bp; | |
| 8889 sata_pkt_t *spkt; | |
| 8890 sata_cmd_t *scmd; | |
| 8891 sata_pkt_txlate_t *spx; | |
| 8892 int rval; | |
| 8893 | |
| 8894 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); | |
| 8895 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 8896 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ | |
| 8897 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); | |
| 8898 if (spkt == NULL) { | |
| 8899 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 8900 return (-1); | |
| 8901 } | |
| 8902 /* address is needed now */ | |
| 8903 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 8904 | |
| 8905 /* | |
| 8906 * Allocate buffer for Identify Data return data | |
| 8907 */ | |
| 8908 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); | |
| 8909 if (bp == NULL) { | |
| 8910 sata_pkt_free(spx); | |
| 8911 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 8912 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 8913 "sata_fetch_device_identify_data: " | |
| 8914 "cannot allocate buffer for ID")); | |
| 8915 return (-1); | |
| 8916 } | |
| 8917 | |
| 8918 /* Fill sata_pkt */ | |
| 8919 sdinfo->satadrv_state = SATA_STATE_PROBING; | |
| 8920 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 8921 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; | |
| 8922 /* Synchronous mode, no callback */ | |
| 8923 spkt->satapkt_comp = NULL; | |
| 8924 /* Timeout 30s */ | |
| 8925 spkt->satapkt_time = sata_default_pkt_time; | |
| 8926 | |
| 8927 scmd = &spkt->satapkt_cmd; | |
| 8928 scmd->satacmd_bp = bp; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
8929 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
|
8930 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; |
| 1258 | 8931 |
| 8932 /* Build Identify Device cmd in the sata_pkt */ | |
| 8933 scmd->satacmd_addr_type = 0; /* N/A */ | |
| 8934 scmd->satacmd_sec_count_lsb = 0; /* N/A */ | |
| 8935 scmd->satacmd_lba_low_lsb = 0; /* N/A */ | |
| 8936 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ | |
| 8937 scmd->satacmd_lba_high_lsb = 0; /* N/A */ | |
| 8938 scmd->satacmd_features_reg = 0; /* N/A */ | |
| 8939 scmd->satacmd_device_reg = 0; /* Always device 0 */ | |
| 8940 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { | |
| 8941 /* Identify Packet Device cmd */ | |
| 8942 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; | |
| 8943 } else { | |
| 8944 /* Identify Device cmd - mandatory for all other devices */ | |
| 8945 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; | |
| 8946 } | |
| 8947 | |
| 8948 /* Send pkt to SATA HBA driver */ | |
| 8949 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != | |
| 8950 SATA_TRAN_ACCEPTED || | |
| 8951 spkt->satapkt_reason != SATA_PKT_COMPLETED) { | |
| 8952 /* | |
| 8953 * Woops, no Identify Data. | |
| 8954 * Invalidate sata_drive_info ? | |
| 8955 */ | |
| 8956 rval = -1; | |
| 8957 } else { | |
| 8958 /* Update sata_drive_info */ | |
| 8959 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, | |
| 8960 DDI_DMA_SYNC_FORKERNEL); | |
| 8961 if (rval != DDI_SUCCESS) { | |
| 8962 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, | |
| 8963 "sata_fetch_device_identify_data: " | |
| 8964 "sync pkt failed")); | |
| 8965 rval = -1; | |
| 8966 goto fail; | |
| 8967 } | |
| 8968 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, | |
| 8969 sizeof (sata_id_t)); | |
| 8970 | |
| 8971 sdinfo->satadrv_features_support = 0; | |
| 8972 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { | |
| 8973 /* | |
| 8974 * Retrieve capacity (disks only) and addressing mode | |
| 8975 */ | |
| 8976 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); | |
| 8977 } else { | |
| 8978 /* | |
| 8979 * For ATAPI devices one has to issue Get Capacity cmd | |
| 8980 * (not needed at the moment) | |
| 8981 */ | |
| 8982 sdinfo->satadrv_capacity = 0; | |
| 8983 } | |
| 8984 /* Setup supported features flags */ | |
| 8985 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) | |
| 8986 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; | |
| 8987 | |
| 8988 /* Check for NCQ support */ | |
| 8989 if (sdinfo->satadrv_id.ai_satacap != 0 && | |
| 8990 sdinfo->satadrv_id.ai_satacap != 0xffff) { | |
| 8991 /* SATA compliance */ | |
| 8992 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) | |
| 8993 sdinfo->satadrv_features_support |= | |
| 8994 SATA_DEV_F_NCQ; | |
| 8995 if (sdinfo->satadrv_id.ai_satacap & | |
| 8996 (SATA_1_SPEED | SATA_2_SPEED)) { | |
| 8997 if (sdinfo->satadrv_id.ai_satacap & | |
| 8998 SATA_2_SPEED) | |
| 8999 sdinfo->satadrv_features_support |= | |
| 9000 SATA_DEV_F_SATA2; | |
| 9001 if (sdinfo->satadrv_id.ai_satacap & | |
| 9002 SATA_1_SPEED) | |
| 9003 sdinfo->satadrv_features_support |= | |
| 9004 SATA_DEV_F_SATA1; | |
| 9005 } else { | |
| 9006 sdinfo->satadrv_features_support |= | |
| 9007 SATA_DEV_F_SATA1; | |
| 9008 } | |
| 9009 } | |
| 9010 | |
| 9011 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; | |
| 9012 if (sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) | |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
9013 ++sdinfo->satadrv_queue_depth; |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
9014 |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
9015 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
|
9016 (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
|
9017 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; |
| 1258 | 9018 |
| 9019 rval = 0; | |
| 9020 } | |
| 9021 fail: | |
| 9022 /* Free allocated resources */ | |
| 9023 sata_free_local_buffer(spx); | |
| 9024 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; | |
| 9025 sata_pkt_free(spx); | |
| 9026 kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 9027 | |
| 9028 return (rval); | |
| 9029 } | |
| 9030 | |
| 9031 | |
| 9032 /* | |
| 9033 * SATA spec requires that the device supports at least UDMA 4 mode and | |
| 9034 * UDMA mode is selected. | |
| 9035 * Some devices (bridged devices) may not come-up with default UDMA mode | |
| 9036 * set correctly, so this function is setting it. | |
| 9037 * | |
| 9038 * Returns SATA_SUCCESS if proper UDMA mode is selected. | |
| 9039 * Returns SATA_FAILURE if proper UDMA mode could not be selected. | |
| 9040 */ | |
| 9041 static int | |
| 9042 sata_set_udma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) | |
| 9043 { | |
| 9044 sata_pkt_t *spkt; | |
| 9045 sata_cmd_t *scmd; | |
| 9046 sata_pkt_txlate_t *spx; | |
| 9047 int result = SATA_SUCCESS; | |
| 9048 int i, mode; | |
| 9049 | |
| 9050 ASSERT(sdinfo != NULL); | |
| 9051 ASSERT(sata_hba_inst != NULL); | |
| 9052 | |
| 9053 /* Find highest Ultra DMA mode supported */ | |
| 9054 for (mode = 6; mode >= 0; --mode) { | |
| 9055 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) | |
| 9056 break; | |
| 9057 } | |
| 9058 if (mode < 4) | |
| 9059 return (SATA_FAILURE); | |
| 9060 | |
| 9061 /* Find UDMA mode currently selected */ | |
| 9062 for (i = 6; i >= 0; --i) { | |
| 9063 if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8))) | |
| 9064 break; | |
| 9065 } | |
| 9066 | |
| 9067 if (i < mode) { | |
| 9068 /* Set UDMA mode via SET FEATURES COMMAND */ | |
| 9069 /* Prepare packet for SET FEATURES COMMAND */ | |
| 9070 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); | |
| 9071 spx->txlt_sata_hba_inst = sata_hba_inst; | |
| 9072 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ | |
| 9073 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); | |
| 9074 if (spkt == NULL) { | |
| 9075 result = SATA_FAILURE; | |
| 9076 goto failure; | |
| 9077 } | |
| 9078 /* Fill sata_pkt */ | |
| 9079 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; | |
| 9080 /* Timeout 30s */ | |
| 9081 spkt->satapkt_time = sata_default_pkt_time; | |
| 9082 /* Synchronous mode, no callback, interrupts */ | |
| 9083 spkt->satapkt_op_mode = | |
| 9084 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; | |
| 9085 spkt->satapkt_comp = NULL; | |
| 9086 scmd = &spkt->satapkt_cmd; | |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
9087 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
|
9088 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; |
| 1258 | 9089 scmd->satacmd_addr_type = 0; |
| 9090 scmd->satacmd_device_reg = 0; | |
| 9091 scmd->satacmd_status_reg = 0; | |
| 9092 scmd->satacmd_error_reg = 0; | |
| 9093 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; | |
| 9094 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; | |
| 9095 scmd->satacmd_sec_count_lsb = | |
| 9096 SATAC_TRANSFER_MODE_ULTRA_DMA | mode; | |
| 9097 | |
| 9098 /* Transfer command to HBA */ | |
| 9099 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), | |
| 9100 spkt) != SATA_TRAN_ACCEPTED || | |
| 9101 spkt->satapkt_reason != SATA_PKT_COMPLETED) { | |
| 9102 /* Pkt execution failed */ | |
| 9103 result = SATA_FAILURE; | |
| 9104 } | |
| 9105 failure: | |
| 9106 if (result == SATA_FAILURE) | |
| 9107 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9108 "sata_set_udma_mode: could not set UDMA " | |
| 9109 "mode %", mode)); | |
| 9110 | |
| 9111 /* Free allocated resources */ | |
| 9112 if (spkt != NULL) | |
| 9113 sata_pkt_free(spx); | |
| 9114 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); | |
| 9115 } | |
| 9116 return (result); | |
| 9117 } | |
| 9118 | |
| 9119 | |
| 9120 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9121 * Set device caching mode. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9122 * One of the following operations should be specified: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9123 * SATAC_SF_ENABLE_READ_AHEAD |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9124 * SATAC_SF_DISABLE_READ_AHEAD |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9125 * SATAC_SF_ENABLE_WRITE_CACHE |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9126 * SATAC_SF_DISABLE_WRITE_CACHE |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9127 * |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9128 * If operation fails, system log messgage is emitted. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9129 * 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
|
9130 */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9131 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9132 static int |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9133 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
|
9134 int cache_op) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9135 { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9136 sata_pkt_t *spkt; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9137 sata_cmd_t *scmd; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9138 sata_pkt_txlate_t *spx; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9139 int rval = SATA_SUCCESS; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9140 char *infop; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9141 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9142 ASSERT(sdinfo != NULL); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9143 ASSERT(sata_hba_inst != NULL); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9144 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9145 cache_op == SATAC_SF_DISABLE_READ_AHEAD || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9146 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9147 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9148 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9149 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9150 /* Prepare packet for SET FEATURES COMMAND */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9151 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
|
9152 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9153 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
|
9154 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9155 if (spkt == NULL) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9156 rval = SATA_FAILURE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9157 goto failure; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9158 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9159 /* Fill sata_pkt */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9160 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9161 /* Timeout 30s */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9162 spkt->satapkt_time = sata_default_pkt_time; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9163 /* Synchronous mode, no callback, interrupts */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9164 spkt->satapkt_op_mode = |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9165 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9166 spkt->satapkt_comp = NULL; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9167 scmd = &spkt->satapkt_cmd; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9168 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
|
9169 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
|
9170 scmd->satacmd_addr_type = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9171 scmd->satacmd_device_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9172 scmd->satacmd_status_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9173 scmd->satacmd_error_reg = 0; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9174 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9175 scmd->satacmd_features_reg = cache_op; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9176 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9177 /* Transfer command to HBA */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9178 if (((*SATA_START_FUNC(sata_hba_inst))( |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9179 SATA_DIP(sata_hba_inst), spkt) != 0) || |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9180 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9181 /* Pkt execution failed */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9182 switch (cache_op) { |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9183 case SATAC_SF_ENABLE_READ_AHEAD: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9184 infop = "enabling read ahead failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9185 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9186 case SATAC_SF_DISABLE_READ_AHEAD: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9187 infop = "disabling read ahead failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9188 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9189 case SATAC_SF_ENABLE_WRITE_CACHE: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9190 infop = "enabling write cache failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9191 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9192 case SATAC_SF_DISABLE_WRITE_CACHE: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9193 infop = "disabling write cache failed"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9194 break; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9195 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9196 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
|
9197 rval = SATA_FAILURE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9198 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9199 failure: |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9200 /* Free allocated resources */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9201 if (spkt != NULL) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9202 sata_pkt_free(spx); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9203 (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
|
9204 return (rval); |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9205 } |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9206 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9207 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9208 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9209 /* |
| 1258 | 9210 * Update port SCR block |
| 9211 */ | |
| 9212 static void | |
| 9213 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device) | |
| 9214 { | |
| 9215 port_scr->sstatus = device->satadev_scr.sstatus; | |
| 9216 port_scr->serror = device->satadev_scr.serror; | |
| 9217 port_scr->scontrol = device->satadev_scr.scontrol; | |
| 9218 port_scr->sactive = device->satadev_scr.sactive; | |
| 9219 port_scr->snotific = device->satadev_scr.snotific; | |
| 9220 } | |
| 9221 | |
| 9222 /* | |
| 9223 * Update state and copy port ss* values from passed sata_device structure. | |
| 9224 * sata_address is validated - if not valid, nothing is changed in sata_scsi | |
| 9225 * configuration struct. | |
| 9226 * | |
| 9227 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function | |
| 9228 * regardless of the state in device argument. | |
| 9229 * | |
| 9230 * Port mutex should be held while calling this function. | |
| 9231 */ | |
| 9232 static void | |
| 9233 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, | |
| 9234 sata_device_t *sata_device) | |
| 9235 { | |
| 9236 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, | |
| 9237 sata_device->satadev_addr.cport))); | |
| 9238 | |
| 9239 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || | |
| 9240 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { | |
| 9241 | |
| 9242 sata_cport_info_t *cportinfo; | |
| 9243 | |
| 9244 if (SATA_NUM_CPORTS(sata_hba_inst) <= | |
| 9245 sata_device->satadev_addr.cport) | |
| 9246 return; | |
| 9247 | |
| 9248 cportinfo = SATA_CPORT_INFO(sata_hba_inst, | |
| 9249 sata_device->satadev_addr.cport); | |
| 9250 sata_update_port_scr(&cportinfo->cport_scr, sata_device); | |
| 9251 | |
| 9252 /* Preserve SATA_PSTATE_SHUTDOWN flag */ | |
| 9253 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | | |
| 9254 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); | |
| 9255 cportinfo->cport_state |= | |
| 9256 sata_device->satadev_state & SATA_PSTATE_VALID; | |
| 9257 } else { | |
| 9258 sata_pmport_info_t *pmportinfo; | |
| 9259 | |
| 9260 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) || | |
| 9261 (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || | |
| 9262 SATA_NUM_PMPORTS(sata_hba_inst, | |
| 9263 sata_device->satadev_addr.cport) < | |
| 9264 sata_device->satadev_addr.pmport) | |
| 9265 return; | |
| 9266 | |
| 9267 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, | |
| 9268 sata_device->satadev_addr.cport, | |
| 9269 sata_device->satadev_addr.pmport); | |
| 9270 sata_update_port_scr(&pmportinfo->pmport_scr, sata_device); | |
| 9271 | |
| 9272 /* Preserve SATA_PSTATE_SHUTDOWN flag */ | |
| 9273 pmportinfo->pmport_state &= | |
| 9274 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | | |
| 9275 SATA_PSTATE_FAILED); | |
| 9276 pmportinfo->pmport_state |= | |
| 9277 sata_device->satadev_state & SATA_PSTATE_VALID; | |
| 9278 } | |
| 9279 } | |
| 9280 | |
| 9281 | |
| 9282 | |
| 9283 /* | |
| 9284 * Extract SATA port specification from an IOCTL argument. | |
| 9285 * | |
| 9286 * This function return the port the user land send us as is, unless it | |
| 9287 * cannot retrieve port spec, then -1 is returned. | |
| 9288 * | |
| 9289 * Note: Only cport - no port multiplier port. | |
| 9290 */ | |
| 9291 static int32_t | |
| 9292 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) | |
| 9293 { | |
| 9294 int32_t port; | |
| 9295 | |
| 9296 /* Extract port number from nvpair in dca structure */ | |
| 9297 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { | |
| 9298 SATA_LOG_D((sata_hba_inst, CE_NOTE, | |
| 9299 "sata_get_port_num: invalid port spec 0x%x in ioctl", | |
| 9300 port)); | |
| 9301 port = -1; | |
| 9302 } | |
| 9303 | |
| 9304 return (port); | |
| 9305 } | |
| 9306 | |
| 9307 /* | |
| 9308 * Get dev_info_t pointer to the device node pointed to by port argument. | |
| 9309 * NOTE: target argument is a value used in ioctls to identify | |
| 9310 * the AP - it is not a sata_address. | |
| 9311 * It is a combination of cport, pmport and address qualifier, encodded same | |
| 9312 * way as a scsi target number. | |
| 9313 * At this moment it carries only cport number. | |
| 9314 * | |
| 9315 * No PMult hotplug support. | |
| 9316 * | |
| 9317 * Returns dev_info_t pointer if target device was found, NULL otherwise. | |
| 9318 */ | |
| 9319 | |
| 9320 static dev_info_t * | |
| 9321 sata_get_target_dip(dev_info_t *dip, int32_t port) | |
| 9322 { | |
| 9323 dev_info_t *cdip = NULL; | |
| 9324 int target, tgt; | |
| 9325 int ncport; | |
| 9326 int circ; | |
| 9327 | |
| 9328 ncport = port & SATA_CFGA_CPORT_MASK; | |
| 9329 target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT); | |
| 9330 | |
| 9331 ndi_devi_enter(dip, &circ); | |
| 9332 for (cdip = ddi_get_child(dip); cdip != NULL; ) { | |
| 9333 dev_info_t *next = ddi_get_next_sibling(cdip); | |
| 9334 | |
| 9335 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, | |
| 9336 DDI_PROP_DONTPASS, "target", -1); | |
| 9337 if (tgt == -1) { | |
| 9338 /* | |
| 9339 * This is actually an error condition, but not | |
| 9340 * a fatal one. Just continue the search. | |
| 9341 */ | |
| 9342 cdip = next; | |
| 9343 continue; | |
| 9344 } | |
| 9345 | |
| 9346 if (tgt == target) | |
| 9347 break; | |
| 9348 | |
| 9349 cdip = next; | |
| 9350 } | |
| 9351 ndi_devi_exit(dip, circ); | |
| 9352 | |
| 9353 return (cdip); | |
| 9354 } | |
| 9355 | |
| 9356 | |
| 9357 /* | |
| 9358 * sata_cfgadm_state: | |
| 9359 * Use the sata port state and state of the target node to figure out | |
| 9360 * the cfgadm_state. | |
| 9361 * | |
| 9362 * The port argument is a value with encoded cport, | |
| 9363 * pmport and address qualifier, in the same manner as a scsi target number. | |
| 9364 * SCSI_TO_SATA_CPORT macro extracts cport number, | |
| 9365 * SCSI_TO_SATA_PMPORT extracts pmport number and | |
| 9366 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. | |
| 9367 * | |
| 9368 * For now, support is for cports only - no pmultiplier ports. | |
| 9369 */ | |
| 9370 | |
| 9371 static void | |
| 9372 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, | |
| 9373 devctl_ap_state_t *ap_state) | |
| 9374 { | |
| 9375 uint16_t cport; | |
| 9376 int port_state; | |
| 9377 | |
| 9378 /* Cport only */ | |
| 9379 cport = SCSI_TO_SATA_CPORT(port); | |
| 9380 | |
| 9381 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); | |
| 9382 if (port_state & SATA_PSTATE_SHUTDOWN || | |
| 9383 port_state & SATA_PSTATE_FAILED) { | |
| 9384 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; | |
| 9385 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9386 if (port_state & SATA_PSTATE_FAILED) | |
| 9387 ap_state->ap_condition = AP_COND_FAILED; | |
| 9388 else | |
| 9389 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9390 | |
| 9391 return; | |
| 9392 } | |
| 9393 | |
| 9394 /* Need to check pmult device port here as well, when supported */ | |
| 9395 | |
| 9396 /* Port is enabled and ready */ | |
| 9397 | |
| 9398 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { | |
| 9399 case SATA_DTYPE_NONE: | |
| 9400 { | |
| 9401 /* No device attached */ | |
| 9402 ap_state->ap_rstate = AP_RSTATE_EMPTY; | |
| 9403 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9404 ap_state->ap_condition = AP_COND_OK; | |
| 9405 break; | |
| 9406 } | |
| 9407 case SATA_DTYPE_UNKNOWN: | |
| 9408 case SATA_DTYPE_ATAPINONCD: | |
| 9409 case SATA_DTYPE_PMULT: /* Until PMult is supported */ | |
| 9410 { | |
| 9411 /* Unknown device attached */ | |
| 9412 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 9413 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9414 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9415 break; | |
| 9416 } | |
| 9417 case SATA_DTYPE_ATADISK: | |
| 9418 case SATA_DTYPE_ATAPICD: | |
| 9419 { | |
| 9420 dev_info_t *tdip = NULL; | |
| 9421 dev_info_t *dip = NULL; | |
| 9422 int circ; | |
| 9423 | |
| 9424 dip = SATA_DIP(sata_hba_inst); | |
| 9425 tdip = sata_get_target_dip(dip, port); | |
| 9426 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 9427 if (tdip != NULL) { | |
| 9428 ndi_devi_enter(dip, &circ); | |
| 9429 mutex_enter(&(DEVI(tdip)->devi_lock)); | |
| 9430 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || | |
| 9431 (DEVI_IS_DEVICE_DOWN(tdip))) { | |
| 9432 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9433 } else { | |
| 9434 ap_state->ap_ostate = AP_OSTATE_CONFIGURED; | |
| 9435 } | |
| 9436 ap_state->ap_condition = AP_COND_OK; | |
| 9437 mutex_exit(&(DEVI(tdip)->devi_lock)); | |
| 9438 ndi_devi_exit(dip, circ); | |
| 9439 } else { | |
| 9440 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9441 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9442 } | |
| 9443 break; | |
| 9444 } | |
| 9445 default: | |
| 9446 ap_state->ap_rstate = AP_RSTATE_CONNECTED; | |
| 9447 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; | |
| 9448 ap_state->ap_condition = AP_COND_UNKNOWN; | |
| 9449 /* | |
| 9450 * This is actually internal error condition (non fatal), | |
| 9451 * beacuse we already checked all defined device types. | |
| 9452 */ | |
| 9453 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9454 "sata_cfgadm_state: Internal error: " | |
| 9455 "unknown device type")); | |
| 9456 break; | |
| 9457 } | |
| 9458 } | |
| 9459 | |
| 9460 /* | |
| 9461 * Start or terminate the thread, depending on flag arg and current state | |
| 9462 */ | |
| 9463 static void | |
| 9464 sata_event_thread_control(int startstop) | |
| 9465 { | |
| 9466 static int sata_event_thread_terminating = 0; | |
| 9467 static int sata_event_thread_starting = 0; | |
| 9468 int i; | |
| 9469 | |
| 9470 mutex_enter(&sata_event_mutex); | |
| 9471 | |
| 9472 if (startstop == 0 && (sata_event_thread_starting == 1 || | |
| 9473 sata_event_thread_terminating == 1)) { | |
| 9474 mutex_exit(&sata_event_mutex); | |
| 9475 return; | |
| 9476 } | |
| 9477 if (startstop == 1 && sata_event_thread_starting == 1) { | |
| 9478 mutex_exit(&sata_event_mutex); | |
| 9479 return; | |
| 9480 } | |
| 9481 if (startstop == 1 && sata_event_thread_terminating == 1) { | |
| 9482 sata_event_thread_starting = 1; | |
| 9483 /* wait til terminate operation completes */ | |
| 9484 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; | |
| 9485 while (sata_event_thread_terminating == 1) { | |
| 9486 if (i-- <= 0) { | |
| 9487 sata_event_thread_starting = 0; | |
| 9488 mutex_exit(&sata_event_mutex); | |
| 9489 #ifdef SATA_DEBUG | |
| 9490 cmn_err(CE_WARN, "sata_event_thread_control: " | |
| 9491 "timeout waiting for thread to terminate"); | |
| 9492 #endif | |
| 9493 return; | |
| 9494 } | |
| 9495 mutex_exit(&sata_event_mutex); | |
| 9496 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); | |
| 9497 mutex_enter(&sata_event_mutex); | |
| 9498 } | |
| 9499 } | |
| 9500 if (startstop == 1) { | |
| 9501 if (sata_event_thread == NULL) { | |
| 9502 sata_event_thread = thread_create(NULL, 0, | |
| 9503 (void (*)())sata_event_daemon, | |
| 9504 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); | |
| 9505 } | |
| 9506 sata_event_thread_starting = 0; | |
| 9507 mutex_exit(&sata_event_mutex); | |
| 9508 return; | |
| 9509 } | |
| 9510 | |
| 9511 /* | |
| 9512 * If we got here, thread may need to be terminated | |
| 9513 */ | |
| 9514 if (sata_event_thread != NULL) { | |
| 9515 int i; | |
| 9516 /* Signal event thread to go away */ | |
| 9517 sata_event_thread_terminating = 1; | |
| 9518 sata_event_thread_terminate = 1; | |
| 9519 cv_signal(&sata_event_cv); | |
| 9520 /* | |
| 9521 * Wait til daemon terminates. | |
| 9522 */ | |
| 9523 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; | |
| 9524 while (sata_event_thread_terminate == 1) { | |
| 9525 mutex_exit(&sata_event_mutex); | |
| 9526 if (i-- <= 0) { | |
| 9527 /* Daemon did not go away !!! */ | |
| 9528 #ifdef SATA_DEBUG | |
| 9529 cmn_err(CE_WARN, "sata_event_thread_control: " | |
| 9530 "cannot terminate event daemon thread"); | |
| 9531 #endif | |
| 9532 mutex_enter(&sata_event_mutex); | |
| 9533 break; | |
| 9534 } | |
| 9535 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); | |
| 9536 mutex_enter(&sata_event_mutex); | |
| 9537 } | |
| 9538 sata_event_thread_terminating = 0; | |
| 9539 } | |
| 9540 ASSERT(sata_event_thread_terminating == 0); | |
| 9541 ASSERT(sata_event_thread_starting == 0); | |
| 9542 mutex_exit(&sata_event_mutex); | |
| 9543 } | |
| 9544 | |
| 9545 | |
| 9546 /* | |
| 9547 * Log sata message | |
| 9548 * dev pathname msg line preceeds the logged message. | |
| 9549 */ | |
| 9550 | |
| 9551 static void | |
| 9552 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) | |
| 9553 { | |
| 9554 char pathname[128]; | |
| 9555 dev_info_t *dip; | |
| 9556 va_list ap; | |
| 9557 | |
| 9558 mutex_enter(&sata_log_mutex); | |
| 9559 | |
| 9560 va_start(ap, fmt); | |
| 9561 (void) vsprintf(sata_log_buf, fmt, ap); | |
| 9562 va_end(ap); | |
| 9563 | |
| 9564 if (sata_hba_inst != NULL) { | |
| 9565 dip = SATA_DIP(sata_hba_inst); | |
| 9566 (void) ddi_pathname(dip, pathname); | |
| 9567 } else { | |
| 9568 pathname[0] = 0; | |
| 9569 } | |
| 9570 if (level == CE_CONT) { | |
| 9571 if (sata_debug_flags == 0) | |
| 9572 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); | |
| 9573 else | |
| 9574 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); | |
| 9575 } else | |
| 9576 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); | |
| 9577 | |
| 9578 mutex_exit(&sata_log_mutex); | |
| 9579 } | |
| 9580 | |
| 9581 | |
| 9582 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ | |
| 9583 | |
| 9584 /* | |
| 9585 * SATA HBA event notification function. | |
| 9586 * Events reported by SATA HBA drivers per HBA instance relate to a change in | |
| 9587 * a port and/or device state or a controller itself. | |
| 9588 * Events for different addresses/addr types cannot be combined. | |
| 9589 * A warning message is generated for each event type. | |
| 9590 * Events are not processed by this function, so only the | |
| 9591 * event flag(s)is set for an affected entity and the event thread is | |
| 9592 * waken up. Event daemon thread processes all events. | |
| 9593 * | |
| 9594 * NOTE: Since more than one event may be reported at the same time, one | |
| 9595 * cannot determine a sequence of events when opposite event are reported, eg. | |
| 9596 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing | |
| 9597 * is taking precedence over reported events, i.e. may cause ignoring some | |
| 9598 * events. | |
| 9599 */ | |
| 9600 #define SATA_EVENT_MAX_MSG_LENGTH 79 | |
| 9601 | |
| 9602 void | |
| 9603 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) | |
| 9604 { | |
| 9605 sata_hba_inst_t *sata_hba_inst = NULL; | |
| 9606 sata_address_t *saddr; | |
| 9607 sata_drive_info_t *sdinfo; | |
| 9608 sata_port_stats_t *pstats; | |
| 9609 int cport, pmport; | |
| 9610 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; | |
| 9611 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; | |
| 9612 char *lcp; | |
| 9613 static char *err_msg_evnt_1 = | |
| 9614 "sata_hba_event_notify: invalid port event 0x%x "; | |
| 9615 static char *err_msg_evnt_2 = | |
| 9616 "sata_hba_event_notify: invalid device event 0x%x "; | |
| 9617 int linkevent; | |
| 9618 | |
| 9619 /* | |
| 9620 * There is a possibility that an event will be generated on HBA | |
| 9621 * that has not completed attachment or is detaching. | |
| 9622 * HBA driver should prevent this, but just in case it does not, | |
| 9623 * we need to ignore events for such HBA. | |
| 9624 */ | |
| 9625 mutex_enter(&sata_mutex); | |
| 9626 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 9627 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 9628 if (SATA_DIP(sata_hba_inst) == dip) | |
| 9629 if (sata_hba_inst->satahba_attached == 1) | |
| 9630 break; | |
| 9631 } | |
| 9632 mutex_exit(&sata_mutex); | |
| 9633 if (sata_hba_inst == NULL) | |
| 9634 /* HBA not attached */ | |
| 9635 return; | |
| 9636 | |
| 9637 ASSERT(sata_device != NULL); | |
| 9638 | |
| 9639 /* | |
| 9640 * Validate address before - do not proceed with invalid address. | |
| 9641 */ | |
| 9642 saddr = &sata_device->satadev_addr; | |
| 9643 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) | |
| 9644 return; | |
| 9645 if (saddr->qual == SATA_ADDR_PMPORT || | |
| 9646 saddr->qual == SATA_ADDR_DPMPORT) | |
| 9647 /* Port Multiplier not supported yet */ | |
| 9648 return; | |
| 9649 | |
| 9650 cport = saddr->cport; | |
| 9651 pmport = saddr->pmport; | |
| 9652 | |
| 9653 buf1[0] = buf2[0] = '\0'; | |
| 9654 | |
| 9655 /* | |
| 9656 * Events refer to devices, ports and controllers - each has | |
| 9657 * unique address. Events for different addresses cannot be combined. | |
| 9658 */ | |
| 9659 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { | |
| 9660 | |
| 9661 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9662 | |
| 9663 /* qualify this event(s) */ | |
| 9664 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { | |
| 9665 /* Invalid event for the device port */ | |
| 9666 (void) sprintf(buf2, err_msg_evnt_1, | |
| 9667 event & SATA_EVNT_PORT_EVENTS); | |
| 9668 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9669 goto event_info; | |
| 9670 } | |
| 9671 if (saddr->qual == SATA_ADDR_CPORT) { | |
| 9672 /* Controller's device port event */ | |
| 9673 | |
| 9674 (SATA_CPORT_INFO(sata_hba_inst, cport))-> | |
| 9675 cport_event_flags |= | |
| 9676 event & SATA_EVNT_PORT_EVENTS; | |
| 9677 pstats = | |
| 9678 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> | |
| 9679 cport_stats; | |
| 9680 } else { | |
| 9681 /* Port multiplier's device port event */ | |
| 9682 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> | |
| 9683 pmport_event_flags |= | |
| 9684 event & SATA_EVNT_PORT_EVENTS; | |
| 9685 pstats = | |
| 9686 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> | |
| 9687 pmport_stats; | |
| 9688 } | |
| 9689 | |
| 9690 /* | |
| 9691 * Add to statistics and log the message. We have to do it | |
| 9692 * here rather than in the event daemon, because there may be | |
| 9693 * multiple events occuring before they are processed. | |
| 9694 */ | |
| 9695 linkevent = event & | |
| 9696 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); | |
| 9697 if (linkevent) { | |
| 9698 if (linkevent == (SATA_EVNT_LINK_LOST | | |
| 9699 SATA_EVNT_LINK_ESTABLISHED)) { | |
| 9700 /* This is likely event combination */ | |
| 9701 (void) strlcat(buf1, "link lost/established, ", | |
| 9702 SATA_EVENT_MAX_MSG_LENGTH); | |
| 9703 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9704 if (pstats->link_lost < 0xffffffffffffffffULL) |
| 1258 | 9705 pstats->link_lost++; |
| 9706 if (pstats->link_established < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9707 0xffffffffffffffffULL) |
| 1258 | 9708 pstats->link_established++; |
| 9709 linkevent = 0; | |
| 9710 } else if (linkevent & SATA_EVNT_LINK_LOST) { | |
| 9711 (void) strlcat(buf1, "link lost, ", | |
| 9712 SATA_EVENT_MAX_MSG_LENGTH); | |
| 9713 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9714 if (pstats->link_lost < 0xffffffffffffffffULL) |
| 1258 | 9715 pstats->link_lost++; |
| 9716 } else { | |
| 9717 (void) strlcat(buf1, "link established, ", | |
| 9718 SATA_EVENT_MAX_MSG_LENGTH); | |
| 9719 if (pstats->link_established < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9720 0xffffffffffffffffULL) |
| 1258 | 9721 pstats->link_established++; |
| 9722 } | |
| 9723 } | |
| 9724 if (event & SATA_EVNT_DEVICE_ATTACHED) { | |
| 9725 (void) strlcat(buf1, "device attached, ", | |
| 9726 SATA_EVENT_MAX_MSG_LENGTH); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9727 if (pstats->device_attached < 0xffffffffffffffffULL) |
| 1258 | 9728 pstats->device_attached++; |
| 9729 } | |
| 9730 if (event & SATA_EVNT_DEVICE_DETACHED) { | |
| 9731 (void) strlcat(buf1, "device detached, ", | |
| 9732 SATA_EVENT_MAX_MSG_LENGTH); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9733 if (pstats->device_detached < 0xffffffffffffffffULL) |
| 1258 | 9734 pstats->device_detached++; |
| 9735 } | |
| 9736 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { | |
| 9737 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 9738 "port %d power level changed", cport); | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9739 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) |
| 1258 | 9740 pstats->port_pwr_changed++; |
| 9741 } | |
| 9742 | |
| 9743 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { | |
| 9744 /* There should be no other events for this address */ | |
| 9745 (void) sprintf(buf2, err_msg_evnt_1, | |
| 9746 event & ~SATA_EVNT_PORT_EVENTS); | |
| 9747 } | |
| 9748 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9749 | |
| 9750 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { | |
| 9751 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9752 | |
| 9753 /* qualify this event */ | |
| 9754 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { | |
| 9755 /* Invalid event for a device */ | |
| 9756 (void) sprintf(buf2, err_msg_evnt_2, | |
| 9757 event & SATA_EVNT_DEVICE_RESET); | |
| 9758 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9759 goto event_info; | |
| 9760 } | |
| 9761 /* drive event */ | |
| 9762 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); | |
| 9763 if (sdinfo != NULL) { | |
| 9764 if (event & SATA_EVNT_DEVICE_RESET) { | |
| 9765 (void) strlcat(buf1, "device reset, ", | |
| 9766 SATA_EVENT_MAX_MSG_LENGTH); | |
| 9767 if (sdinfo->satadrv_stats.drive_reset < | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
9768 0xffffffffffffffffULL) |
| 1258 | 9769 sdinfo->satadrv_stats.drive_reset++; |
| 9770 sdinfo->satadrv_event_flags |= | |
| 9771 SATA_EVNT_DEVICE_RESET; | |
| 9772 } | |
| 9773 } | |
| 9774 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { | |
| 9775 /* Invalid event for a device */ | |
| 9776 (void) sprintf(buf2, err_msg_evnt_2, | |
| 9777 event & ~SATA_EVNT_DRIVE_EVENTS); | |
| 9778 } | |
| 9779 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); | |
| 9780 } else { | |
| 9781 if (saddr->qual != SATA_ADDR_NULL) { | |
| 9782 /* Wrong address qualifier */ | |
| 9783 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9784 "sata_hba_event_notify: invalid address 0x%x", | |
| 9785 *(uint32_t *)saddr)); | |
| 9786 return; | |
| 9787 } | |
| 9788 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || | |
| 9789 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { | |
| 9790 /* Invalid event for the controller */ | |
| 9791 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 9792 "sata_hba_event_notify: invalid event 0x%x for " | |
| 9793 "controller", | |
| 9794 event & SATA_EVNT_CONTROLLER_EVENTS)); | |
| 9795 return; | |
| 9796 } | |
| 9797 buf1[0] = '\0'; | |
| 9798 /* This may be a frequent and not interesting event */ | |
| 9799 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, | |
| 9800 "controller power level changed\n", NULL); | |
| 9801 | |
| 9802 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 9803 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
|
9804 0xffffffffffffffffULL) |
| 1258 | 9805 sata_hba_inst->satahba_stats.ctrl_pwr_change++; |
| 9806 | |
| 9807 sata_hba_inst->satahba_event_flags |= | |
| 9808 SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 9809 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 9810 } | |
| 9811 /* | |
| 9812 * If we got here, there is something to do with this HBA | |
| 9813 * instance. | |
| 9814 */ | |
| 9815 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 9816 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 9817 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 9818 mutex_enter(&sata_mutex); | |
| 9819 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ | |
| 9820 mutex_exit(&sata_mutex); | |
| 9821 | |
| 9822 /* Tickle event thread */ | |
| 9823 mutex_enter(&sata_event_mutex); | |
| 9824 if (sata_event_thread_active == 0) | |
| 9825 cv_signal(&sata_event_cv); | |
| 9826 mutex_exit(&sata_event_mutex); | |
| 9827 | |
| 9828 event_info: | |
| 9829 if (buf1[0] != '\0') { | |
| 9830 lcp = strrchr(buf1, ','); | |
| 9831 if (lcp != NULL) | |
| 9832 *lcp = '\0'; | |
| 9833 } | |
| 9834 if (saddr->qual == SATA_ADDR_CPORT || | |
| 9835 saddr->qual == SATA_ADDR_DCPORT) { | |
| 9836 if (buf1[0] != '\0') { | |
| 9837 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", | |
| 9838 cport, buf1); | |
| 9839 } | |
| 9840 if (buf2[0] != '\0') { | |
| 9841 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", | |
| 9842 cport, buf2); | |
| 9843 } | |
| 9844 } else if (saddr->qual == SATA_ADDR_PMPORT || | |
| 9845 saddr->qual == SATA_ADDR_DPMPORT) { | |
| 9846 if (buf1[0] != '\0') { | |
| 9847 sata_log(sata_hba_inst, CE_NOTE, | |
| 9848 "port %d pmport %d: %s\n", cport, pmport, buf1); | |
| 9849 } | |
| 9850 if (buf2[0] != '\0') { | |
| 9851 sata_log(sata_hba_inst, CE_NOTE, | |
| 9852 "port %d pmport %d: %s\n", cport, pmport, buf2); | |
| 9853 } | |
| 9854 } | |
| 9855 } | |
| 9856 | |
| 9857 | |
| 9858 /* | |
| 9859 * Event processing thread. | |
| 9860 * Arg is a pointer to the sata_hba_list pointer. | |
| 9861 * It is not really needed, because sata_hba_list is global and static | |
| 9862 */ | |
| 9863 static void | |
| 9864 sata_event_daemon(void *arg) | |
| 9865 { | |
| 9866 #ifndef __lock_lint | |
| 9867 _NOTE(ARGUNUSED(arg)) | |
| 9868 #endif | |
| 9869 sata_hba_inst_t *sata_hba_inst; | |
| 9870 clock_t lbolt; | |
| 9871 | |
| 9872 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 9873 "SATA event daemon started\n", NULL); | |
| 9874 loop: | |
| 9875 /* | |
| 9876 * Process events here. Walk through all registered HBAs | |
| 9877 */ | |
| 9878 mutex_enter(&sata_mutex); | |
| 9879 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 9880 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 9881 ASSERT(sata_hba_inst != NULL); | |
| 9882 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 9883 if (sata_hba_inst->satahba_attached != 1 || | |
| 9884 (sata_hba_inst->satahba_event_flags & | |
| 9885 SATA_EVNT_SKIP) != 0) { | |
| 9886 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 9887 continue; | |
| 9888 } | |
| 9889 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { | |
| 9890 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; | |
| 9891 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 9892 mutex_exit(&sata_mutex); | |
| 9893 /* Got the controller with pending event */ | |
| 9894 sata_process_controller_events(sata_hba_inst); | |
| 9895 /* | |
| 9896 * Since global mutex was released, there is a | |
| 9897 * possibility that HBA list has changed, so start | |
| 9898 * over from the top. Just processed controller | |
| 9899 * will be passed-over because of the SKIP flag. | |
| 9900 */ | |
| 9901 goto loop; | |
| 9902 } | |
| 9903 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 9904 } | |
| 9905 /* Clear SKIP flag in all controllers */ | |
| 9906 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; | |
| 9907 sata_hba_inst = sata_hba_inst->satahba_next) { | |
| 9908 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 9909 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; | |
| 9910 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 9911 } | |
| 9912 mutex_exit(&sata_mutex); | |
| 9913 | |
| 9914 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 9915 "SATA EVENT DAEMON suspending itself", NULL); | |
| 9916 | |
| 9917 #ifdef SATA_DEBUG | |
| 9918 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { | |
| 9919 sata_log(sata_hba_inst, CE_WARN, | |
| 9920 "SATA EVENTS PROCESSING DISABLED\n"); | |
| 9921 thread_exit(); /* Daemon will not run again */ | |
| 9922 } | |
| 9923 #endif | |
| 9924 mutex_enter(&sata_event_mutex); | |
| 9925 sata_event_thread_active = 0; | |
| 9926 mutex_exit(&sata_event_mutex); | |
| 9927 /* | |
| 9928 * Go to sleep/suspend itself and wake up either because new event or | |
| 9929 * wait timeout. Exit if there is a termination request (driver | |
| 9930 * unload). | |
| 9931 */ | |
| 9932 do { | |
| 9933 lbolt = ddi_get_lbolt(); | |
| 9934 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); | |
| 9935 mutex_enter(&sata_event_mutex); | |
| 9936 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt); | |
| 9937 | |
| 9938 if (sata_event_thread_active != 0) { | |
| 9939 mutex_exit(&sata_event_mutex); | |
| 9940 continue; | |
| 9941 } | |
| 9942 | |
| 9943 /* Check if it is time to go away */ | |
| 9944 if (sata_event_thread_terminate == 1) { | |
| 9945 /* | |
| 9946 * It is up to the thread setting above flag to make | |
| 9947 * sure that this thread is not killed prematurely. | |
| 9948 */ | |
| 9949 sata_event_thread_terminate = 0; | |
| 9950 sata_event_thread = NULL; | |
| 9951 mutex_exit(&sata_event_mutex); | |
| 9952 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 9953 "SATA_EVENT_DAEMON_TERMINATING", NULL); | |
| 9954 thread_exit(); { _NOTE(NOT_REACHED) } | |
| 9955 } | |
| 9956 mutex_exit(&sata_event_mutex); | |
| 9957 } while (!(sata_event_pending & SATA_EVNT_MAIN)); | |
| 9958 | |
| 9959 mutex_enter(&sata_event_mutex); | |
| 9960 sata_event_thread_active = 1; | |
| 9961 mutex_exit(&sata_event_mutex); | |
| 9962 | |
| 9963 mutex_enter(&sata_mutex); | |
| 9964 sata_event_pending &= ~SATA_EVNT_MAIN; | |
| 9965 mutex_exit(&sata_mutex); | |
| 9966 | |
| 9967 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, | |
| 9968 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); | |
| 9969 | |
| 9970 goto loop; | |
| 9971 } | |
| 9972 | |
| 9973 /* | |
| 9974 * Specific HBA instance event processing. | |
| 9975 * | |
| 9976 * NOTE: At the moment, device event processing is limited to hard disks | |
| 9977 * only. | |
| 9978 * cports only are supported - no pmports. | |
| 9979 */ | |
| 9980 static void | |
| 9981 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) | |
| 9982 { | |
| 9983 int ncport; | |
| 9984 uint32_t event_flags; | |
| 9985 sata_address_t *saddr; | |
| 9986 | |
| 9987 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, | |
| 9988 "Processing controller %d event(s)", | |
| 9989 ddi_get_instance(SATA_DIP(sata_hba_inst))); | |
| 9990 | |
| 9991 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 9992 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; | |
| 9993 event_flags = sata_hba_inst->satahba_event_flags; | |
| 9994 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 9995 /* | |
| 9996 * Process controller power change first | |
| 9997 * HERE | |
| 9998 */ | |
| 9999 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) | |
| 10000 sata_process_cntrl_pwr_level_change(sata_hba_inst); | |
| 10001 | |
| 10002 /* | |
| 10003 * Search through ports/devices to identify affected port/device. | |
| 10004 * We may have to process events for more than one port/device. | |
| 10005 */ | |
| 10006 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { | |
| 10007 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10008 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 10009 cport_event_flags; | |
| 10010 /* Check if port was locked by IOCTL processing */ | |
| 10011 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { | |
| 10012 /* | |
| 10013 * We ignore port events because port is busy | |
| 10014 * with AP control processing. Set again | |
| 10015 * controller and main event flag, so that | |
| 10016 * events may be processed by the next daemon | |
| 10017 * run. | |
| 10018 */ | |
| 10019 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10020 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10021 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 10022 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10023 mutex_enter(&sata_mutex); | |
| 10024 sata_event_pending |= SATA_EVNT_MAIN; | |
| 10025 mutex_exit(&sata_mutex); | |
| 10026 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, | |
| 10027 "Event processing postponed until " | |
| 10028 "AP control processing completes", | |
| 10029 NULL); | |
| 10030 /* Check other ports */ | |
| 10031 continue; | |
| 10032 } else { | |
| 10033 /* | |
| 10034 * Set BSY flag so that AP control would not | |
| 10035 * interfere with events processing for | |
| 10036 * this port. | |
| 10037 */ | |
| 10038 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 10039 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; | |
| 10040 } | |
| 10041 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10042 | |
| 10043 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; | |
| 10044 | |
| 10045 if ((event_flags & | |
| 10046 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { | |
| 10047 /* | |
| 10048 * Got port event. | |
| 10049 * We need some hierarchy of event processing as they | |
| 10050 * are affecting each other: | |
| 10051 * 1. port failed | |
| 10052 * 2. device detached/attached | |
| 10053 * 3. link events - link events may trigger device | |
| 10054 * detached or device attached events in some | |
| 10055 * circumstances. | |
| 10056 * 4. port power level changed | |
| 10057 */ | |
| 10058 if (event_flags & SATA_EVNT_PORT_FAILED) { | |
| 10059 sata_process_port_failed_event(sata_hba_inst, | |
| 10060 saddr); | |
| 10061 } | |
| 10062 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { | |
| 10063 sata_process_device_detached(sata_hba_inst, | |
| 10064 saddr); | |
| 10065 } | |
| 10066 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { | |
| 10067 sata_process_device_attached(sata_hba_inst, | |
| 10068 saddr); | |
| 10069 } | |
| 10070 if (event_flags & | |
| 10071 (SATA_EVNT_LINK_ESTABLISHED | | |
| 10072 SATA_EVNT_LINK_LOST)) { | |
| 10073 sata_process_port_link_events(sata_hba_inst, | |
| 10074 saddr); | |
| 10075 } | |
| 10076 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { | |
| 10077 sata_process_port_pwr_change(sata_hba_inst, | |
| 10078 saddr); | |
| 10079 } | |
| 10080 } | |
| 10081 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != | |
| 10082 SATA_DTYPE_NONE) { | |
| 10083 /* May have device event */ | |
| 10084 sata_process_device_reset(sata_hba_inst, saddr); | |
| 10085 } | |
| 10086 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10087 /* Release PORT_BUSY flag */ | |
| 10088 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> | |
| 10089 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; | |
| 10090 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); | |
| 10091 | |
| 10092 } /* End of loop through the controller SATA ports */ | |
| 10093 } | |
| 10094 | |
| 10095 /* | |
| 10096 * Process HBA power level change reported by HBA driver. | |
| 10097 * Not implemented at this time - event is ignored. | |
| 10098 */ | |
| 10099 static void | |
| 10100 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) | |
| 10101 { | |
| 10102 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10103 "Processing controller power level change", NULL); | |
| 10104 | |
| 10105 /* Ignoring it for now */ | |
| 10106 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10107 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 10108 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10109 } | |
| 10110 | |
| 10111 /* | |
| 10112 * Process port power level change reported by HBA driver. | |
| 10113 * Not implemented at this time - event is ignored. | |
| 10114 */ | |
| 10115 static void | |
| 10116 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, | |
| 10117 sata_address_t *saddr) | |
| 10118 { | |
| 10119 sata_cport_info_t *cportinfo; | |
| 10120 | |
| 10121 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10122 "Processing port power level change", NULL); | |
| 10123 | |
| 10124 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10125 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10126 /* Reset event flag */ | |
| 10127 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; | |
| 10128 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10129 } | |
| 10130 | |
| 10131 /* | |
| 10132 * Process port failure reported by HBA driver. | |
| 10133 * cports support only - no pmports. | |
| 10134 */ | |
| 10135 static void | |
| 10136 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, | |
| 10137 sata_address_t *saddr) | |
| 10138 { | |
| 10139 sata_cport_info_t *cportinfo; | |
| 10140 | |
| 10141 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10142 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10143 /* Reset event flag first */ | |
| 10144 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; | |
| 10145 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ | |
| 10146 if ((cportinfo->cport_state & | |
| 10147 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { | |
| 10148 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10149 cport_mutex); | |
| 10150 return; | |
| 10151 } | |
| 10152 /* Fail the port */ | |
| 10153 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10154 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10155 sata_log(sata_hba_inst, CE_WARN, "port %d failed", saddr->cport); | |
| 10156 } | |
| 10157 | |
| 10158 /* | |
| 10159 * Device Reset Event processing. | |
| 10160 * The seqeunce is managed by 3 stage flags: | |
| 10161 * - reset event reported, | |
| 10162 * - reset event being processed, | |
| 10163 * - request to clear device reset state. | |
| 10164 */ | |
| 10165 static void | |
| 10166 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, | |
| 10167 sata_address_t *saddr) | |
| 10168 { | |
| 10169 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ | |
| 10170 sata_drive_info_t *sdinfo; | |
| 10171 sata_cport_info_t *cportinfo; | |
| 10172 sata_device_t sata_device; | |
| 10173 int rval; | |
| 10174 | |
| 10175 /* We only care about host sata cport for now */ | |
| 10176 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10177 | |
| 10178 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10179 | |
| 10180 /* If the port is in SHUTDOWN or FAILED state, ignore reset event. */ | |
| 10181 if ((cportinfo->cport_state & | |
| 10182 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10183 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10184 cport_mutex); | |
| 10185 return; | |
| 10186 } | |
| 10187 | |
| 10188 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & | |
| 10189 SATA_VALID_DEV_TYPE) == 0) { | |
| 10190 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10191 cport_mutex); | |
| 10192 return; | |
| 10193 } | |
| 10194 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); | |
| 10195 if (sdinfo == NULL) { | |
| 10196 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10197 cport_mutex); | |
| 10198 return; | |
| 10199 } | |
| 10200 | |
| 10201 if ((sdinfo->satadrv_event_flags & SATA_EVNT_DEVICE_RESET) == 0) { | |
| 10202 /* Nothing to do */ | |
| 10203 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10204 cport_mutex); | |
| 10205 return; | |
| 10206 } | |
| 10207 | |
| 10208 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10209 "Processing port %d device reset", saddr->cport); | |
| 10210 | |
| 10211 if (sdinfo->satadrv_event_flags & SATA_EVNT_INPROC_DEVICE_RESET) { | |
| 10212 /* Something is weird - new device reset event */ | |
| 10213 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10214 "Overlapping device reset events!", NULL); | |
| 10215 /* Just leave */ | |
| 10216 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10217 cport_mutex); | |
| 10218 return; | |
| 10219 } | |
| 10220 | |
| 10221 /* Clear event flag */ | |
| 10222 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; | |
| 10223 | |
| 10224 /* It seems that we always need to check the port state first */ | |
| 10225 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10226 sata_device.satadev_addr = *saddr; | |
| 10227 /* | |
| 10228 * We have to exit mutex, because the HBA probe port function may | |
| 10229 * block on its own mutex. | |
| 10230 */ | |
| 10231 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10232 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10233 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10234 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10235 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 10236 if (rval != SATA_SUCCESS) { | |
| 10237 /* Something went wrong? Fail the port */ | |
| 10238 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10239 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10240 cport_mutex); | |
| 10241 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed", | |
| 10242 saddr->cport)); | |
| 10243 return; | |
| 10244 } | |
| 10245 if ((sata_device.satadev_scr.sstatus & | |
| 10246 SATA_PORT_DEVLINK_UP_MASK) != | |
| 10247 SATA_PORT_DEVLINK_UP || | |
| 10248 sata_device.satadev_type == SATA_DTYPE_NONE) { | |
| 10249 /* | |
| 10250 * No device to process, anymore. Some other event processing | |
| 10251 * would or have already performed port info cleanup. | |
| 10252 * To be safe (HBA may need it), request clearing device | |
| 10253 * reset condition. | |
| 10254 */ | |
| 10255 sdinfo->satadrv_event_flags = 0; | |
| 10256 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 10257 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10258 cport_mutex); | |
| 10259 return; | |
| 10260 } | |
| 10261 | |
| 10262 /* Mark device reset processing as active */ | |
| 10263 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; | |
| 10264 | |
| 10265 old_sdinfo = *sdinfo; /* local copy of the drive info */ | |
| 10266 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10267 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10268 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == |
| 1258 | 10269 SATA_FAILURE) { |
| 10270 /* | |
| 10271 * Restoring drive setting failed. | |
| 10272 * Probe the port first, to check if the port state has changed | |
| 10273 */ | |
| 10274 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10275 sata_device.satadev_addr = *saddr; | |
| 10276 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; | |
| 10277 /* probe port */ | |
| 10278 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10279 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10280 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10281 cport_mutex); | |
| 10282 if (rval == SATA_SUCCESS && | |
| 10283 (sata_device.satadev_state & | |
| 10284 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && | |
| 10285 (sata_device.satadev_scr.sstatus & | |
| 10286 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && | |
| 10287 (sata_device.satadev_type & SATA_DTYPE_ATADISK) != 0) { | |
| 10288 /* | |
| 10289 * We may retry this a bit later - reinstate reset | |
| 10290 * condition | |
| 10291 */ | |
| 10292 if ((cportinfo->cport_dev_type & | |
| 10293 SATA_VALID_DEV_TYPE) != 0 && | |
| 10294 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10295 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10296 sdinfo->satadrv_event_flags |= | |
| 10297 SATA_EVNT_DEVICE_RESET; | |
| 10298 sdinfo->satadrv_event_flags &= | |
| 10299 ~SATA_EVNT_INPROC_DEVICE_RESET; | |
| 10300 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, | |
| 10301 saddr->cport)->cport_mutex); | |
| 10302 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10303 sata_hba_inst->satahba_event_flags |= | |
| 10304 SATA_EVNT_MAIN; | |
| 10305 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10306 return; | |
| 10307 } | |
| 10308 } else { | |
| 10309 /* | |
| 10310 * No point of retrying - some other event processing | |
| 10311 * would or already did port info cleanup. | |
| 10312 * To be safe (HBA may need it), | |
| 10313 * request clearing device reset condition. | |
| 10314 */ | |
| 10315 sdinfo->satadrv_event_flags = 0; | |
| 10316 sdinfo->satadrv_event_flags |= | |
| 10317 SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 10318 } | |
| 10319 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10320 cport_mutex); | |
| 10321 return; | |
| 10322 } | |
| 10323 | |
| 10324 /* | |
| 10325 * Raise the flag indicating that the next sata command could | |
| 10326 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device | |
| 10327 * reset is reported. | |
| 10328 */ | |
| 10329 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10330 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 && | |
| 10331 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10332 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10333 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; | |
| 10334 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; | |
| 10335 } | |
| 10336 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10337 } | |
| 10338 | |
| 10339 | |
| 10340 /* | |
| 10341 * Port Link Events processing. | |
| 10342 * Every link established event may involve device reset (due to | |
| 10343 * COMRESET signal, equivalent of the hard reset) so arbitrarily | |
| 10344 * set device reset event for an attached device (if any). | |
| 10345 * If the port is in SHUTDOWN or FAILED state, ignore link events. | |
| 10346 * | |
| 10347 * The link established event processing varies, depending on the state | |
| 10348 * of the target node, HBA hotplugging capabilities, state of the port. | |
| 10349 * If the link is not active, the link established event is ignored. | |
| 10350 * If HBA cannot detect device attachment and there is no target node, | |
| 10351 * the link established event triggers device attach event processing. | |
| 10352 * Else, link established event triggers device reset event processing. | |
| 10353 * | |
| 10354 * The link lost event processing varies, depending on a HBA hotplugging | |
| 10355 * capability and the state of the port (link active or not active). | |
| 10356 * If the link is active, the lost link event is ignored. | |
| 10357 * If HBA cannot detect device removal, the lost link event triggers | |
| 10358 * device detached event processing after link lost timeout. | |
| 10359 * Else, the event is ignored. | |
| 10360 * | |
| 10361 * NOTE: Only cports are processed for now, i.e. no port multiplier ports | |
| 10362 */ | |
| 10363 static void | |
| 10364 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, | |
| 10365 sata_address_t *saddr) | |
| 10366 { | |
| 10367 sata_device_t sata_device; | |
| 10368 sata_cport_info_t *cportinfo; | |
| 10369 sata_drive_info_t *sdinfo; | |
| 10370 int event_flags; | |
| 10371 int rval; | |
| 10372 | |
| 10373 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10374 "Processing port %d link event(s)", saddr->cport); | |
| 10375 | |
| 10376 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10377 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10378 event_flags = cportinfo->cport_event_flags; | |
| 10379 | |
| 10380 /* Reset event flags first */ | |
| 10381 cportinfo->cport_event_flags &= | |
| 10382 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); | |
| 10383 | |
| 10384 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ | |
| 10385 if ((cportinfo->cport_state & | |
| 10386 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10387 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10388 cport_mutex); | |
| 10389 return; | |
| 10390 } | |
| 10391 | |
| 10392 /* | |
| 10393 * For the sanity sake get current port state. | |
| 10394 * Set device address only. Other sata_device fields should be | |
| 10395 * set by HBA driver. | |
| 10396 */ | |
| 10397 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10398 sata_device.satadev_addr = *saddr; | |
| 10399 /* | |
| 10400 * We have to exit mutex, because the HBA probe port function may | |
| 10401 * block on its own mutex. | |
| 10402 */ | |
| 10403 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10404 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10405 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10406 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10407 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 10408 if (rval != SATA_SUCCESS) { | |
| 10409 /* Something went wrong? Fail the port */ | |
| 10410 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10411 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10412 cport_mutex); | |
| 10413 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed", | |
| 10414 saddr->cport)); | |
| 10415 /* | |
| 10416 * We may want to release device info structure, but | |
| 10417 * it is not necessary. | |
| 10418 */ | |
| 10419 return; | |
| 10420 } else { | |
| 10421 /* port probed successfully */ | |
| 10422 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; | |
| 10423 } | |
| 10424 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { | |
| 10425 | |
| 10426 if ((sata_device.satadev_scr.sstatus & | |
| 10427 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { | |
| 10428 /* Ignore event */ | |
| 10429 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10430 "Ignoring port %d link established event - " | |
| 10431 "link down", | |
| 10432 saddr->cport); | |
| 10433 goto linklost; | |
| 10434 } | |
| 10435 | |
| 10436 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10437 "Processing port %d link established event", | |
| 10438 saddr->cport); | |
| 10439 | |
| 10440 /* | |
| 10441 * For the sanity sake check if a device is attached - check | |
| 10442 * return state of a port probing. | |
| 10443 */ | |
| 10444 if (sata_device.satadev_type != SATA_DTYPE_NONE && | |
| 10445 sata_device.satadev_type != SATA_DTYPE_PMULT) { | |
| 10446 /* | |
| 10447 * HBA port probe indicated that there is a device | |
| 10448 * attached. Check if the framework had device info | |
| 10449 * structure attached for this device. | |
| 10450 */ | |
| 10451 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { | |
| 10452 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != | |
| 10453 NULL); | |
| 10454 | |
| 10455 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10456 if ((sdinfo->satadrv_type & | |
| 10457 SATA_VALID_DEV_TYPE) != 0) { | |
| 10458 /* | |
| 10459 * Dev info structure is present. | |
| 10460 * If dev_type is set to known type in | |
| 10461 * the framework's drive info struct | |
| 10462 * then the device existed before and | |
| 10463 * the link was probably lost | |
| 10464 * momentarily - in such case | |
| 10465 * we may want to check device | |
| 10466 * identity. | |
| 10467 * Identity check is not supported now. | |
| 10468 * | |
| 10469 * Link established event | |
| 10470 * triggers device reset event. | |
| 10471 */ | |
| 10472 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> | |
| 10473 satadrv_event_flags |= | |
| 10474 SATA_EVNT_DEVICE_RESET; | |
| 10475 } | |
| 10476 } else if (cportinfo->cport_dev_type == | |
| 10477 SATA_DTYPE_NONE) { | |
| 10478 /* | |
| 10479 * We got new device attached! If HBA does not | |
| 10480 * generate device attached events, trigger it | |
| 10481 * here. | |
| 10482 */ | |
| 10483 if (!(SATA_FEATURES(sata_hba_inst) & | |
| 10484 SATA_CTLF_HOTPLUG)) { | |
| 10485 cportinfo->cport_event_flags |= | |
| 10486 SATA_EVNT_DEVICE_ATTACHED; | |
| 10487 } | |
| 10488 } | |
| 10489 /* Reset link lost timeout */ | |
| 10490 cportinfo->cport_link_lost_time = 0; | |
| 10491 } | |
| 10492 } | |
| 10493 linklost: | |
| 10494 if (event_flags & SATA_EVNT_LINK_LOST) { | |
| 10495 if ((sata_device.satadev_scr.sstatus & | |
| 10496 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { | |
| 10497 /* Ignore event */ | |
| 10498 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10499 "Ignoring port %d link lost event - link is up", | |
| 10500 saddr->cport); | |
| 10501 goto done; | |
| 10502 } | |
| 10503 #ifdef SATA_DEBUG | |
| 10504 if (cportinfo->cport_link_lost_time == 0) { | |
| 10505 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10506 "Processing port %d link lost event", | |
| 10507 saddr->cport); | |
| 10508 } | |
| 10509 #endif | |
| 10510 /* | |
| 10511 * When HBA cannot generate device attached/detached events, | |
| 10512 * we need to track link lost time and eventually generate | |
| 10513 * device detach event. | |
| 10514 */ | |
| 10515 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { | |
| 10516 /* We are tracking link lost time */ | |
| 10517 if (cportinfo->cport_link_lost_time == 0) { | |
| 10518 /* save current time (lbolt value) */ | |
| 10519 cportinfo->cport_link_lost_time = | |
| 10520 ddi_get_lbolt(); | |
| 10521 /* just keep link lost event */ | |
| 10522 cportinfo->cport_event_flags |= | |
| 10523 SATA_EVNT_LINK_LOST; | |
| 10524 } else { | |
| 10525 clock_t cur_time = ddi_get_lbolt(); | |
| 10526 if ((cur_time - | |
| 10527 cportinfo->cport_link_lost_time) >= | |
| 10528 drv_usectohz( | |
| 10529 SATA_EVNT_LINK_LOST_TIMEOUT)) { | |
| 10530 /* trigger device detach event */ | |
| 10531 cportinfo->cport_event_flags |= | |
| 10532 SATA_EVNT_DEVICE_DETACHED; | |
| 10533 cportinfo->cport_link_lost_time = 0; | |
| 10534 SATADBG1(SATA_DBG_EVENTS, | |
| 10535 sata_hba_inst, | |
| 10536 "Triggering port %d " | |
| 10537 "device detached event", | |
| 10538 saddr->cport); | |
| 10539 } else { | |
| 10540 /* keep link lost event */ | |
| 10541 cportinfo->cport_event_flags |= | |
| 10542 SATA_EVNT_LINK_LOST; | |
| 10543 } | |
| 10544 } | |
| 10545 } | |
| 10546 /* | |
| 10547 * We could change port state to disable/delay access to | |
| 10548 * the attached device until the link is recovered. | |
| 10549 */ | |
| 10550 } | |
| 10551 done: | |
| 10552 event_flags = cportinfo->cport_event_flags; | |
| 10553 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10554 if (event_flags != 0) { | |
| 10555 mutex_enter(&sata_hba_inst->satahba_mutex); | |
| 10556 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; | |
| 10557 mutex_exit(&sata_hba_inst->satahba_mutex); | |
| 10558 mutex_enter(&sata_mutex); | |
| 10559 sata_event_pending |= SATA_EVNT_MAIN; | |
| 10560 mutex_exit(&sata_mutex); | |
| 10561 } | |
| 10562 } | |
| 10563 | |
| 10564 /* | |
| 10565 * Device Detached Event processing. | |
| 10566 * Port is probed to find if a device is really gone. If so, | |
| 10567 * the device info structure is detached from the SATA port info structure | |
| 10568 * and released. | |
| 10569 * Port status is updated. | |
| 10570 * | |
| 10571 * NOTE: Process cports event only, no port multiplier ports. | |
| 10572 */ | |
| 10573 static void | |
| 10574 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, | |
| 10575 sata_address_t *saddr) | |
| 10576 { | |
| 10577 sata_cport_info_t *cportinfo; | |
| 10578 sata_drive_info_t *sdevinfo; | |
| 10579 sata_device_t sata_device; | |
| 10580 dev_info_t *tdip; | |
| 10581 int rval; | |
| 10582 | |
| 10583 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10584 "Processing port %d device detached", saddr->cport); | |
| 10585 | |
| 10586 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10587 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10588 /* Clear event flag */ | |
| 10589 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; | |
| 10590 | |
| 10591 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ | |
| 10592 if ((cportinfo->cport_state & | |
| 10593 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10594 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10595 cport_mutex); | |
| 10596 return; | |
| 10597 } | |
| 10598 /* For sanity, re-probe the port */ | |
| 10599 sata_device.satadev_rev = SATA_DEVICE_REV; | |
| 10600 sata_device.satadev_addr = *saddr; | |
| 10601 | |
| 10602 /* | |
| 10603 * We have to exit mutex, because the HBA probe port function may | |
| 10604 * block on its own mutex. | |
| 10605 */ | |
| 10606 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10607 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) | |
| 10608 (SATA_DIP(sata_hba_inst), &sata_device); | |
| 10609 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10610 sata_update_port_info(sata_hba_inst, &sata_device); | |
| 10611 if (rval != SATA_SUCCESS) { | |
| 10612 /* Something went wrong? Fail the port */ | |
| 10613 cportinfo->cport_state = SATA_PSTATE_FAILED; | |
| 10614 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10615 cport_mutex); | |
| 10616 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed", | |
| 10617 saddr->cport)); | |
| 10618 /* | |
| 10619 * We may want to release device info structure, but | |
| 10620 * it is not necessary. | |
| 10621 */ | |
| 10622 return; | |
| 10623 } else { | |
| 10624 /* port probed successfully */ | |
| 10625 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; | |
| 10626 } | |
| 10627 /* | |
| 10628 * Check if a device is still attached. For sanity, check also | |
| 10629 * link status - if no link, there is no device. | |
| 10630 */ | |
| 10631 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == | |
| 10632 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != | |
| 10633 SATA_DTYPE_NONE) { | |
| 10634 /* | |
| 10635 * Device is still attached - ignore detach event. | |
| 10636 */ | |
| 10637 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10638 cport_mutex); | |
| 10639 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10640 "Ignoring detach - device still attached to port %d", | |
| 10641 sata_device.satadev_addr.cport); | |
| 10642 return; | |
| 10643 } | |
| 10644 /* | |
| 10645 * We need to detach and release device info structure here | |
| 10646 */ | |
| 10647 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10648 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10649 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 10650 (void) kmem_free((void *)sdevinfo, | |
| 10651 sizeof (sata_drive_info_t)); | |
| 10652 } | |
| 10653 cportinfo->cport_dev_type = SATA_DTYPE_NONE; | |
| 10654 /* | |
| 10655 * Device cannot be reached anymore, even if the target node may be | |
| 10656 * still present. | |
| 10657 */ | |
| 10658 | |
| 10659 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10660 sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d", | |
| 10661 sata_device.satadev_addr.cport); | |
| 10662 | |
| 10663 /* | |
| 10664 * Try to offline a device and remove target node if it still exists | |
| 10665 */ | |
| 10666 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); | |
| 10667 if (tdip != NULL) { | |
| 10668 /* | |
| 10669 * target node exist - unconfigure device first, then remove | |
| 10670 * the node | |
| 10671 */ | |
| 10672 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { | |
| 10673 /* | |
| 10674 * PROBLEM - no device, but target node remained | |
| 10675 * This happens when the file was open or node was | |
| 10676 * waiting for resources. | |
| 10677 */ | |
| 10678 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10679 "sata_process_device_detached: " | |
| 10680 "Failed to unconfigure removed device.")); | |
| 10681 } | |
| 10682 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { | |
| 10683 /* | |
| 10684 * PROBLEM - no device, but target node remained | |
| 10685 * This happens when the file was open or node was | |
| 10686 * waiting for resources. | |
| 10687 */ | |
| 10688 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10689 "sata_process_device_detached: " | |
| 10690 "Failed to remove target node for " | |
| 10691 "removed device.")); | |
| 10692 } | |
| 10693 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10694 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10695 * 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
|
10696 * with the hint: SE_HINT_REMOVE |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10697 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10698 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); |
| 1258 | 10699 } |
| 10700 | |
| 10701 | |
| 10702 /* | |
| 10703 * Device Attached Event processing. | |
| 10704 * Port state is checked to verify that a device is really attached. If so, | |
| 10705 * the device info structure is created and attached to the SATA port info | |
| 10706 * structure. | |
| 10707 * | |
| 10708 * This function cannot be called in interrupt context (it may sleep). | |
| 10709 * | |
| 10710 * NOTE: Process cports event only, no port multiplier ports. | |
| 10711 */ | |
| 10712 static void | |
| 10713 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, | |
| 10714 sata_address_t *saddr) | |
| 10715 { | |
| 10716 sata_cport_info_t *cportinfo; | |
| 10717 sata_drive_info_t *sdevinfo; | |
| 10718 sata_device_t sata_device; | |
| 10719 dev_info_t *tdip; | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10720 int rval; |
| 1258 | 10721 |
| 10722 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, | |
| 10723 "Processing port %d device attached", saddr->cport); | |
| 10724 | |
| 10725 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); | |
| 10726 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10727 | |
| 10728 /* Clear event flag first */ | |
| 10729 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; | |
| 10730 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ | |
| 10731 if ((cportinfo->cport_state & | |
| 10732 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { | |
| 10733 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> | |
| 10734 cport_mutex); | |
| 10735 return; | |
| 10736 } | |
| 10737 | |
| 10738 /* | |
| 10739 * If the sata_drive_info structure is found attached to the port info, | |
| 10740 * something went wrong in the event reporting and processing sequence. | |
| 10741 * To recover, arbitrarily release device info structure and issue | |
| 10742 * a warning. | |
| 10743 */ | |
| 10744 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { | |
| 10745 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); | |
| 10746 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; | |
| 10747 (void) kmem_free((void *)sdevinfo, | |
| 10748 sizeof (sata_drive_info_t)); | |
| 10749 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10750 "Arbitrarily detaching old device info.")); | |
| 10751 } | |
| 10752 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
|
10753 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10754 /* For sanity, re-probe the port */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10755 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
|
10756 sata_device.satadev_addr = *saddr; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10757 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10758 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10759 * 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
|
10760 * block on its own mutex. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10761 */ |
| 1258 | 10762 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
|
10763 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
|
10764 (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
|
10765 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
|
10766 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
|
10767 if (rval != SATA_SUCCESS) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10768 /* Something went wrong? Fail the port */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10769 cportinfo->cport_state = SATA_PSTATE_FAILED; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10770 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
|
10771 cport_mutex); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10772 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
|
10773 saddr->cport)); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10774 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10775 } else { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10776 /* port probed successfully */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10777 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
|
10778 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10779 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10780 * 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
|
10781 * 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
|
10782 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10783 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
|
10784 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
|
10785 SATA_DTYPE_NONE) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10786 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10787 * No device - ignore attach event. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10788 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10789 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
|
10790 cport_mutex); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10791 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
|
10792 "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
|
10793 sata_device.satadev_addr.cport); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10794 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10795 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10796 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10797 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
|
10798 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10799 * 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
|
10800 * with the hint: SE_HINT_INSERT |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10801 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10802 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
|
10803 |
| 1258 | 10804 /* |
| 10805 * Make sure that there is no target node for that device. | |
| 10806 * If so, release it. It should not happen, unless we had problem | |
| 10807 * removing the node when device was detached. | |
| 10808 */ | |
| 10809 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); | |
| 10810 if (tdip != NULL) { | |
| 10811 | |
| 10812 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10813 "sata_process_device_attached: " | |
| 10814 "old device target node exists!!!")); | |
| 10815 /* | |
| 10816 * target node exist - unconfigure device first, then remove | |
| 10817 * the node | |
| 10818 */ | |
| 10819 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { | |
| 10820 /* | |
| 10821 * PROBLEM - no device, but target node remained | |
| 10822 * This happens when the file was open or node was | |
| 10823 * waiting for resources. | |
| 10824 */ | |
| 10825 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10826 "sata_process_device_attached: " | |
| 10827 "Failed to unconfigure old target node!")); | |
| 10828 } | |
| 10829 /* Following call will retry node offlining and removing it */ | |
| 10830 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { | |
| 10831 /* PROBLEM - no device, but target node remained */ | |
| 10832 SATA_LOG_D((sata_hba_inst, CE_WARN, | |
| 10833 "sata_process_device_attached: " | |
| 10834 "Failed to remove old target node!")); | |
| 10835 /* | |
| 10836 * It is not clear, what should be done here. | |
| 10837 * For now, we will not attach a new device | |
| 10838 */ | |
| 10839 return; | |
| 10840 } | |
| 10841 } | |
| 10842 | |
| 10843 /* | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10844 * 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
|
10845 * structure and determination of the device type. |
| 1258 | 10846 */ |
| 10847 sata_device.satadev_addr = *saddr; | |
| 10848 (void) sata_reprobe_port(sata_hba_inst, &sata_device); | |
| 10849 /* | |
| 10850 * If device was successfully attached, an explicit | |
| 10851 * 'configure' command is needed to configure it. | |
| 10852 */ | |
| 10853 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10854 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
|
10855 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
|
10856 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
|
10857 "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
|
10858 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10859 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
|
10860 sata_drive_info_t new_sdinfo; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10861 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10862 /* Log device info data */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10863 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
|
10864 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
|
10865 } |
| 1258 | 10866 } |
| 10867 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); | |
| 10868 } | |
| 10869 | |
| 10870 | |
| 10871 /* | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10872 * sata_set_drive_featues function compares current device features setting |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10873 * 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
|
10874 * it restores device features setting to the previously saved state. |
| 1258 | 10875 * Device Identify data has to be current. |
| 10876 * At the moment only read ahead and write cache settings are considered. | |
| 10877 * | |
| 10878 * This function cannot be called in the interrupt context (it may sleep). | |
| 10879 * | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10880 * 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
|
10881 * to be updated after features are set. |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10882 * |
| 1258 | 10883 * Returns TRUE if successful or there was nothing to do. |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10884 * Returns FALSE if device features cound not be set . |
| 1258 | 10885 * |
| 10886 * Note: This function may fail the port, making it inaccessible. | |
| 10887 * Explicit port disconnect/connect or physical device | |
| 10888 * detach/attach is required to re-evaluate it's state afterwards | |
| 10889 */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10890 |
| 1258 | 10891 static int |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10892 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
|
10893 sata_drive_info_t *sdinfo, int restore) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10894 { |
| 1258 | 10895 int rval = SATA_SUCCESS; |
| 10896 sata_drive_info_t new_sdinfo; | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10897 char *finfo = "sata_set_drive_features: cannot"; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10898 char *finfox; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10899 int cache_op; |
| 1258 | 10900 |
| 10901 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); | |
| 10902 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; | |
| 10903 new_sdinfo.satadrv_type = sdinfo->satadrv_type; | |
| 10904 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { | |
| 10905 /* | |
| 10906 * Cannot get device identification - retry later | |
| 10907 */ | |
| 10908 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
|
10909 "%s fetch device identify data\n", finfo)); |
| 1258 | 10910 return (SATA_FAILURE); |
| 10911 } | |
| 10912 /* Arbitrarily set UDMA mode */ | |
| 10913 if (sata_set_udma_mode(sata_hba_inst, &new_sdinfo) != SATA_SUCCESS) { | |
| 10914 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
|
10915 "%s set UDMA mode\n", finfo)); |
| 1258 | 10916 return (SATA_FAILURE); |
| 10917 } | |
| 10918 | |
| 10919 if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && | |
| 10920 !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { | |
| 10921 /* None of the features is supported - do nothing */ | |
| 10922 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
|
10923 "settable features not supported\n", NULL); |
| 1258 | 10924 return (SATA_SUCCESS); |
| 10925 } | |
| 10926 | |
| 10927 if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && | |
| 10928 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && | |
| 10929 ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && | |
| 10930 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { | |
| 10931 /* Nothing to do */ | |
| 10932 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
|
10933 "no device features to set\n", NULL); |
| 1258 | 10934 return (SATA_SUCCESS); |
| 10935 } | |
| 10936 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10937 finfox = (restore != 0) ? " restore device features" : |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10938 " initialize device features\n"; |
| 1258 | 10939 |
| 10940 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && | |
| 10941 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) { | |
| 10942 if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) | |
| 10943 /* Enable read ahead / read cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10944 cache_op = SATAC_SF_ENABLE_READ_AHEAD; |
| 1258 | 10945 else |
| 10946 /* Disable read ahead / read cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10947 cache_op = SATAC_SF_DISABLE_READ_AHEAD; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10948 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10949 /* Try to set read cache mode */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10950 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
|
10951 cache_op) != SATA_SUCCESS) { |
| 1258 | 10952 /* Pkt execution failed */ |
| 10953 rval = SATA_FAILURE; | |
| 10954 } | |
| 10955 } | |
| 10956 | |
| 10957 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && | |
| 10958 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { | |
| 10959 if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) | |
| 10960 /* Enable write cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10961 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; |
| 1258 | 10962 else |
| 10963 /* Disable write cache */ | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10964 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10965 |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10966 /* Try to set write cache mode */ |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10967 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
|
10968 cache_op) != SATA_SUCCESS) { |
| 1258 | 10969 /* Pkt execution failed */ |
| 10970 rval = SATA_FAILURE; | |
| 10971 } | |
| 10972 } | |
| 10973 | |
|
1781
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10974 if (rval == SATA_FAILURE) |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10975 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
1005b1d56b1c
6397649 hotplugging sata disk may disable write and read cache
pawelw
parents:
1675
diff
changeset
|
10976 "%s %s", finfo, finfox)); |
| 1258 | 10977 |
| 10978 /* | |
| 10979 * We need to fetch Device Identify data again | |
| 10980 */ | |
| 10981 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { | |
| 10982 /* | |
| 10983 * Cannot get device identification - retry later | |
| 10984 */ | |
| 10985 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
|
10986 "%s cannot re-fetch device identify data\n")); |
| 1258 | 10987 rval = SATA_FAILURE; |
| 10988 } | |
| 10989 /* Copy device sata info. */ | |
| 10990 sdinfo->satadrv_id = new_sdinfo.satadrv_id; | |
| 10991 | |
| 10992 return (rval); | |
| 10993 } | |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10994 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
10995 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10996 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10997 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10998 * Returns 1 if threshold exceeded, 0 if threshold no exceeded, -1 if |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
10999 * unable to determine. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11000 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11001 * Cannot be called in an interrupt context. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11002 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11003 * Called by sata_build_lsense_page_2f() |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11004 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11005 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11006 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11007 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
|
11008 sata_drive_info_t *sdinfo) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11009 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11010 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11011 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11012 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11013 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11014 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11015 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
|
11016 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11017 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
|
11018 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11019 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11020 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11021 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11022 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11023 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11024 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11025 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11026 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11027 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11028 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11029 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
|
11030 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11031 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11032 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11033 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11034 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11035 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11036 scmd->satacmd_flags.sata_special_regs = B_TRUE; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11037 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
|
11038 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11039 /* Set up which registers need to be returned */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11040 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
|
11041 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
|
11042 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11043 /* 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
|
11044 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11045 scmd->satacmd_sec_count_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11046 scmd->satacmd_lba_low_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11047 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
|
11048 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
|
11049 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11050 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11051 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11052 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11053 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11054 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11055 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11056 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11057 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
|
11058 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11059 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11060 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11061 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11062 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11063 * Whoops, no SMART RETURN STATUS |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11064 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11065 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11066 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11067 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11068 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11069 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11070 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11071 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11072 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11073 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11074 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11075 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11076 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11077 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
|
11078 (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
|
11079 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11080 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
|
11081 (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
|
11082 rval = 1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11083 else { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11084 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11085 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11086 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11087 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11088 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11089 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11090 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11091 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11092 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11093 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11094 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11095 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11096 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11097 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11098 * Returns 0 if succeeded, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11099 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11100 * Cannot be called in an interrupt context. |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11101 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11102 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11103 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11104 sata_fetch_smart_data( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11105 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11106 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11107 struct smart_data *smart_data) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11108 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11109 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11110 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11111 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11112 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11113 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11114 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11115 ASSERT(sizeof (struct smart_data) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11116 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11117 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11118 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
|
11119 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11120 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
|
11121 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11122 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11123 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11124 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11125 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11126 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11127 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11128 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11129 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11130 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11131 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11132 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
|
11133 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11134 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11135 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11136 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11137 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11138 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11139 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
|
11140 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11141 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11142 * Allocate buffer for SMART data |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11143 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11144 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11145 sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11146 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11147 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11148 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11149 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11150 "sata_fetch_smart_data: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11151 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11152 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11153 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11154 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11155 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11156 /* 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
|
11157 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11158 scmd->satacmd_sec_count_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11159 scmd->satacmd_lba_low_lsb = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11160 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
|
11161 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
|
11162 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11163 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11164 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11165 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11166 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11167 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11168 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11169 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
|
11170 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11171 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11172 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11173 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11174 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11175 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11176 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11177 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11178 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11179 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11180 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11181 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11182 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
|
11183 DDI_DMA_SYNC_FORKERNEL); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11184 if (rval != DDI_SUCCESS) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11185 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11186 "sata_fetch_smart_data: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11187 "sync pkt failed")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11188 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11189 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11190 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11191 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
|
11192 sizeof (struct smart_data)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11193 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11194 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11195 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11196 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11197 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11198 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
|
11199 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11200 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11201 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11202 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11203 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11204 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11205 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11206 * Used by LOG SENSE page 0x10 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11207 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11208 * return 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11209 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11210 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11211 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11212 sata_ext_smart_selftest_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11213 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11214 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11215 struct smart_ext_selftest_log *ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11216 uint16_t block_num) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11217 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11218 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11219 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11220 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11221 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11222 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11223 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11224 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11225 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11226 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11227 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
|
11228 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11229 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
|
11230 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11231 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11232 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11233 return (-1); |
|
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 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11236 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11237 |
|
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 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11240 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11241 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
|
11242 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11243 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11244 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11245 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11246 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11247 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11248 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
|
11249 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11250 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11251 * Allocate buffer for SMART extended self-test log |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11252 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11253 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11254 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11255 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11256 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11257 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11258 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11259 "sata_ext_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11260 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11261 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11262 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11263 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11264 /* 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
|
11265 scmd->satacmd_addr_type = ATA_ADDR_LBA48; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11266 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
|
11267 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
|
11268 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
|
11269 scmd->satacmd_lba_low_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11270 scmd->satacmd_lba_mid_lsb = block_num & 0xff; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11271 scmd->satacmd_lba_mid_msb = block_num >> 8; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11272 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11273 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11274 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11275 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11276 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11277 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11278 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11279 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
|
11280 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11281 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11282 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11283 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11284 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11285 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11286 * Whoops, no SMART selftest log info available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11287 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11288 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11289 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11290 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11291 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11292 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11293 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11294 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
|
11295 DDI_DMA_SYNC_FORKERNEL); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11296 if (rval != DDI_SUCCESS) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11297 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11298 "sata_ext_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11299 "sync pkt failed")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11300 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11301 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11302 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11303 bcopy(scmd->satacmd_bp->b_un.b_addr, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11304 (uint8_t *)ext_selftest_log, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11305 sizeof (struct smart_ext_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11306 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11307 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11308 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11309 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11310 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11311 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11312 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
|
11313 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11314 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11315 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11316 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11317 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11318 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11319 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11320 * Returns 0 for success, -1 otherwise |
|
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 * 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
|
11323 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11324 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11325 sata_smart_selftest_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11326 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11327 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11328 struct smart_selftest_log *selftest_log) |
|
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 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11331 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11332 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11333 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11334 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11335 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11336 ASSERT(sizeof (struct smart_selftest_log) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11337 #endif |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11338 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11339 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
|
11340 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11341 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
|
11342 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11343 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11344 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11345 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11346 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11347 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11348 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11349 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11350 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11351 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11352 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11353 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
|
11354 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11355 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11356 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11357 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11358 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11359 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11360 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
|
11361 |
|
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 * Allocate buffer for Identify Data return data |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11364 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11365 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11366 sizeof (struct smart_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11367 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11368 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11369 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11370 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11371 "sata_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11372 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11373 return (-1); |
|
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 /* 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
|
11377 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11378 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
|
11379 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
|
11380 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
|
11381 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
|
11382 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11383 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11384 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11385 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11386 sdinfo->satadrv_addr.cport))); |
|
1612
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 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11389 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
|
11390 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11391 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11392 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11393 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11394 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11395 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11396 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11397 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11398 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11399 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11400 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11401 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11402 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
|
11403 DDI_DMA_SYNC_FORKERNEL); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11404 if (rval != DDI_SUCCESS) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11405 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11406 "sata_smart_selftest_log: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11407 "sync pkt failed")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11408 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11409 goto fail; |
|
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 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
|
11412 sizeof (struct smart_selftest_log)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11413 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11414 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11415 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11416 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11417 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11418 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11419 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
|
11420 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11421 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
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 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11424 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11425 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11426 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11427 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11428 * Returns 0 for success, -1 otherwise |
|
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 * 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
|
11431 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11432 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11433 sata_smart_read_log( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11434 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11435 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11436 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
|
11437 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
|
11438 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
|
11439 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11440 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11441 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11442 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11443 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11444 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11445 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
|
11446 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11447 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
|
11448 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11449 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11450 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11451 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11452 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11453 /* address is needed now */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11454 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11455 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11456 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11457 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11458 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11459 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
|
11460 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11461 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11462 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11463 spkt->satapkt_time = sata_default_pkt_time; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11464 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11465 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11466 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
|
11467 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11468 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11469 * Allocate buffer for SMART READ LOG |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11470 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11471 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
|
11472 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11473 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11474 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11475 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11476 "sata_smart_read_log: " "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11477 return (-1); |
|
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 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11480 /* 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
|
11481 scmd->satacmd_addr_type = 0; /* N/A */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11482 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
|
11483 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
|
11484 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
|
11485 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
|
11486 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11487 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11488 scmd->satacmd_cmd_reg = SATAC_SMART; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11489 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11490 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11491 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11492 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11493 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11494 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
|
11495 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11496 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11497 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11498 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11499 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11500 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11501 * Whoops, no SMART DATA available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11502 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11503 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11504 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11505 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11506 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11507 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11508 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11509 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
|
11510 DDI_DMA_SYNC_FORKERNEL); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11511 if (rval != DDI_SUCCESS) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11512 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11513 "sata_smart_read_log: " "sync pkt failed")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11514 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11515 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11516 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11517 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
|
11518 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11519 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11520 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11521 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11522 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11523 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11524 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
|
11525 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11526 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11527 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11528 return (rval); |
|
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 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11532 * Used by LOG SENSE page 0x10 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11533 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11534 * return 0 for success, -1 otherwise |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11535 * |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11536 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11537 static int |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11538 sata_read_log_ext_directory( |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11539 sata_hba_inst_t *sata_hba_inst, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11540 sata_drive_info_t *sdinfo, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11541 struct read_log_ext_directory *logdir) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11542 { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11543 sata_pkt_txlate_t *spx; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11544 sata_pkt_t *spkt; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11545 sata_cmd_t *scmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11546 int rval; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11547 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11548 #if ! defined(lint) |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11549 ASSERT(sizeof (struct read_log_ext_directory) == 512); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11550 #endif |
|
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 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
|
11553 spx->txlt_sata_hba_inst = sata_hba_inst; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11554 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
|
11555 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11556 if (spkt == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11557 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11558 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11559 } |
|
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 /* Fill sata_pkt */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11562 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11563 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
|
11564 /* Synchronous mode, no callback */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11565 spkt->satapkt_comp = NULL; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11566 /* Timeout 30s */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11567 spkt->satapkt_time = sata_default_pkt_time; |
|
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 scmd = &spkt->satapkt_cmd; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11570 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
|
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 * Allocate buffer for SMART extended self-test log |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11574 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11575 scmd->satacmd_bp = sata_alloc_local_buffer(spx, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11576 sizeof (struct read_log_ext_directory)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11577 if (scmd->satacmd_bp == NULL) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11578 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11579 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11580 SATA_LOG_D((sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11581 "sata_read_log_ext_directory: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11582 "cannot allocate buffer")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11583 return (-1); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11584 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11585 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11586 /* 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
|
11587 scmd->satacmd_addr_type = ATA_ADDR_LBA48; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11588 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
|
11589 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
|
11590 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
|
11591 scmd->satacmd_lba_low_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11592 scmd->satacmd_lba_mid_lsb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11593 scmd->satacmd_lba_mid_msb = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11594 scmd->satacmd_device_reg = 0; /* Always device 0 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11595 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11596 |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11597 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11598 sdinfo->satadrv_addr.cport))); |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11599 |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11600 /* Send pkt to SATA HBA driver */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11601 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
|
11602 SATA_TRAN_ACCEPTED || |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11603 spkt->satapkt_reason != SATA_PKT_COMPLETED) { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11604 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11605 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11606 /* |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11607 * Whoops, no SMART selftest log info available |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11608 */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11609 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11610 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11611 } else { |
|
1940
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11612 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, |
|
c302ad4d1aa7
6404894 Informational exceptions log parameter should be 4 bytes
ls24207
parents:
1781
diff
changeset
|
11613 sdinfo->satadrv_addr.cport))); |
|
1612
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11614 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
|
11615 DDI_DMA_SYNC_FORKERNEL); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11616 if (rval != DDI_SUCCESS) { |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11617 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11618 "sata_read_log_ext_directory: " |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11619 "sync pkt failed")); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11620 rval = -1; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11621 goto fail; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11622 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11623 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
|
11624 sizeof (struct read_log_ext_directory)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11625 rval = 0; |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11626 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11627 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11628 fail: |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11629 /* Free allocated resources */ |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11630 sata_free_local_buffer(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11631 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
|
11632 sata_pkt_free(spx); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11633 kmem_free(spx, sizeof (sata_pkt_txlate_t)); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11634 |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11635 return (rval); |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11636 } |
|
f22bd5bc2aff
6369698 sata framework needs to support SCSI LOG SENSE command
ls24207
parents:
1529
diff
changeset
|
11637 |
|
1529
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11638 static void |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11639 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
|
11640 int hint) |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11641 { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11642 char ap[MAXPATHLEN]; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11643 nvlist_t *ev_attr_list = NULL; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11644 int err; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11645 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11646 /* Allocate and build sysevent attribute list */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11647 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
|
11648 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11649 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
|
11650 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11651 "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
|
11652 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11653 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11654 /* Add hint attribute */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11655 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
|
11656 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11657 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
|
11658 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11659 "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
|
11660 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11661 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11662 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11663 /* |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11664 * Add AP attribute. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11665 * 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
|
11666 * a target number. |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11667 */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11668 (void) snprintf(ap, MAXPATHLEN, "/devices"); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11669 (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
|
11670 (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
|
11671 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
|
11672 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11673 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
|
11674 if (err != 0) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11675 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
|
11676 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11677 "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
|
11678 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11679 return; |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11680 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11681 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11682 /* Generate/log sysevent */ |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11683 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
|
11684 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
|
11685 if (err != DDI_SUCCESS) { |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11686 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
|
11687 "sata_gen_sysevent: " |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11688 "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
|
11689 } |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11690 |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11691 nvlist_free(ev_attr_list); |
|
4fa3374f2b9d
6386938 sata framework should generate sysevent when device is plugged or unplugged
pawelw
parents:
1258
diff
changeset
|
11692 } |
|
1675
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11693 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11694 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11695 * 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
|
11696 * information to SCSI information returned in the SCSI |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11697 * packet. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11698 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11699 static void |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11700 sata_xlate_errors(sata_pkt_txlate_t *spx) |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11701 { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11702 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11703 struct scsi_extended_sense *sense; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11704 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11705 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11706 *scsipkt->pkt_scbp = STATUS_CHECK; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11707 sense = sata_arq_sense(spx); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11708 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11709 switch (spx->txlt_sata_pkt->satapkt_reason) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11710 case SATA_PKT_PORT_ERROR: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11711 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11712 * 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
|
11713 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11714 sense->es_key = KEY_HARDWARE_ERROR; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11715 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11716 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11717 case SATA_PKT_DEV_ERROR: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11718 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
|
11719 SATA_STATUS_ERR) { |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11720 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11721 * determine dev error reason from error |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11722 * reg content |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11723 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11724 sata_decode_device_error(spx, sense); |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11725 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11726 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11727 /* No extended sense key - no info available */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11728 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11729 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11730 case SATA_PKT_TIMEOUT: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11731 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11732 * scsipkt->pkt_reason = CMD_TIMEOUT; This causes problems. |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11733 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11734 scsipkt->pkt_reason = CMD_INCOMPLETE; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11735 /* No extended sense key */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11736 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11737 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11738 case SATA_PKT_ABORTED: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11739 scsipkt->pkt_reason = CMD_ABORTED; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11740 /* No extended sense key */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11741 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11742 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11743 case SATA_PKT_RESET: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11744 /* |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11745 * 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
|
11746 * a host, or due to error recovery |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11747 */ |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11748 scsipkt->pkt_reason = CMD_RESET; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11749 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11750 |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11751 default: |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11752 scsipkt->pkt_reason = CMD_TRAN_ERR; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11753 break; |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11754 } |
|
5791e75682d0
6397847 sata framework has to support Informational Exception Control page
ls24207
parents:
1612
diff
changeset
|
11755 } |